@loaders.gl/tile-converter 4.2.0-alpha.4 → 4.2.0-alpha.6

package/dist/3d-tiles-converter/helpers/load-i3s.js

@@ -2,90 +2,96 @@ import { load } from '@loaders.gl/core';
 import { I3SLoader, parseSLPKArchive } from '@loaders.gl/i3s';
 import { FileHandleFile } from '@loaders.gl/loader-utils';
 import { ZipFileSystem, makeZipCDHeaderIterator } from '@loaders.gl/zip';
+/**
+ * Load I3S node content
+ * @param sourceTileset - source layer JSON
+ * @param sourceTile - source I3S node metadata
+ * @param tilesetLoadOptions - load options for Tiles3DLoader
+ * @param slpkFilesystem - loaded instance of ZipFileSystem for local convertion from SLPK file
+ * @returns - 3DTiles tile content or null
+ */
 export const loadI3SContent = async (sourceTileset, sourceTile, tilesetLoadOptions, slpkFilesystem) => {
-  if (!sourceTileset || !sourceTile.contentUrl) {
-    return null;
-  }
-  const loadOptions = {
-    ...tilesetLoadOptions,
-    i3s: {
-      ...tilesetLoadOptions.i3s,
-      isTileset: false,
-      isTileHeader: false,
-      _tileOptions: {
-        attributeUrls: sourceTile.attributeUrls || [],
-        textureUrl: sourceTile.textureUrl,
-        textureFormat: sourceTile.textureFormat,
-        textureLoaderOptions: sourceTile.textureLoaderOptions,
-        materialDefinition: sourceTile.materialDefinition,
-        isDracoGeometry: sourceTile.isDracoGeometry,
-        mbs: sourceTile.mbs
-      },
-      _tilesetOptions: {
-        store: sourceTileset.store,
-        attributeStorageInfo: sourceTileset.attributeStorageInfo,
-        fields: sourceTileset.fields
-      }
+    if (!sourceTileset || !sourceTile.contentUrl) {
+        return null;
     }
-  };
-  const tileContent = await loadFromArchive(sourceTile.contentUrl, I3SLoader, loadOptions, slpkFilesystem);
-  return tileContent;
+    const loadOptions = {
+        ...tilesetLoadOptions,
+        i3s: {
+            ...tilesetLoadOptions.i3s,
+            // @ts-expect-error
+            isTileset: false,
+            // @ts-expect-error
+            isTileHeader: false,
+            _tileOptions: {
+                attributeUrls: sourceTile.attributeUrls || [],
+                textureUrl: sourceTile.textureUrl,
+                textureFormat: sourceTile.textureFormat,
+                textureLoaderOptions: sourceTile.textureLoaderOptions,
+                materialDefinition: sourceTile.materialDefinition,
+                isDracoGeometry: sourceTile.isDracoGeometry,
+                mbs: sourceTile.mbs
+            },
+            _tilesetOptions: {
+                store: sourceTileset.store,
+                // @ts-expect-error
+                attributeStorageInfo: sourceTileset.attributeStorageInfo,
+                // @ts-expect-error
+                fields: sourceTileset.fields
+            }
+        }
+    };
+    const tileContent = await loadFromArchive(sourceTile.contentUrl, I3SLoader, loadOptions, slpkFilesystem);
+    return tileContent;
 };
+/**
+ * Load local SLPK file to ZipFileSystem instance
+ * @param url - path to SLPK file
+ * @returns instance of ZipFileSystem or null if url is not an SLPK file
+ */
 export async function openSLPK(url) {
-  const slpkUrlParts = url.split('.slpk');
-  const {
-    slpkFileName
-  } = getSlpkUrlParts(url) || {};
-  if (slpkFileName) {
-    const slpkFileName = `${slpkUrlParts[0]}.slpk`;
-    const fileProvider = new FileHandleFile(slpkFileName);
-    const archive = await parseSLPKArchive(fileProvider, undefined, slpkFileName);
-    const fileSystem = new ZipFileSystem(archive);
-    return fileSystem;
-  }
-  return null;
+    const slpkUrlParts = url.split('.slpk');
+    if (slpkUrlParts.length === 2) {
+        const slpkFileName = `${slpkUrlParts[0]}.slpk`;
+        const fileProvider = new FileHandleFile(slpkFileName);
+        const archive = await parseSLPKArchive(fileProvider, undefined, slpkFileName);
+        const fileSystem = new ZipFileSystem(archive);
+        return fileSystem;
+    }
+    return null;
 }
+/**
+ * Load a resource with load options and .3tz format support
+ * @param url - resource URL
+ * @param loader - loader to parse data (Tiles3DLoader / CesiumIonLoader)
+ * @param loadOptions - i3s loader options
+ * @returns i3s resource
+ */
 export async function loadFromArchive(url, loader, loadOptions, fileSystem) {
-  const slpkUrlParts = getSlpkUrlParts(url);
-  if (fileSystem !== null && slpkUrlParts !== null) {
-    const {
-      internalFileName
-    } = slpkUrlParts;
-    const content = await load(internalFileName, loader, {
-      ...loadOptions,
-      fetch: fileSystem.fetch.bind(fileSystem)
-    });
-    return content;
-  }
-  return await load(url, loader, loadOptions);
-}
-function getSlpkUrlParts(url) {
-  const slpkUrlParts = url.split('.slpk');
-  let result;
-  if (slpkUrlParts.length === 1) {
-    result = null;
-  } else if (slpkUrlParts.length === 2) {
-    result = {
-      slpkFileName: `${slpkUrlParts[0]}.slpk`,
-      internalFileName: slpkUrlParts[1].slice(1)
-    };
-  } else {
-    throw new Error('Unexpected URL format');
-  }
-  return result;
+    if (fileSystem !== null) {
+        const content = await load(url, loader, {
+            ...loadOptions,
+            fetch: fileSystem.fetch.bind(fileSystem)
+        });
+        return content;
+    }
+    return await load(url, loader, loadOptions);
 }
+/**
+ * Get nodes count inside SLPK
+ * @param fileSystem - file system of SLPK
+ * @returns number of nodes
+ */
 export async function getNodeCount(fileSystem) {
-  if (!(fileSystem !== null && fileSystem !== void 0 && fileSystem.fileProvider)) {
-    return 0;
-  }
-  let count = 0;
-  const filesIterator = makeZipCDHeaderIterator(fileSystem.fileProvider);
-  for await (const file of filesIterator) {
-    const filename = file.fileName;
-    if (filename.indexOf('3dNodeIndexDocument.json.gz') >= 0) {
-      count++;
+    if (!fileSystem?.fileProvider) {
+        return 0;
+    }
+    let count = 0;
+    const filesIterator = makeZipCDHeaderIterator(fileSystem.fileProvider);
+    for await (const file of filesIterator) {
+        const filename = file.fileName;
+        if (filename.indexOf('3dNodeIndexDocument.json.gz') >= 0) {
+            count++;
+        }
     }
-  }
-  return count;
+    return count;
 }
-//# sourceMappingURL=load-i3s.js.map

package/dist/3d-tiles-converter/helpers/texture-atlas.js

@@ -1,27 +1,50 @@
+/**
+ * Apply uvRegions to texture coordinates.
+ * Spec - https://github.com/Esri/i3s-spec/blob/master/docs/1.7/geometryUVRegion.cmn.md
+ * Shader formula vec2 uv = fract(texCoords) * (uvRegions.zw - uvRegions.xy) + uvRegions.xy;
+ * @param texCoords
+ * @param uvRegions
+ */
 export function convertTextureAtlas(texCoords, uvRegions) {
-  const convertedTexCoords = new Float32Array(texCoords.length);
-  const normalisedRegions = normalizeRegions(uvRegions);
-  for (let index = 0; index < texCoords.length; index += 2) {
-    const uv = texCoords.subarray(index, index + 2);
-    const regions = normalisedRegions.slice(index * 2, index * 2 + 4);
-    const fractatedUV = fract([uv[0], uv[1]]);
-    const subtracted = [regions[2] - regions[0], regions[3] - regions[1]];
-    const multiplicationResult = [fractatedUV[0] * subtracted[0], fractatedUV[1] * subtracted[1]];
-    const convertedUV = [multiplicationResult[0] + regions[0], multiplicationResult[1] + regions[1]];
-    convertedTexCoords[index] = convertedUV[0];
-    convertedTexCoords[index + 1] = convertedUV[1];
-  }
-  return convertedTexCoords;
+    const convertedTexCoords = new Float32Array(texCoords.length);
+    const normalisedRegions = normalizeRegions(uvRegions);
+    for (let index = 0; index < texCoords.length; index += 2) {
+        const uv = texCoords.subarray(index, index + 2);
+        const regions = normalisedRegions.slice(index * 2, index * 2 + 4);
+        // fract(texCoords)
+        const fractatedUV = fract([uv[0], uv[1]]);
+        // (uvRegions.zw - uvRegions.xy)
+        const subtracted = [regions[2] - regions[0], regions[3] - regions[1]];
+        // fract(texCoords) * (uvRegions.zw - uvRegions.xy)
+        const multiplicationResult = [fractatedUV[0] * subtracted[0], fractatedUV[1] * subtracted[1]];
+        // fract(texCoords) * (uvRegions.zw - uvRegions.xy) + uvRegions.xy;
+        const convertedUV = [
+            multiplicationResult[0] + regions[0],
+            multiplicationResult[1] + regions[1]
+        ];
+        convertedTexCoords[index] = convertedUV[0];
+        convertedTexCoords[index + 1] = convertedUV[1];
+    }
+    return convertedTexCoords;
 }
+/**
+ * Do fractation of UV array.
+ * @param uv
+ */
 function fract(uv) {
-  return [uv[0] - Math.floor(uv[0]), uv[1] - Math.floor(uv[1])];
+    return [uv[0] - Math.floor(uv[0]), uv[1] - Math.floor(uv[1])];
 }
+/**
+ * Normalize uvRegions by dividing by the maximum Uint16 value
+ * @param regions
+ */
 function normalizeRegions(regions) {
-  const MAX_UINT_16_VALUE = 65535;
-  const normalizedRegions = [];
-  for (let index = 0; index < regions.length; index++) {
-    normalizedRegions[index] = regions[index] / MAX_UINT_16_VALUE;
-  }
-  return normalizedRegions;
+    // The code is for Uint16Array because it is the spec requirement
+    // https://github.com/Esri/i3s-spec/blob/master/docs/1.8/geometryUVRegion.cmn.md
+    const MAX_UINT_16_VALUE = 65535;
+    const normalizedRegions = [];
+    for (let index = 0; index < regions.length; index++) {
+        normalizedRegions[index] = regions[index] / MAX_UINT_16_VALUE;
+    }
+    return normalizedRegions;
 }
-//# sourceMappingURL=texture-atlas.js.map

package/dist/3d-tiles-converter/json-templates/tileset.js

@@ -1,40 +1,39 @@
 import transform from 'json-map-transform';
 const ASSET = () => ({
-  version: {
-    path: 'version',
-    default: '1.0'
-  }
+    version: {
+        path: 'version',
+        default: '1.0'
+    }
 });
 const TILE = () => ({
-  boundingVolume: {
-    path: 'boundingVolume'
-  },
-  geometricError: {
-    path: 'geometricError'
-  },
-  refine: {
-    path: 'refine'
-  },
-  content: {
-    path: 'content'
-  },
-  children: {
-    path: 'children',
-    transform: val => val.map(tile => transform(tile, TILE()))
-  }
+    boundingVolume: {
+        path: 'boundingVolume'
+    },
+    geometricError: {
+        path: 'geometricError'
+    },
+    refine: {
+        path: 'refine'
+    },
+    content: {
+        path: 'content'
+    },
+    children: {
+        path: 'children',
+        transform: (val) => val.map((tile) => transform(tile, TILE()))
+    }
 });
 export const TILESET = () => ({
-  asset: {
-    path: 'asset',
-    transform: val => transform(val, ASSET())
-  },
-  geometricError: {
-    path: 'root',
-    transform: val => val.geometricError
-  },
-  root: {
-    path: 'root',
-    transform: val => transform(val, TILE())
-  }
+    asset: {
+        path: 'asset',
+        transform: (val) => transform(val, ASSET())
+    },
+    geometricError: {
+        path: 'root',
+        transform: (val) => val.geometricError
+    },
+    root: {
+        path: 'root',
+        transform: (val) => transform(val, TILE())
+    }
 });
-//# sourceMappingURL=tileset.js.map

package/dist/constants.js

@@ -1,3 +1,2 @@
 export const BROWSER_ERROR_MESSAGE = 'Tile converter does not work in browser, only in node js environment';
 export const DUMP_FILE_SUFFIX = '.dump.json';
-//# sourceMappingURL=constants.js.map