@loaders.gl/terrain 4.0.0-alpha.5 → 4.0.0-alpha.7

package/dist/bundle.js

@@ -1,5 +1,5 @@
+"use strict";
+// @ts-nocheck
 const moduleExports = require('./index');
-
 globalThis.loaders = globalThis.loaders || {};
 module.exports = Object.assign(globalThis.loaders, moduleExports);
-//# sourceMappingURL=bundle.js.map

package/dist/dist.min.js

@@ -13,7 +13,7 @@
       __defProp(target, name, { get: all[name], enumerable: true });
   };
 
-  // ../schema/src/category/mesh/mesh-utils.ts
+  // ../schema/src/lib/mesh/mesh-utils.ts
   function getMeshBoundingBox(attributes) {
     let minX = Infinity;
     let minY = Infinity;
@@ -40,7 +40,7 @@
     ];
   }
   var init_mesh_utils = __esm({
-    "../schema/src/category/mesh/mesh-utils.ts"() {
+    "../schema/src/lib/mesh/mesh-utils.ts"() {
     }
   });
 
@@ -323,12 +323,12 @@
     }
     edges.sort((a, b) => Math.min(...a) - Math.min(...b) || Math.max(...a) - Math.max(...b));
     const outsideEdges = [];
-    let index = 1;
+    let index = 0;
     while (index < edges.length) {
-      if (edges[index][0] === edges[index - 1][1] && edges[index][1] === edges[index - 1][0]) {
+      if (edges[index][0] === edges[index + 1]?.[1] && edges[index][1] === edges[index + 1]?.[0]) {
         index += 2;
       } else {
-        outsideEdges.push(edges[index - 1]);
+        outsideEdges.push(edges[index]);
         index++;
       }
     }
@@ -368,11 +368,11 @@
     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] = edge[1];
-    newTriangles[triangle1Offset + 2] = positionsLength / 3 + vertex2Offset;
+    newTriangles[triangle1Offset + 1] = positionsLength / 3 + vertex2Offset;
+    newTriangles[triangle1Offset + 2] = edge[1];
     newTriangles[triangle1Offset + 3] = positionsLength / 3 + vertex2Offset;
-    newTriangles[triangle1Offset + 4] = positionsLength / 3 + vertex1Offset;
-    newTriangles[triangle1Offset + 5] = edge[0];
+    newTriangles[triangle1Offset + 4] = edge[0];
+    newTriangles[triangle1Offset + 5] = positionsLength / 3 + vertex1Offset;
   }
   var init_skirt = __esm({
     "src/lib/helpers/skirt.ts"() {
@@ -381,34 +381,7 @@
   });
 
   // src/lib/parse-quantized-mesh.ts
-  function getMeshAttributes(vertexData, header, bounds) {
-    const { minHeight, maxHeight } = header;
-    const [minX, minY, maxX, maxY] = bounds || [0, 0, 1, 1];
-    const xScale = maxX - minX;
-    const yScale = maxY - minY;
-    const zScale = maxHeight - minHeight;
-    const nCoords = vertexData.length / 3;
-    const positions = new Float32Array(nCoords * 3);
-    const texCoords = new Float32Array(nCoords * 2);
-    for (let i = 0; i < nCoords; i++) {
-      const x = vertexData[i] / 32767;
-      const y = vertexData[i + nCoords] / 32767;
-      const z = vertexData[i + nCoords * 2] / 32767;
-      positions[3 * i + 0] = x * xScale + minX;
-      positions[3 * i + 1] = y * yScale + minY;
-      positions[3 * i + 2] = z * zScale + minHeight;
-      texCoords[2 * i + 0] = x;
-      texCoords[2 * i + 1] = y;
-    }
-    return {
-      POSITION: { value: positions, size: 3 },
-      TEXCOORD_0: { value: texCoords, size: 2 }
-    };
-  }
-  function getTileMesh(arrayBuffer, options) {
-    if (!arrayBuffer) {
-      return null;
-    }
+  function parseQuantizedMesh(arrayBuffer, options = {}) {
     const { bounds } = options;
     const {
       header,
@@ -422,7 +395,7 @@
     let triangleIndices = originalTriangleIndices;
     let attributes = getMeshAttributes(vertexData, header, bounds);
     const boundingBox = getMeshBoundingBox(attributes);
-    if (options.skirtHeight) {
+    if (options?.skirtHeight) {
       const { attributes: newAttributes, triangles: newTriangles } = addSkirt(attributes, triangleIndices, options.skirtHeight, {
         westIndices,
         northIndices,
@@ -440,13 +413,36 @@
         vertexCount: triangleIndices.length,
         boundingBox
       },
+      schema: void 0,
+      topology: "triangle-list",
       mode: 4,
       indices: { value: triangleIndices, size: 1 },
       attributes
     };
   }
-  function loadQuantizedMesh(arrayBuffer, options) {
-    return getTileMesh(arrayBuffer, options["quantized-mesh"]);
+  function getMeshAttributes(vertexData, header, bounds) {
+    const { minHeight, maxHeight } = header;
+    const [minX, minY, maxX, maxY] = bounds || [0, 0, 1, 1];
+    const xScale = maxX - minX;
+    const yScale = maxY - minY;
+    const zScale = maxHeight - minHeight;
+    const nCoords = vertexData.length / 3;
+    const positions = new Float32Array(nCoords * 3);
+    const texCoords = new Float32Array(nCoords * 2);
+    for (let i = 0; i < nCoords; i++) {
+      const x = vertexData[i] / 32767;
+      const y = vertexData[i + nCoords] / 32767;
+      const z = vertexData[i + nCoords * 2] / 32767;
+      positions[3 * i + 0] = x * xScale + minX;
+      positions[3 * i + 1] = y * yScale + minY;
+      positions[3 * i + 2] = z * zScale + minHeight;
+      texCoords[2 * i + 0] = x;
+      texCoords[2 * i + 1] = y;
+    }
+    return {
+      POSITION: { value: positions, size: 3 },
+      TEXCOORD_0: { value: texCoords, size: 2 }
+    };
   }
   var init_parse_quantized_mesh = __esm({
     "src/lib/parse-quantized-mesh.ts"() {
@@ -953,55 +949,7 @@
   });
 
   // src/lib/parse-terrain.ts
-  function getTerrain(imageData, width, height, elevationDecoder, tesselator) {
-    const { rScaler, bScaler, gScaler, offset } = elevationDecoder;
-    const terrain = new Float32Array((width + 1) * (height + 1));
-    for (let i = 0, y = 0; y < height; y++) {
-      for (let x = 0; x < width; x++, i++) {
-        const k = i * 4;
-        const r = imageData[k + 0];
-        const g = imageData[k + 1];
-        const b = imageData[k + 2];
-        terrain[i + y] = r * rScaler + g * gScaler + b * bScaler + offset;
-      }
-    }
-    if (tesselator === "martini") {
-      for (let i = (width + 1) * width, x = 0; x < width; x++, i++) {
-        terrain[i] = terrain[i - width - 1];
-      }
-      for (let i = height, y = 0; y < height + 1; y++, i += height + 1) {
-        terrain[i] = terrain[i - 1];
-      }
-    }
-    return terrain;
-  }
-  function getMeshAttributes2(vertices, terrain, width, height, bounds) {
-    const gridSize = width + 1;
-    const numOfVerticies = vertices.length / 2;
-    const positions = new Float32Array(numOfVerticies * 3);
-    const texCoords = new Float32Array(numOfVerticies * 2);
-    const [minX, minY, maxX, maxY] = bounds || [0, 0, width, height];
-    const xScale = (maxX - minX) / width;
-    const yScale = (maxY - minY) / height;
-    for (let i = 0; i < numOfVerticies; i++) {
-      const x = vertices[i * 2];
-      const y = vertices[i * 2 + 1];
-      const pixelIdx = y * gridSize + x;
-      positions[3 * i + 0] = x * xScale + minX;
-      positions[3 * i + 1] = -y * yScale + maxY;
-      positions[3 * i + 2] = terrain[pixelIdx];
-      texCoords[2 * i + 0] = x / width;
-      texCoords[2 * i + 1] = y / height;
-    }
-    return {
-      POSITION: { value: positions, size: 3 },
-      TEXCOORD_0: { value: texCoords, size: 2 }
-    };
-  }
-  function getMesh(terrainImage, terrainOptions) {
-    if (terrainImage === null) {
-      return null;
-    }
+  function makeTerrainMeshFromImage(terrainImage, terrainOptions) {
     const { meshMaxError, bounds, elevationDecoder } = terrainOptions;
     const { data, width, height } = terrainImage;
     let terrain;
@@ -1061,11 +1009,50 @@
     const vertices = coords;
     return { vertices, triangles };
   }
-  async function loadTerrain(arrayBuffer, options, context) {
-    options.image = options.image || {};
-    options.image.type = "data";
-    const image = await context.parse(arrayBuffer, options, options.baseUri);
-    return getMesh(image, options.terrain);
+  function getTerrain(imageData, width, height, elevationDecoder, tesselator) {
+    const { rScaler, bScaler, gScaler, offset } = elevationDecoder;
+    const terrain = new Float32Array((width + 1) * (height + 1));
+    for (let i = 0, y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++, i++) {
+        const k = i * 4;
+        const r = imageData[k + 0];
+        const g = imageData[k + 1];
+        const b = imageData[k + 2];
+        terrain[i + y] = r * rScaler + g * gScaler + b * bScaler + offset;
+      }
+    }
+    if (tesselator === "martini") {
+      for (let i = (width + 1) * width, x = 0; x < width; x++, i++) {
+        terrain[i] = terrain[i - width - 1];
+      }
+      for (let i = height, y = 0; y < height + 1; y++, i += height + 1) {
+        terrain[i] = terrain[i - 1];
+      }
+    }
+    return terrain;
+  }
+  function getMeshAttributes2(vertices, terrain, width, height, bounds) {
+    const gridSize = width + 1;
+    const numOfVerticies = vertices.length / 2;
+    const positions = new Float32Array(numOfVerticies * 3);
+    const texCoords = new Float32Array(numOfVerticies * 2);
+    const [minX, minY, maxX, maxY] = bounds || [0, 0, width, height];
+    const xScale = (maxX - minX) / width;
+    const yScale = (maxY - minY) / height;
+    for (let i = 0; i < numOfVerticies; i++) {
+      const x = vertices[i * 2];
+      const y = vertices[i * 2 + 1];
+      const pixelIdx = y * gridSize + x;
+      positions[3 * i + 0] = x * xScale + minX;
+      positions[3 * i + 1] = -y * yScale + maxY;
+      positions[3 * i + 2] = terrain[pixelIdx];
+      texCoords[2 * i + 0] = x / width;
+      texCoords[2 * i + 1] = y / height;
+    }
+    return {
+      POSITION: { value: positions, size: 3 },
+      TEXCOORD_0: { value: texCoords, size: 2 }
+    };
   }
   var init_parse_terrain = __esm({
     "src/lib/parse-terrain.ts"() {
@@ -1095,12 +1082,12 @@
         module: "terrain",
         version: VERSION,
         worker: true,
-        extensions: ["png", "pngraw"],
-        mimeTypes: ["image/png"],
+        extensions: ["png", "pngraw", "jpg", "jpeg", "gif", "webp", "bmp"],
+        mimeTypes: ["image/png", "image/jpeg", "image/gif", "image/webp", "image/bmp"],
         options: {
           terrain: {
             tesselator: "auto",
-            bounds: null,
+            bounds: void 0,
             meshMaxError: 10,
             elevationDecoder: {
               rScaler: 1,
@@ -1108,7 +1095,7 @@
               bScaler: 0,
               offset: 0
             },
-            skirtHeight: null
+            skirtHeight: void 0
           }
         }
       };
@@ -1145,10 +1132,19 @@
     QuantizedMeshWorkerLoader: () => QuantizedMeshLoader,
     TerrainLoader: () => TerrainLoader2,
     TerrainWorkerLoader: () => TerrainLoader,
-    _typecheckQuantizedMeshLoader: () => _typecheckQuantizedMeshLoader,
-    _typecheckTerrainLoader: () => _typecheckTerrainLoader
+    parseTerrain: () => parseTerrain
   });
-  var TerrainLoader2, _typecheckTerrainLoader, QuantizedMeshLoader2, _typecheckQuantizedMeshLoader;
+  async function parseTerrain(arrayBuffer, options, context) {
+    const loadImageOptions = {
+      ...options,
+      mimeType: "application/x.image",
+      image: { ...options?.image, type: "data" }
+    };
+    const image = await context?.parse(arrayBuffer, loadImageOptions);
+    const terrainOptions = { ...TerrainLoader2.options.terrain, ...options?.terrain };
+    return makeTerrainMeshFromImage(image, terrainOptions);
+  }
+  var TerrainLoader2, QuantizedMeshLoader2;
   var init_src3 = __esm({
     "src/index.ts"() {
       init_parse_quantized_mesh();
@@ -1157,15 +1153,13 @@
       init_quantized_mesh_loader();
       TerrainLoader2 = {
         ...TerrainLoader,
-        parse: loadTerrain
+        parse: parseTerrain
       };
-      _typecheckTerrainLoader = TerrainLoader2;
       QuantizedMeshLoader2 = {
         ...QuantizedMeshLoader,
-        parseSync: loadQuantizedMesh,
-        parse: async (arrayBuffer, options) => loadQuantizedMesh(arrayBuffer, options)
+        parseSync: (arrayBuffer, options) => parseQuantizedMesh(arrayBuffer, options?.["quantized-mesh"]),
+        parse: async (arrayBuffer, options) => parseQuantizedMesh(arrayBuffer, options?.["quantized-mesh"])
       };
-      _typecheckQuantizedMeshLoader = QuantizedMeshLoader2;
     }
   });
 

package/dist/es5/bundle.js

@@ -0,0 +1,6 @@
+"use strict";
+
+var moduleExports = require('./index');
+globalThis.loaders = globalThis.loaders || {};
+module.exports = Object.assign(globalThis.loaders, moduleExports);
+//# sourceMappingURL=bundle.js.map

package/dist/es5/bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.js","names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"sources":["../../src/bundle.ts"],"sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"mappings":";;AACA,IAAMA,aAAa,GAAGC,OAAO,CAAC,SAAS,CAAC;AACxCC,UAAU,CAACC,OAAO,GAAGD,UAAU,CAACC,OAAO,IAAI,CAAC,CAAC;AAC7CC,MAAM,CAACC,OAAO,GAAGC,MAAM,CAACC,MAAM,CAACL,UAAU,CAACC,OAAO,EAAEH,aAAa,CAAC"}

package/dist/es5/index.js

@@ -0,0 +1,87 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.QuantizedMeshLoader = void 0;
+Object.defineProperty(exports, "QuantizedMeshWorkerLoader", {
+  enumerable: true,
+  get: function get() {
+    return _quantizedMeshLoader.QuantizedMeshLoader;
+  }
+});
+exports.TerrainLoader = void 0;
+Object.defineProperty(exports, "TerrainWorkerLoader", {
+  enumerable: true,
+  get: function get() {
+    return _terrainLoader.TerrainLoader;
+  }
+});
+exports.parseTerrain = parseTerrain;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _parseQuantizedMesh = require("./lib/parse-quantized-mesh");
+var _parseTerrain2 = require("./lib/parse-terrain");
+var _terrainLoader = require("./terrain-loader");
+var _quantizedMeshLoader = require("./quantized-mesh-loader");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var TerrainLoader = _objectSpread(_objectSpread({}, _terrainLoader.TerrainLoader), {}, {
+  parse: parseTerrain
+});
+exports.TerrainLoader = TerrainLoader;
+function parseTerrain(_x, _x2, _x3) {
+  return _parseTerrain.apply(this, arguments);
+}
+function _parseTerrain() {
+  _parseTerrain = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(arrayBuffer, options, context) {
+    var loadImageOptions, image, terrainOptions;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          loadImageOptions = _objectSpread(_objectSpread({}, options), {}, {
+            mimeType: 'application/x.image',
+            image: _objectSpread(_objectSpread({}, options === null || options === void 0 ? void 0 : options.image), {}, {
+              type: 'data'
+            })
+          });
+          _context2.next = 3;
+          return context === null || context === void 0 ? void 0 : context.parse(arrayBuffer, loadImageOptions);
+        case 3:
+          image = _context2.sent;
+          terrainOptions = _objectSpread(_objectSpread({}, TerrainLoader.options.terrain), options === null || options === void 0 ? void 0 : options.terrain);
+          return _context2.abrupt("return", (0, _parseTerrain2.makeTerrainMeshFromImage)(image, terrainOptions));
+        case 6:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _parseTerrain.apply(this, arguments);
+}
+var QuantizedMeshLoader = _objectSpread(_objectSpread({}, _quantizedMeshLoader.QuantizedMeshLoader), {}, {
+  parseSync: function parseSync(arrayBuffer, options) {
+    return (0, _parseQuantizedMesh.parseQuantizedMesh)(arrayBuffer, options === null || options === void 0 ? void 0 : options['quantized-mesh']);
+  },
+  parse: function () {
+    var _parse = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(arrayBuffer, options) {
+      return _regenerator.default.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            return _context.abrupt("return", (0, _parseQuantizedMesh.parseQuantizedMesh)(arrayBuffer, options === null || options === void 0 ? void 0 : options['quantized-mesh']));
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    function parse(_x4, _x5) {
+      return _parse.apply(this, arguments);
+    }
+    return parse;
+  }()
+});
+exports.QuantizedMeshLoader = QuantizedMeshLoader;
+//# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_parseQuantizedMesh","require","_parseTerrain2","_terrainLoader","_quantizedMeshLoader","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","target","i","arguments","length","source","forEach","key","_defineProperty2","default","getOwnPropertyDescriptors","defineProperties","defineProperty","TerrainLoader","TerrainWorkerLoader","parse","parseTerrain","exports","_x","_x2","_x3","_parseTerrain","_asyncToGenerator2","_regenerator","mark","_callee2","arrayBuffer","options","context","loadImageOptions","image","terrainOptions","wrap","_callee2$","_context2","prev","next","mimeType","type","sent","terrain","abrupt","makeTerrainMeshFromImage","stop","QuantizedMeshLoader","QuantizedMeshWorkerLoader","parseSync","parseQuantizedMesh","_parse","_callee","_callee$","_context","_x4","_x5"],"sources":["../../src/index.ts"],"sourcesContent":["import type {LoaderContext, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {parseQuantizedMesh} from './lib/parse-quantized-mesh';\nimport {TerrainOptions, makeTerrainMeshFromImage} from './lib/parse-terrain';\n\nimport {TerrainLoader as TerrainWorkerLoader, TerrainLoaderOptions} from './terrain-loader';\nimport {\n  QuantizedMeshLoader as QuantizedMeshWorkerLoader,\n  QuantizedMeshLoaderOptions\n} from './quantized-mesh-loader';\n\n// TerrainLoader\n\nexport {TerrainWorkerLoader};\n\nexport const TerrainLoader: LoaderWithParser<any, never, TerrainLoaderOptions> = {\n  ...TerrainWorkerLoader,\n  parse: parseTerrain\n};\n\nexport async function parseTerrain(\n  arrayBuffer: ArrayBuffer,\n  options?: TerrainLoaderOptions,\n  context?: LoaderContext\n) {\n  const loadImageOptions = {\n    ...options,\n    mimeType: 'application/x.image',\n    image: {...options?.image, type: 'data'}\n  };\n  const image = await context?.parse(arrayBuffer, loadImageOptions);\n  // Extend function to support additional mesh generation options (square grid or delatin)\n  const terrainOptions = {...TerrainLoader.options.terrain, ...options?.terrain} as TerrainOptions;\n  return makeTerrainMeshFromImage(image, terrainOptions);\n}\n\n// QuantizedMeshLoader\n\nexport {QuantizedMeshWorkerLoader};\n\n/**\n * Loader for quantized meshes\n */\nexport const QuantizedMeshLoader: LoaderWithParser<any, never, QuantizedMeshLoaderOptions> = {\n  ...QuantizedMeshWorkerLoader,\n  parseSync: (arrayBuffer, options) => parseQuantizedMesh(arrayBuffer, options?.['quantized-mesh']),\n  parse: async (arrayBuffer, options) =>\n    parseQuantizedMesh(arrayBuffer, options?.['quantized-mesh'])\n};\n"],"mappings":"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"}