@loaders.gl/terrain 4.0.0-beta.1 → 4.0.0-beta.3

package/dist/quantized-mesh-worker.js

@@ -1,3 +1,4 @@
+"use strict";
 (() => {
   // ../loader-utils/src/loader-types.ts
   async function parseFromContext(data, loaders, options, context) {
@@ -6,7 +7,7 @@
 
   // ../worker-utils/src/lib/worker-utils/get-transfer-list.ts
   function getTransferList(object, recursive = true, transfers) {
-    const transfersSet = transfers || new Set();
+    const transfersSet = transfers || /* @__PURE__ */ new Set();
     if (!object) {
     } else if (isTransferable(object)) {
       transfersSet.add(object);
@@ -49,11 +50,15 @@
     }
     return parentPort;
   }
-  var onMessageWrapperMap = new Map();
+  var onMessageWrapperMap = /* @__PURE__ */ new Map();
   var WorkerBody = class {
+    /** Check that we are actually in a worker thread */
     static inWorkerThread() {
       return typeof self !== "undefined" || Boolean(getParentPort());
     }
+    /*
+     * (type: WorkerMessageType, payload: WorkerMessagePayload) => any
+     */
     static set onmessage(onMessage) {
       function handleMessage(message) {
         const parentPort3 = getParentPort();
@@ -97,6 +102,11 @@
         globalThis.removeEventListener("message", onMessageWrapper);
       }
     }
+    /**
+     * Send a message from a worker to creating thread (main thread)
+     * @param type
+     * @param payload
+     */
     static postMessage(type, payload) {
       const data = { source: "loaders.gl", type, payload };
       const transferList = getTransferList(payload);
@@ -128,6 +138,7 @@
               loader,
               arrayBuffer: input,
               options,
+              // @ts-expect-error fetch missing
               context: {
                 ...context,
                 _parse: parseOnMainThread
@@ -198,7 +209,9 @@
     const arrays = typedArrays;
     const TypedArrayConstructor = arrays && arrays.length > 1 && arrays[0].constructor || null;
     if (!TypedArrayConstructor) {
-      throw new Error('"concatenateTypedArrays" - incorrect quantity of arguments or arguments have incompatible data types');
+      throw new Error(
+        '"concatenateTypedArrays" - incorrect quantity of arguments or arguments have incompatible data types'
+      );
     }
     const sumLength = arrays.reduce((acc, value) => acc + value.length, 0);
     const result = new TypedArrayConstructor(sumLength);
@@ -238,7 +251,7 @@
   }
 
   // src/lib/decode-quantized-mesh.ts
-  var QUANTIZED_MESH_HEADER = new Map([
+  var QUANTIZED_MESH_HEADER = /* @__PURE__ */ new Map([
     ["centerX", Float64Array.BYTES_PER_ELEMENT],
     ["centerY", Float64Array.BYTES_PER_ELEMENT],
     ["centerZ", Float64Array.BYTES_PER_ELEMENT],
@@ -282,7 +295,9 @@
     for (let i = 0; i < vertexCount; i++) {
       u += decodeZigZag(dataView.getUint16(uArrayStartPosition + bytesPerArrayElement * i, true));
       v += decodeZigZag(dataView.getUint16(vArrayStartPosition + bytesPerArrayElement * i, true));
-      height += decodeZigZag(dataView.getUint16(heightArrayStartPosition + bytesPerArrayElement * i, true));
+      height += decodeZigZag(
+        dataView.getUint16(heightArrayStartPosition + bytesPerArrayElement * i, true)
+      );
       vertexData[i] = u;
       vertexData[i + vertexCount] = v;
       vertexData[i + vertexCount * 2] = height;
@@ -321,7 +336,12 @@
     const triangleCount = dataView.getUint32(position, true);
     position += Uint32Array.BYTES_PER_ELEMENT;
     const triangleIndicesCount = triangleCount * 3;
-    const triangleIndices = decodeIndex(dataView.buffer, position, triangleIndicesCount, bytesPerIndex);
+    const triangleIndices = decodeIndex(
+      dataView.buffer,
+      position,
+      triangleIndicesCount,
+      bytesPerIndex
+    );
     position += triangleIndicesCount * bytesPerIndex;
     return {
       triangleIndicesEndPosition: position,
@@ -339,7 +359,13 @@
     position += westVertexCount * bytesPerIndex;
     const southVertexCount = dataView.getUint32(position, true);
     position += Uint32Array.BYTES_PER_ELEMENT;
-    const southIndices = decodeIndex(dataView.buffer, position, southVertexCount, bytesPerIndex, false);
+    const southIndices = decodeIndex(
+      dataView.buffer,
+      position,
+      southVertexCount,
+      bytesPerIndex,
+      false
+    );
     position += southVertexCount * bytesPerIndex;
     const eastVertexCount = dataView.getUint32(position, true);
     position += Uint32Array.BYTES_PER_ELEMENT;
@@ -347,7 +373,13 @@
     position += eastVertexCount * bytesPerIndex;
     const northVertexCount = dataView.getUint32(position, true);
     position += Uint32Array.BYTES_PER_ELEMENT;
-    const northIndices = decodeIndex(dataView.buffer, position, northVertexCount, bytesPerIndex, false);
+    const northIndices = decodeIndex(
+      dataView.buffer,
+      position,
+      northVertexCount,
+      bytesPerIndex,
+      false
+    );
     position += northVertexCount * bytesPerIndex;
     return {
       edgeIndicesEndPosition: position,
@@ -358,10 +390,17 @@
     };
   }
   function decodeVertexNormalsExtension(extensionDataView) {
-    return new Uint8Array(extensionDataView.buffer, extensionDataView.byteOffset, extensionDataView.byteLength);
+    return new Uint8Array(
+      extensionDataView.buffer,
+      extensionDataView.byteOffset,
+      extensionDataView.byteLength
+    );
   }
   function decodeWaterMaskExtension(extensionDataView) {
-    return extensionDataView.buffer.slice(extensionDataView.byteOffset, extensionDataView.byteOffset + extensionDataView.byteLength);
+    return extensionDataView.buffer.slice(
+      extensionDataView.byteOffset,
+      extensionDataView.byteOffset + extensionDataView.byteLength
+    );
   }
   function decodeExtensions(dataView, indicesEndPosition) {
     const extensions = {};
@@ -412,7 +451,11 @@
     if (options.maxDecodingStep < DECODING_STEPS.triangleIndices) {
       return { header, vertexData };
     }
-    const { triangleIndices, triangleIndicesEndPosition } = decodeTriangleIndices(view, vertexData, vertexDataEndPosition);
+    const { triangleIndices, triangleIndicesEndPosition } = decodeTriangleIndices(
+      view,
+      vertexData,
+      vertexDataEndPosition
+    );
     if (options.maxDecodingStep < DECODING_STEPS.edgeIndices) {
       return { header, vertexData, triangleIndices };
     }
@@ -513,12 +556,24 @@
     const positionsLength = attributes.POSITION.value.length;
     const vertex1Offset = edgeIndex * 2;
     const vertex2Offset = edgeIndex * 2 + 1;
-    newPosition.set(attributes.POSITION.value.subarray(edge[0] * 3, edge[0] * 3 + 3), vertex1Offset * 3);
+    newPosition.set(
+      attributes.POSITION.value.subarray(edge[0] * 3, edge[0] * 3 + 3),
+      vertex1Offset * 3
+    );
     newPosition[vertex1Offset * 3 + 2] = newPosition[vertex1Offset * 3 + 2] - skirtHeight;
-    newPosition.set(attributes.POSITION.value.subarray(edge[1] * 3, edge[1] * 3 + 3), vertex2Offset * 3);
+    newPosition.set(
+      attributes.POSITION.value.subarray(edge[1] * 3, edge[1] * 3 + 3),
+      vertex2Offset * 3
+    );
     newPosition[vertex2Offset * 3 + 2] = newPosition[vertex2Offset * 3 + 2] - skirtHeight;
-    newTexcoord0.set(attributes.TEXCOORD_0.value.subarray(edge[0] * 2, edge[0] * 2 + 2), vertex1Offset * 2);
-    newTexcoord0.set(attributes.TEXCOORD_0.value.subarray(edge[1] * 2, edge[1] * 2 + 2), vertex2Offset * 2);
+    newTexcoord0.set(
+      attributes.TEXCOORD_0.value.subarray(edge[0] * 2, edge[0] * 2 + 2),
+      vertex1Offset * 2
+    );
+    newTexcoord0.set(
+      attributes.TEXCOORD_0.value.subarray(edge[1] * 2, edge[1] * 2 + 2),
+      vertex2Offset * 2
+    );
     const triangle1Offset = edgeIndex * 2 * 3;
     newTriangles[triangle1Offset] = edge[0];
     newTriangles[triangle1Offset + 1] = positionsLength / 3 + vertex2Offset;
@@ -544,26 +599,35 @@
     let attributes = getMeshAttributes(vertexData, header, bounds);
     const boundingBox = getMeshBoundingBox(attributes);
     if (options?.skirtHeight) {
-      const { attributes: newAttributes, triangles: newTriangles } = addSkirt(attributes, triangleIndices, options.skirtHeight, {
-        westIndices,
-        northIndices,
-        eastIndices,
-        southIndices
-      });
+      const { attributes: newAttributes, triangles: newTriangles } = addSkirt(
+        attributes,
+        triangleIndices,
+        options.skirtHeight,
+        {
+          westIndices,
+          northIndices,
+          eastIndices,
+          southIndices
+        }
+      );
       attributes = newAttributes;
       triangleIndices = newTriangles;
     }
     return {
+      // Data return by this loader implementation
       loaderData: {
         header: {}
       },
       header: {
+        // @ts-ignore
         vertexCount: triangleIndices.length,
         boundingBox
       },
+      // TODO
       schema: void 0,
       topology: "triangle-list",
       mode: 4,
+      // TRIANGLES
       indices: { value: triangleIndices, size: 1 },
       attributes
     };
@@ -590,6 +654,8 @@
     return {
       POSITION: { value: positions, size: 3 },
       TEXCOORD_0: { value: texCoords, size: 2 }
+      // TODO: Parse normals if they exist in the file
+      // NORMAL: {}, - optional, but creates the high poly look with lighting
     };
   }
 
@@ -599,7 +665,9 @@
       this.gridSize = gridSize;
       const tileSize = gridSize - 1;
       if (tileSize & tileSize - 1)
-        throw new Error(`Expected grid size to be 2^n+1, got ${gridSize}.`);
+        throw new Error(
+          `Expected grid size to be 2^n+1, got ${gridSize}.`
+        );
       this.numTriangles = tileSize * tileSize * 2 - 2;
       this.numParentTriangles = this.numTriangles - tileSize * tileSize;
       this.indices = new Uint32Array(this.gridSize * this.gridSize);
@@ -644,7 +712,9 @@
     constructor(terrain, martini) {
       const size = martini.gridSize;
       if (terrain.length !== size * size)
-        throw new Error(`Expected terrain data of length ${size * size} (${size} x ${size}), got ${terrain.length}.`);
+        throw new Error(
+          `Expected terrain data of length ${size * size} (${size} x ${size}), got ${terrain.length}.`
+        );
       this.terrain = terrain;
       this.martini = martini;
       this.errors = new Float32Array(terrain.length);
@@ -753,24 +823,30 @@
       this._addTriangle(p0, p3, p1, t0, -1, -1);
       this._flush();
     }
+    // refine the mesh until its maximum error gets below the given one
     run(maxError = 1) {
       while (this.getMaxError() > maxError) {
         this.refine();
       }
     }
+    // refine the mesh with a single point
     refine() {
       this._step();
       this._flush();
     }
+    // max error of the current mesh
     getMaxError() {
       return this._errors[0];
     }
+    // root-mean-square deviation of the current mesh
     getRMSD() {
       return this._rmsSum > 0 ? Math.sqrt(this._rmsSum / (this.width * this.height)) : 0;
     }
+    // height value at a given position
     heightAt(x, y) {
       return this.data[this.width * y + x];
     }
+    // rasterize and queue all triangles that got added or updated in _step
     _flush() {
       const coords = this.coords;
       for (let i = 0; i < this._pendingLen; i++) {
@@ -778,10 +854,19 @@
         const a = 2 * this.triangles[t * 3 + 0];
         const b = 2 * this.triangles[t * 3 + 1];
         const c = 2 * this.triangles[t * 3 + 2];
-        this._findCandidate(coords[a], coords[a + 1], coords[b], coords[b + 1], coords[c], coords[c + 1], t);
+        this._findCandidate(
+          coords[a],
+          coords[a + 1],
+          coords[b],
+          coords[b + 1],
+          coords[c],
+          coords[c + 1],
+          t
+        );
       }
       this._pendingLen = 0;
     }
+    // rasterize a triangle, find its max error, and queue it for processing
     _findCandidate(p0x, p0y, p1x, p1y, p2x, p2y, t) {
       const minX = Math.min(p0x, p1x, p2x);
       const minY = Math.min(p0y, p1y, p2y);
@@ -849,6 +934,7 @@
       this._rms[t] = rms;
       this._queuePush(t, maxError, rms);
     }
+    // process the next triangle in the queue, splitting it with a new point
     _step() {
       const t = this._queuePop();
       const e0 = t * 3 + 0;
@@ -884,11 +970,13 @@
         this._legalize(t2);
       }
     }
+    // add coordinates for a new vertex
     _addPoint(x, y) {
       const i = this.coords.length >> 1;
       this.coords.push(x, y);
       return i;
     }
+    // add or update a triangle in the mesh
     _addTriangle(a, b, c, ab, bc, ca, e = this.triangles.length) {
       const t = e / 3;
       this.triangles[e + 0] = a;
@@ -929,7 +1017,16 @@
       const pl = this.triangles[al];
       const p1 = this.triangles[bl];
       const coords = this.coords;
-      if (!inCircle(coords[2 * p0], coords[2 * p0 + 1], coords[2 * pr], coords[2 * pr + 1], coords[2 * pl], coords[2 * pl + 1], coords[2 * p1], coords[2 * p1 + 1])) {
+      if (!inCircle(
+        coords[2 * p0],
+        coords[2 * p0 + 1],
+        coords[2 * pr],
+        coords[2 * pr + 1],
+        coords[2 * pl],
+        coords[2 * pl + 1],
+        coords[2 * p1],
+        coords[2 * p1 + 1]
+      )) {
         return;
       }
       const hal = this._halfedges[al];
@@ -943,6 +1040,7 @@
       this._legalize(t0 + 1);
       this._legalize(t1 + 2);
     }
+    // handle a case where new vertex is on the edge of a triangle
     _handleCollinear(pn, a) {
       const a0 = a - a % 3;
       const al = a0 + (a + 1) % 3;
@@ -976,6 +1074,7 @@
       this._legalize(t2);
       this._legalize(t3);
     }
+    // priority queue methods
     _queuePush(t, error, rms) {
       const i = this._queue.length;
       this._queueIndices[t] = i;
@@ -1109,11 +1208,16 @@
     let attributes = getMeshAttributes2(vertices, terrain, width, height, bounds);
     const boundingBox = getMeshBoundingBox(attributes);
     if (terrainOptions.skirtHeight) {
-      const { attributes: newAttributes, triangles: newTriangles } = addSkirt(attributes, triangles, terrainOptions.skirtHeight);
+      const { attributes: newAttributes, triangles: newTriangles } = addSkirt(
+        attributes,
+        triangles,
+        terrainOptions.skirtHeight
+      );
       attributes = newAttributes;
       triangles = newTriangles;
     }
     return {
+      // Data return by this loader implementation
       loaderData: {
         header: {}
       },
@@ -1122,6 +1226,7 @@
         boundingBox
       },
       mode: 4,
+      // TRIANGLES
       indices: { value: Uint32Array.from(triangles), size: 1 },
       attributes
     };
@@ -1183,11 +1288,12 @@
     return {
       POSITION: { value: positions, size: 3 },
       TEXCOORD_0: { value: texCoords, size: 2 }
+      // NORMAL: {}, - optional, but creates the high poly look with lighting
     };
   }
 
   // src/lib/utils/version.ts
-  var VERSION = true ? "4.0.0-beta.1" : "latest";
+  var VERSION = true ? "4.0.0-beta.3" : "latest";
 
   // src/terrain-loader.ts
   var TerrainLoader = {

package/dist/{esm/terrain-loader.js → terrain-loader.js}

@@ -1,4 +1,4 @@
-import { VERSION } from './lib/utils/version';
+import { VERSION } from "./lib/utils/version.js";
 export const TerrainLoader = {
   name: 'Terrain',
   id: 'terrain',

package/dist/terrain-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrain-loader.js","names":["VERSION","TerrainLoader","name","id","module","version","worker","extensions","mimeTypes","options","terrain","tesselator","bounds","undefined","meshMaxError","elevationDecoder","rScaler","gScaler","bScaler","offset","skirtHeight"],"sources":["../src/terrain-loader.ts"],"sourcesContent":["import type {Loader} from '@loaders.gl/loader-utils';\nimport type {ImageLoaderOptions} from '@loaders.gl/images';\nimport {VERSION} from './lib/utils/version';\n\nimport {TerrainOptions} from './lib/parse-terrain';\nimport {Mesh} from '@loaders.gl/schema';\n\nexport type TerrainLoaderOptions = ImageLoaderOptions & {\n  terrain?: TerrainOptions;\n};\n\n/**\n * Worker loader for image encoded terrain\n */\nexport const TerrainLoader: Loader<Mesh, never, TerrainLoaderOptions> = {\n  name: 'Terrain',\n  id: 'terrain',\n  module: 'terrain',\n  version: VERSION,\n  worker: true,\n  extensions: ['png', 'pngraw', 'jpg', 'jpeg', 'gif', 'webp', 'bmp'],\n  mimeTypes: ['image/png', 'image/jpeg', 'image/gif', 'image/webp', 'image/bmp'],\n  options: {\n    terrain: {\n      tesselator: 'auto',\n      bounds: undefined!,\n      meshMaxError: 10,\n      elevationDecoder: {\n        rScaler: 1,\n        gScaler: 0,\n        bScaler: 0,\n        offset: 0\n      },\n      skirtHeight: undefined\n    }\n  }\n};\n"],"mappings":"SAEQA,OAAO;AAYf,OAAO,MAAMC,aAAwD,GAAG;EACtEC,IAAI,EAAE,SAAS;EACfC,EAAE,EAAE,SAAS;EACbC,MAAM,EAAE,SAAS;EACjBC,OAAO,EAAEL,OAAO;EAChBM,MAAM,EAAE,IAAI;EACZC,UAAU,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC;EAClEC,SAAS,EAAE,CAAC,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,CAAC;EAC9EC,OAAO,EAAE;IACPC,OAAO,EAAE;MACPC,UAAU,EAAE,MAAM;MAClBC,MAAM,EAAEC,SAAU;MAClBC,YAAY,EAAE,EAAE;MAChBC,gBAAgB,EAAE;QAChBC,OAAO,EAAE,CAAC;QACVC,OAAO,EAAE,CAAC;QACVC,OAAO,EAAE,CAAC;QACVC,MAAM,EAAE;MACV,CAAC;MACDC,WAAW,EAAEP;IACf;EACF;AACF,CAAC"}