@loaders.gl/i3s 4.0.0-alpha.1 → 4.0.0-alpha.11

package/dist/lib/helpers/i3s-nodepages-tiles.js

@@ -1,229 +1,242 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { load } from '@loaders.gl/core';
-import { getSupportedGPUTextureFormats, selectSupportedBasisFormat } from '@loaders.gl/textures';
-import { I3SNodePageLoader } from '../../i3s-node-page-loader';
-import { normalizeTileNonUrlData } from '../parsers/parse-i3s';
-import { getUrlWithToken, generateTilesetAttributeUrls } from '../utils/url-utils';
-export default class I3SNodePagesTiles {
-  constructor(tileset, options) {
-    _defineProperty(this, "tileset", void 0);
-
-    _defineProperty(this, "nodePages", []);
-
-    _defineProperty(this, "pendingNodePages", []);
-
-    _defineProperty(this, "nodesPerPage", void 0);
-
-    _defineProperty(this, "options", void 0);
-
-    _defineProperty(this, "lodSelectionMetricType", void 0);
-
-    _defineProperty(this, "textureDefinitionsSelectedFormats", []);
-
-    _defineProperty(this, "textureLoaderOptions", {});
-
-    this.tileset = { ...tileset
-    };
-    this.nodesPerPage = tileset.nodePages.nodesPerPage;
-    this.lodSelectionMetricType = tileset.nodePages.lodSelectionMetricType;
-    this.options = options;
-    this.initSelectedFormatsForTextureDefinitions(tileset);
-  }
-
-  async getNodeById(id) {
-    const pageIndex = Math.floor(id / this.nodesPerPage);
-
-    if (!this.nodePages[pageIndex] && !this.pendingNodePages[pageIndex]) {
-      var _this$options$i3s;
-
-      const nodePageUrl = getUrlWithToken("".concat(this.tileset.url, "/nodepages/").concat(pageIndex), (_this$options$i3s = this.options.i3s) === null || _this$options$i3s === void 0 ? void 0 : _this$options$i3s.token);
-      this.pendingNodePages[pageIndex] = {
-        status: 'Pending',
-        promise: load(nodePageUrl, I3SNodePageLoader, this.options)
-      };
-      this.nodePages[pageIndex] = await this.pendingNodePages[pageIndex].promise;
-      this.pendingNodePages[pageIndex].status = 'Done';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@loaders.gl/core");
+const textures_1 = require("@loaders.gl/textures");
+const i3s_node_page_loader_1 = require("../../i3s-node-page-loader");
+const parse_i3s_1 = require("../parsers/parse-i3s");
+const url_utils_1 = require("../utils/url-utils");
+/**
+ * class I3SNodePagesTiles - loads nodePages and form i3s tiles from them
+ */
+class I3SNodePagesTiles {
+    /**
+     * @constructs
+     * Create a I3SNodePagesTiles instance.
+     * @param tileset - i3s tileset header ('layers/0')
+     * @param options - i3s loader options
+     */
+    constructor(tileset, options) {
+        this.nodePages = [];
+        this.pendingNodePages = [];
+        this.textureDefinitionsSelectedFormats = [];
+        this.textureLoaderOptions = {};
+        this.tileset = { ...tileset }; // spread the tileset to avoid circular reference
+        this.nodesPerPage = tileset.nodePages?.nodesPerPage || 64;
+        this.lodSelectionMetricType = tileset.nodePages?.lodSelectionMetricType;
+        this.options = options;
+        this.nodesInNodePages = 0;
+        this.initSelectedFormatsForTextureDefinitions(tileset);
     }
-
-    if (this.pendingNodePages[pageIndex].status === 'Pending') {
-      this.nodePages[pageIndex] = await this.pendingNodePages[pageIndex].promise;
-    }
-
-    const nodeIndex = id % this.nodesPerPage;
-    return this.nodePages[pageIndex].nodes[nodeIndex];
-  }
-
-  async formTileFromNodePages(id) {
-    const node = await this.getNodeById(id);
-    const children = [];
-
-    for (const child of node.children || []) {
-      const childNode = await this.getNodeById(child);
-      children.push({
-        id: child,
-        obb: childNode.obb
-      });
-    }
-
-    let contentUrl = null;
-    let textureUrl = null;
-    let materialDefinition = null;
-    let textureFormat = 'jpeg';
-    let attributeUrls = [];
-    let isDracoGeometry = false;
-
-    if (node && node.mesh) {
-      const {
-        url,
-        isDracoGeometry: isDracoGeometryResult
-      } = node.mesh.geometry && this.getContentUrl(node.mesh.geometry) || {
-        url: null,
-        isDracoGeometry: null
-      };
-      contentUrl = url;
-      isDracoGeometry = isDracoGeometryResult;
-      const [textureData, nodeMaterialDefinition] = this.getInformationFromMaterial(node.mesh.material);
-      materialDefinition = nodeMaterialDefinition;
-      textureFormat = textureData.format || textureFormat;
-
-      if (textureData.name) {
-        textureUrl = "".concat(this.tileset.url, "/nodes/").concat(node.mesh.material.resource, "/textures/").concat(textureData.name);
-      }
-
-      if (this.tileset.attributeStorageInfo) {
-        attributeUrls = generateTilesetAttributeUrls(this.tileset, node.mesh.attribute.resource);
-      }
-    }
-
-    const lodSelection = this.getLodSelection(node);
-    return normalizeTileNonUrlData({
-      id,
-      lodSelection,
-      obb: node.obb,
-      contentUrl,
-      textureUrl,
-      attributeUrls,
-      materialDefinition,
-      textureFormat,
-      textureLoaderOptions: this.textureLoaderOptions,
-      children,
-      isDracoGeometry
-    });
-  }
-
-  getContentUrl(meshGeometryData) {
-    let result = {};
-    const geometryDefinition = this.tileset.geometryDefinitions[meshGeometryData.definition];
-    let geometryIndex = -1;
-
-    if (this.options.i3s && this.options.i3s.useDracoGeometry) {
-      geometryIndex = geometryDefinition.geometryBuffers.findIndex(buffer => buffer.compressedAttributes && buffer.compressedAttributes.encoding === 'draco');
+    /**
+     * Loads some nodePage and return a particular node from it
+     * @param id - id of node through all node pages
+     */
+    async getNodeById(id) {
+        const pageIndex = Math.floor(id / this.nodesPerPage);
+        if (!this.nodePages[pageIndex] && !this.pendingNodePages[pageIndex]) {
+            const nodePageUrl = (0, url_utils_1.getUrlWithToken)(`${this.tileset.url}/nodepages/${pageIndex}`, 
+            // @ts-expect-error this.options is not properly typed
+            this.options.i3s?.token);
+            this.pendingNodePages[pageIndex] = {
+                status: 'Pending',
+                promise: (0, core_1.load)(nodePageUrl, i3s_node_page_loader_1.I3SNodePageLoader, this.options)
+            };
+            this.nodePages[pageIndex] = await this.pendingNodePages[pageIndex].promise;
+            this.nodesInNodePages += this.nodePages[pageIndex].nodes.length;
+            this.pendingNodePages[pageIndex].status = 'Done';
+        }
+        if (this.pendingNodePages[pageIndex].status === 'Pending') {
+            this.nodePages[pageIndex] = await this.pendingNodePages[pageIndex].promise;
+        }
+        const nodeIndex = id % this.nodesPerPage;
+        return this.nodePages[pageIndex].nodes[nodeIndex];
     }
-
-    if (geometryIndex === -1) {
-      geometryIndex = geometryDefinition.geometryBuffers.findIndex(buffer => !buffer.compressedAttributes);
+    /**
+     * Forms tile header using node and tileset data
+     * @param id - id of node through all node pages
+     */
+    // eslint-disable-next-line complexity, max-statements
+    async formTileFromNodePages(id) {
+        const node = await this.getNodeById(id);
+        const children = [];
+        const childNodesPromises = [];
+        for (const child of node.children || []) {
+            childNodesPromises.push(this.getNodeById(child));
+        }
+        const childNodes = await Promise.all(childNodesPromises);
+        for (const childNode of childNodes) {
+            children.push({
+                id: childNode.index.toString(),
+                obb: childNode.obb
+            });
+        }
+        let contentUrl;
+        let textureUrl;
+        let materialDefinition;
+        let textureFormat = 'jpg';
+        let attributeUrls = [];
+        let isDracoGeometry = false;
+        if (node && node.mesh) {
+            // Get geometry resource URL and type (compressed / non-compressed)
+            const { url, isDracoGeometry: isDracoGeometryResult } = (node.mesh.geometry &&
+                this.getContentUrl(node.mesh.geometry)) || { isDracoGeometry: false };
+            contentUrl = url;
+            isDracoGeometry = isDracoGeometryResult;
+            const { textureData, materialDefinition: nodeMaterialDefinition } = this.getInformationFromMaterial(node.mesh.material);
+            materialDefinition = nodeMaterialDefinition;
+            textureFormat = textureData.format || textureFormat;
+            if (textureData.name) {
+                textureUrl = `${this.tileset.url}/nodes/${node.mesh.material.resource}/textures/${textureData.name}`;
+            }
+            if (this.tileset.attributeStorageInfo) {
+                attributeUrls = (0, url_utils_1.generateTilesetAttributeUrls)(this.tileset, node.mesh.attribute.resource);
+            }
+        }
+        const lodSelection = this.getLodSelection(node);
+        return (0, parse_i3s_1.normalizeTileNonUrlData)({
+            id: id.toString(),
+            lodSelection,
+            obb: node.obb,
+            contentUrl,
+            textureUrl,
+            attributeUrls,
+            materialDefinition,
+            textureFormat,
+            textureLoaderOptions: this.textureLoaderOptions,
+            children,
+            isDracoGeometry
+        });
     }
-
-    if (geometryIndex !== -1) {
-      const isDracoGeometry = Boolean(geometryDefinition.geometryBuffers[geometryIndex].compressedAttributes);
-      result = {
-        url: "".concat(this.tileset.url, "/nodes/").concat(meshGeometryData.resource, "/geometries/").concat(geometryIndex),
-        isDracoGeometry
-      };
+    /**
+     * Forms url and type of geometry resource by nodepage's data and `geometryDefinitions` in the tileset
+     * @param - data about the node's mesh from the nodepage
+     * @returns -
+     *   {string} url - url to the geometry resource
+     *   {boolean} isDracoGeometry - whether the geometry resource contain DRACO compressed geometry
+     */
+    getContentUrl(meshGeometryData) {
+        let result = null;
+        // @ts-ignore
+        const geometryDefinition = this.tileset.geometryDefinitions[meshGeometryData.definition];
+        let geometryIndex = -1;
+        // Try to find DRACO geometryDefinition of `useDracoGeometry` option is set
+        // @ts-expect-error this.options is not properly typed
+        if (this.options.i3s && this.options.i3s.useDracoGeometry) {
+            geometryIndex = geometryDefinition.geometryBuffers.findIndex((buffer) => buffer.compressedAttributes && buffer.compressedAttributes.encoding === 'draco');
+        }
+        // If DRACO geometry is not applicable try to select non-compressed geometry
+        if (geometryIndex === -1) {
+            geometryIndex = geometryDefinition.geometryBuffers.findIndex((buffer) => !buffer.compressedAttributes);
+        }
+        if (geometryIndex !== -1) {
+            const isDracoGeometry = Boolean(geometryDefinition.geometryBuffers[geometryIndex].compressedAttributes);
+            result = {
+                url: `${this.tileset.url}/nodes/${meshGeometryData.resource}/geometries/${geometryIndex}`,
+                isDracoGeometry
+            };
+        }
+        return result;
     }
-
-    return result;
-  }
-
-  getLodSelection(node) {
-    const lodSelection = [];
-
-    if (this.lodSelectionMetricType === 'maxScreenThresholdSQ') {
-      lodSelection.push({
-        metricType: 'maxScreenThreshold',
-        maxError: Math.sqrt(node.lodThreshold / (Math.PI * 0.25))
-      });
+    /**
+     * Forms 1.6 compatible LOD selection object from a nodepage's node data
+     * @param node - a node from nodepage
+     * @returns- Array of LodSelection
+     */
+    getLodSelection(node) {
+        const lodSelection = [];
+        if (this.lodSelectionMetricType === 'maxScreenThresholdSQ') {
+            lodSelection.push({
+                metricType: 'maxScreenThreshold',
+                // @ts-ignore
+                maxError: Math.sqrt(node.lodThreshold / (Math.PI * 0.25))
+            });
+        }
+        lodSelection.push({
+            metricType: this.lodSelectionMetricType,
+            // @ts-ignore
+            maxError: node.lodThreshold
+        });
+        return lodSelection;
     }
-
-    lodSelection.push({
-      metricType: this.lodSelectionMetricType,
-      maxError: node.lodThreshold
-    });
-    return lodSelection;
-  }
-
-  getInformationFromMaterial(material) {
-    const textureDataDefault = {
-      name: null,
-      format: null
-    };
-
-    if (material) {
-      const materialDefinition = this.tileset.materialDefinitions[material.definition];
-      const textureSetDefinitionIndex = materialDefinition && materialDefinition.pbrMetallicRoughness && materialDefinition.pbrMetallicRoughness.baseColorTexture && materialDefinition.pbrMetallicRoughness.baseColorTexture.textureSetDefinitionId;
-
-      if (textureSetDefinitionIndex || textureSetDefinitionIndex === 0) {
-        const textureData = this.textureDefinitionsSelectedFormats[textureSetDefinitionIndex] || textureDataDefault;
-        return [textureData, materialDefinition];
-      }
-
-      return [textureDataDefault, materialDefinition];
+    /**
+     * Returns information about texture and material from `materialDefinitions`
+     * @param material - material data from nodepage
+     * @returns - Couple {textureData, materialDefinition}
+     * {string} textureData.name - path name of the texture
+     * {string} textureData.format - format of the texture
+     * materialDefinition - PBR-like material definition from `materialDefinitions`
+     */
+    getInformationFromMaterial(material) {
+        const informationFromMaterial = { textureData: { name: null } };
+        if (material) {
+            const materialDefinition = this.tileset.materialDefinitions?.[material.definition];
+            if (materialDefinition) {
+                informationFromMaterial.materialDefinition = materialDefinition;
+                const textureSetDefinitionIndex = materialDefinition?.pbrMetallicRoughness?.baseColorTexture?.textureSetDefinitionId;
+                if (typeof textureSetDefinitionIndex === 'number') {
+                    informationFromMaterial.textureData =
+                        this.textureDefinitionsSelectedFormats[textureSetDefinitionIndex] ||
+                            informationFromMaterial.textureData;
+                }
+            }
+        }
+        return informationFromMaterial;
     }
-
-    return [textureDataDefault, null];
-  }
-
-  initSelectedFormatsForTextureDefinitions(tileset) {
-    this.textureDefinitionsSelectedFormats = [];
-    const possibleI3sFormats = this.getSupportedTextureFormats();
-    const textureSetDefinitions = tileset.textureSetDefinitions || [];
-
-    for (const textureSetDefinition of textureSetDefinitions) {
-      const formats = textureSetDefinition && textureSetDefinition.formats || [];
-      let selectedFormat = null;
-
-      for (const i3sFormat of possibleI3sFormats) {
-        const format = formats.find(value => value.format === i3sFormat);
-
-        if (format) {
-          selectedFormat = format;
-          break;
+    /**
+     * Sets preferable and supported format for each textureDefinition of the tileset
+     * @param tileset - I3S layer data
+     * @returns
+     */
+    initSelectedFormatsForTextureDefinitions(tileset) {
+        this.textureDefinitionsSelectedFormats = [];
+        const possibleI3sFormats = this.getSupportedTextureFormats();
+        const textureSetDefinitions = tileset.textureSetDefinitions || [];
+        for (const textureSetDefinition of textureSetDefinitions) {
+            const formats = (textureSetDefinition && textureSetDefinition.formats) || [];
+            let selectedFormat = null;
+            for (const i3sFormat of possibleI3sFormats) {
+                const format = formats.find((value) => value.format === i3sFormat);
+                if (format) {
+                    selectedFormat = format;
+                    break;
+                }
+            }
+            // For I3S 1.8 need to define basis target format to decode
+            if (selectedFormat && selectedFormat.format === 'ktx2') {
+                this.textureLoaderOptions.basis = {
+                    format: (0, textures_1.selectSupportedBasisFormat)(),
+                    containerFormat: 'ktx2',
+                    module: 'encoder'
+                };
+            }
+            this.textureDefinitionsSelectedFormats.push(selectedFormat);
         }
-      }
-
-      if (selectedFormat && selectedFormat.format === 'ktx2') {
-        this.textureLoaderOptions.basis = {
-          format: selectSupportedBasisFormat(),
-          containerFormat: 'ktx2',
-          module: 'encoder'
-        };
-      }
-
-      this.textureDefinitionsSelectedFormats.push(selectedFormat);
     }
-  }
-
-  getSupportedTextureFormats() {
-    const formats = [];
-
-    if (!this.options.i3s || this.options.i3s.useCompressedTextures) {
-      const supportedCompressedFormats = getSupportedGPUTextureFormats();
-
-      if (supportedCompressedFormats.has('etc2')) {
-        formats.push('ktx-etc2');
-      }
-
-      if (supportedCompressedFormats.has('dxt')) {
-        formats.push('dds');
-      }
-
-      formats.push('ktx2');
+    /**
+     * Returns the array of supported texture format
+     * @returns list of format strings
+     */
+    getSupportedTextureFormats() {
+        const formats = [];
+        // @ts-expect-error this.options is not properly typed
+        if (!this.options.i3s || this.options.i3s.useCompressedTextures) {
+            // I3S 1.7 selection
+            const supportedCompressedFormats = (0, textures_1.getSupportedGPUTextureFormats)();
+            // List of possible in i3s formats:
+            // https://github.com/Esri/i3s-spec/blob/master/docs/1.7/textureSetDefinitionFormat.cmn.md
+            if (supportedCompressedFormats.has('etc2')) {
+                formats.push('ktx-etc2');
+            }
+            if (supportedCompressedFormats.has('dxt')) {
+                formats.push('dds');
+            }
+            // I3S 1.8 selection
+            // ktx2 wraps basis texture which at the edge case can be decoded as uncompressed image
+            formats.push('ktx2');
+        }
+        formats.push('jpg');
+        formats.push('png');
+        return formats;
     }
-
-    formats.push('jpg');
-    formats.push('png');
-    return formats;
-  }
-
 }
-//# sourceMappingURL=i3s-nodepages-tiles.js.map
+exports.default = I3SNodePagesTiles;

package/dist/lib/parsers/constants.d.ts

@@ -0,0 +1,40 @@
+export declare function getConstructorForDataFormat(dataType: string): Uint8ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor;
+export declare const GL_TYPE_MAP: {
+    [key: string]: number;
+};
+/**
+ * Returns how many bytes a type occupies
+ * @param dataType
+ * @returns
+ */
+export declare function sizeOf(dataType: string): number;
+export declare const STRING_ATTRIBUTE_TYPE = "String";
+export declare const OBJECT_ID_ATTRIBUTE_TYPE = "Oid32";
+export declare const FLOAT_64_TYPE = "Float64";
+export declare const INT_16_ATTRIBUTE_TYPE = "Int16";
+export declare enum COORDINATE_SYSTEM {
+    /**
+     * `LNGLAT` if rendering into a geospatial viewport, `CARTESIAN` otherwise
+     */
+    DEFAULT = -1,
+    /**
+     * Positions are interpreted as [lng, lat, elevation]
+     * lng lat are degrees, elevation is meters. distances as meters.
+     */
+    LNGLAT = 1,
+    /**
+     * Positions are interpreted as meter offsets, distances as meters
+     */
+    METER_OFFSETS = 2,
+    /**
+     * Positions are interpreted as lng lat offsets: [deltaLng, deltaLat, elevation]
+     * deltaLng, deltaLat are delta degrees, elevation is meters.
+     * distances as meters.
+     */
+    LNGLAT_OFFSETS = 3,
+    /**
+     * Non-geospatial
+     */
+    CARTESIAN = 0
+}
+//# sourceMappingURL=constants.d.ts.map

package/dist/lib/parsers/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/constants.ts"],"names":[],"mappings":"AAGA,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,+HAe3D;AAED,eAAO,MAAM,WAAW,EAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAM/C,CAAC;AACF;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAkB/C;AAED,eAAO,MAAM,qBAAqB,WAAW,CAAC;AAC9C,eAAO,MAAM,wBAAwB,UAAU,CAAC;AAChD,eAAO,MAAM,aAAa,YAAY,CAAC;AACvC,eAAO,MAAM,qBAAqB,UAAU,CAAC;AAI7C,oBAAY,iBAAiB;IAC3B;;OAEG;IACH,OAAO,KAAK;IACZ;;;OAGG;IACH,MAAM,IAAI;IACV;;OAEG;IACH,aAAa,IAAI;IACjB;;;;OAIG;IACH,cAAc,IAAI;IAClB;;OAEG;IACH,SAAS,IAAI;CACd"}

package/dist/lib/parsers/constants.js

@@ -1,44 +1,89 @@
-import GL from '@luma.gl/constants';
-export const TYPE_ARRAY_MAP = {
-  UInt8: Uint8Array,
-  UInt16: Uint16Array,
-  UInt32: Uint32Array,
-  Float32: Float32Array,
-  UInt64: Float64Array
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-export const GL_TYPE_MAP = {
-  UInt8: GL.UNSIGNED_BYTE,
-  UInt16: GL.UNSIGNED_INT,
-  Float32: GL.FLOAT,
-  UInt32: GL.UNSIGNED_INT,
-  UInt64: GL.DOUBLE
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COORDINATE_SYSTEM = exports.INT_16_ATTRIBUTE_TYPE = exports.FLOAT_64_TYPE = exports.OBJECT_ID_ATTRIBUTE_TYPE = exports.STRING_ATTRIBUTE_TYPE = exports.sizeOf = exports.GL_TYPE_MAP = exports.getConstructorForDataFormat = void 0;
+const constants_1 = __importDefault(require("@luma.gl/constants"));
+const types_1 = require("../../types");
+function getConstructorForDataFormat(dataType) {
+    switch (dataType) {
+        case types_1.DATA_TYPE.UInt8:
+            return Uint8Array;
+        case types_1.DATA_TYPE.UInt16:
+            return Uint16Array;
+        case types_1.DATA_TYPE.UInt32:
+            return Uint32Array;
+        case types_1.DATA_TYPE.Float32:
+            return Float32Array;
+        case types_1.DATA_TYPE.UInt64:
+            return Float64Array;
+        default:
+            throw new Error(`parse i3s tile content: unknown type of data: ${dataType}`);
+    }
+}
+exports.getConstructorForDataFormat = getConstructorForDataFormat;
+exports.GL_TYPE_MAP = {
+    UInt8: constants_1.default.UNSIGNED_BYTE,
+    UInt16: constants_1.default.UNSIGNED_SHORT,
+    Float32: constants_1.default.FLOAT,
+    UInt32: constants_1.default.UNSIGNED_INT,
+    UInt64: constants_1.default.DOUBLE
 };
-export const I3S_NAMED_VERTEX_ATTRIBUTES = {
-  position: 'position',
-  normal: 'normal',
-  uv0: 'uv0',
-  color: 'color',
-  region: 'region'
-};
-export const I3S_NAMED_GEOMETRY_ATTRIBUTES = {
-  vertexAttributes: 'vertexAttributes',
-  featureAttributeOrder: 'featureAttributeOrder',
-  featureAttributes: 'featureAttributes'
-};
-export const I3S_NAMED_HEADER_ATTRIBUTES = {
-  header: 'header',
-  vertexCount: 'vertexCount',
-  featureCount: 'featureCount'
-};
-export const SIZEOF = {
-  UInt8: 1,
-  UInt16: 2,
-  UInt32: 4,
-  Float32: 4,
-  UInt64: 8
-};
-export const STRING_ATTRIBUTE_TYPE = 'String';
-export const OBJECT_ID_ATTRIBUTE_TYPE = 'Oid32';
-export const FLOAT_64_TYPE = 'Float64';
-export const INT_16_ATTRIBUTE_TYPE = 'Int16';
-//# sourceMappingURL=constants.js.map
+/**
+ * Returns how many bytes a type occupies
+ * @param dataType
+ * @returns
+ */
+function sizeOf(dataType) {
+    switch (dataType) {
+        case types_1.DATA_TYPE.UInt8:
+            return 1;
+        case types_1.DATA_TYPE.UInt16:
+        case types_1.DATA_TYPE.Int16:
+            return 2;
+        case types_1.DATA_TYPE.UInt32:
+        case types_1.DATA_TYPE.Int32:
+        case types_1.DATA_TYPE.Float32:
+            return 4;
+        case types_1.DATA_TYPE.UInt64:
+        case types_1.DATA_TYPE.Int64:
+        case types_1.DATA_TYPE.Float64:
+            return 8;
+        default:
+            throw new Error(`parse i3s tile content: unknown size of data: ${dataType}`);
+    }
+}
+exports.sizeOf = sizeOf;
+exports.STRING_ATTRIBUTE_TYPE = 'String';
+exports.OBJECT_ID_ATTRIBUTE_TYPE = 'Oid32';
+exports.FLOAT_64_TYPE = 'Float64';
+exports.INT_16_ATTRIBUTE_TYPE = 'Int16';
+// https://github.com/visgl/deck.gl/blob/9548f43cba2234a1f4877b6b17f6c88eb35b2e08/modules/core/src/lib/constants.js#L27
+// Describes the format of positions
+var COORDINATE_SYSTEM;
+(function (COORDINATE_SYSTEM) {
+    /**
+     * `LNGLAT` if rendering into a geospatial viewport, `CARTESIAN` otherwise
+     */
+    COORDINATE_SYSTEM[COORDINATE_SYSTEM["DEFAULT"] = -1] = "DEFAULT";
+    /**
+     * Positions are interpreted as [lng, lat, elevation]
+     * lng lat are degrees, elevation is meters. distances as meters.
+     */
+    COORDINATE_SYSTEM[COORDINATE_SYSTEM["LNGLAT"] = 1] = "LNGLAT";
+    /**
+     * Positions are interpreted as meter offsets, distances as meters
+     */
+    COORDINATE_SYSTEM[COORDINATE_SYSTEM["METER_OFFSETS"] = 2] = "METER_OFFSETS";
+    /**
+     * Positions are interpreted as lng lat offsets: [deltaLng, deltaLat, elevation]
+     * deltaLng, deltaLat are delta degrees, elevation is meters.
+     * distances as meters.
+     */
+    COORDINATE_SYSTEM[COORDINATE_SYSTEM["LNGLAT_OFFSETS"] = 3] = "LNGLAT_OFFSETS";
+    /**
+     * Non-geospatial
+     */
+    COORDINATE_SYSTEM[COORDINATE_SYSTEM["CARTESIAN"] = 0] = "CARTESIAN";
+})(COORDINATE_SYSTEM = exports.COORDINATE_SYSTEM || (exports.COORDINATE_SYSTEM = {}));

package/dist/lib/parsers/parse-arcgis-webscene.d.ts

@@ -0,0 +1,7 @@
+import type { ArcGisWebSceneData } from '../../types';
+/**
+ * Parses ArcGIS WebScene
+ * @param data
+ */
+export declare function parseWebscene(data: ArrayBuffer): Promise<ArcGisWebSceneData>;
+//# sourceMappingURL=parse-arcgis-webscene.d.ts.map

package/dist/lib/parsers/parse-arcgis-webscene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-arcgis-webscene.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-arcgis-webscene.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,kBAAkB,EAAmB,MAAM,aAAa,CAAC;AA2BtE;;;GAGG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAclF"}