@loaders.gl/i3s 3.1.0-alpha.5 → 3.1.0-beta.7

package/dist/lib/parsers/parse-i3s-attribute.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseI3STileAttribute = void 0;
+const constants_1 = require("./constants");
+/**
+ * Get particular tile and creates attribute object inside.
+ * @param {ArrayBuffer} arrayBuffer
+ * @param {Object} options
+ * @returns {Promise<object>}
+ */
+async function parseI3STileAttribute(arrayBuffer, options) {
+    const { attributeName, attributeType } = options;
+    if (!attributeName) {
+        return {};
+    }
+    return {
+        [attributeName]: attributeType ? parseAttribute(attributeType, arrayBuffer) : null
+    };
+}
+exports.parseI3STileAttribute = parseI3STileAttribute;
+/**
+ * Parse attributes based on attribute type.
+ * @param {String} attributeType
+ * @param {ArrayBuffer} arrayBuffer
+ * @returns {any}
+ */
+function parseAttribute(attributeType, arrayBuffer) {
+    switch (attributeType) {
+        case constants_1.STRING_ATTRIBUTE_TYPE:
+            return parseStringsAttribute(arrayBuffer);
+        case constants_1.OBJECT_ID_ATTRIBUTE_TYPE:
+            return parseShortNumberAttribute(arrayBuffer);
+        case constants_1.FLOAT_64_TYPE:
+            return parseFloatAttribute(arrayBuffer);
+        case constants_1.INT_16_ATTRIBUTE_TYPE:
+            return parseInt16ShortNumberAttribute(arrayBuffer);
+        default:
+            return parseShortNumberAttribute(arrayBuffer);
+    }
+}
+/**
+ * Parse short number attribute.
+ * Short Integer spec - https://github.com/Esri/i3s-spec/blob/master/docs/1.7/attributeStorageInfo.cmn.md
+ * @param {ArrayBuffer} arrayBuffer
+ * @returns {Uint32Array}
+ */
+function parseShortNumberAttribute(arrayBuffer) {
+    const countOffset = 4;
+    return new Uint32Array(arrayBuffer, countOffset);
+}
+/**
+ * Parse Int16 short number attribute.
+ * Parsing of such data is not documented. Added to handle Building Scene Layer Tileset attributes data.
+ * @param {ArrayBuffer} arrayBuffer
+ * @returns {Int16Array}
+ */
+function parseInt16ShortNumberAttribute(arrayBuffer) {
+    const countOffset = 4;
+    return new Int16Array(arrayBuffer, countOffset);
+}
+/**
+ * Parse float attribute.
+ * Double Spec - https://github.com/Esri/i3s-spec/blob/master/docs/1.7/attributeStorageInfo.cmn.md
+ * @param {ArrayBuffer} arrayBuffer
+ * @returns {Float64Array}
+ */
+function parseFloatAttribute(arrayBuffer) {
+    const countOffset = 8;
+    return new Float64Array(arrayBuffer, countOffset);
+}
+/**
+ * Parse string attribute.
+ * String spec - https://github.com/Esri/i3s-spec/blob/master/docs/1.7/attributeStorageInfo.cmn.md
+ * @param arrayBuffer
+ * @returns list of strings
+ */
+function parseStringsAttribute(arrayBuffer) {
+    const stringsCountOffset = 0;
+    const dataOffset = 8;
+    const bytesPerStringSize = 4;
+    const stringsArray = [];
+    try {
+        // Use DataView to avoid multiple of 4 error on Uint32Array constructor
+        const stringsCount = new DataView(arrayBuffer, stringsCountOffset, bytesPerStringSize).getUint32(stringsCountOffset, true);
+        const stringSizes = new Uint32Array(arrayBuffer, dataOffset, stringsCount);
+        let stringOffset = dataOffset + stringsCount * bytesPerStringSize;
+        for (const stringByteSize of stringSizes) {
+            const textDecoder = new TextDecoder('utf-8');
+            const stringAttribute = new Uint8Array(arrayBuffer, stringOffset, stringByteSize);
+            stringsArray.push(textDecoder.decode(stringAttribute));
+            stringOffset += stringByteSize;
+        }
+    }
+    catch (error) {
+        console.error('Parse string attribute error: ', error.message); // eslint-disable-line
+    }
+    return stringsArray;
+}

package/dist/lib/parsers/parse-i3s-building-scene-layer.d.ts

@@ -6,3 +6,4 @@ import type { BuildingSceneLayerTileset } from '../../types';
  * @param context
  */
 export declare function parseBuildingSceneLayer(data: ArrayBuffer, url: string): Promise<BuildingSceneLayerTileset>;
+//# sourceMappingURL=parse-i3s-building-scene-layer.d.ts.map

package/dist/lib/parsers/parse-i3s-building-scene-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-i3s-building-scene-layer.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-i3s-building-scene-layer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,yBAAyB,EAAwB,MAAM,aAAa,CAAC;AAIlF;;;;;GAKG;AACH,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,yBAAyB,CAAC,CAQpC"}

package/dist/lib/parsers/parse-i3s-building-scene-layer.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBuildingSceneLayer = void 0;
+const OBJECT_3D_LAYER_TYPE = '3DObject';
+/**
+ * Parses Builiding Scene Layer and creates tileset
+ * @param data
+ * @param options
+ * @param context
+ */
+async function parseBuildingSceneLayer(data, url) {
+    const layer0 = JSON.parse(new TextDecoder().decode(data));
+    const { sublayers } = layer0;
+    return {
+        header: layer0,
+        sublayers: parseSublayersTree(sublayers, url)
+    };
+}
+exports.parseBuildingSceneLayer = parseBuildingSceneLayer;
+/**
+ * Recursively parses Building Scene Layer sublayers.
+ * @param sublayers
+ * @param url
+ */
+function parseSublayersTree(sublayers, url) {
+    let layers = [];
+    for (let index = 0; index < sublayers.length; index++) {
+        const subLayer = sublayers[index];
+        const { id, layerType, visibility = true, ...rest } = subLayer;
+        // Add support only for 3DObject layer type for I3S purposes.
+        if (layerType === OBJECT_3D_LAYER_TYPE) {
+            const sublayerUrl = `${url}/sublayers/${id}`;
+            layers.push({
+                url: sublayerUrl,
+                id,
+                layerType,
+                visibility,
+                ...rest
+            });
+        }
+        if (subLayer?.sublayers?.length) {
+            layers = [...layers, ...parseSublayersTree(subLayer.sublayers, url)];
+        }
+    }
+    return layers;
+}

package/dist/lib/parsers/parse-i3s-tile-content.d.ts

@@ -1,3 +1,4 @@
 import type { LoaderOptions, LoaderContext } from '@loaders.gl/loader-utils';
-import { Tileset, Tile } from '../../types';
+import type { Tileset, Tile } from '../../types';
 export declare function parseI3STileContent(arrayBuffer: ArrayBuffer, tile: Tile, tileset: Tileset, options?: LoaderOptions, context?: LoaderContext): Promise<Tile>;
+//# sourceMappingURL=parse-i3s-tile-content.d.ts.map

package/dist/lib/parsers/parse-i3s-tile-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-i3s-tile-content.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-i3s-tile-content.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAK3E,OAAO,KAAK,EACV,OAAO,EACP,IAAI,EAOL,MAAM,aAAa,CAAC;AAgCrB,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,OAAO,EAChB,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,iBAkDxB"}

package/dist/lib/parsers/parse-i3s-tile-content.js

@@ -0,0 +1,508 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseI3STileContent = void 0;
+const core_1 = require("@loaders.gl/core");
+const core_2 = require("@math.gl/core");
+const geospatial_1 = require("@math.gl/geospatial");
+const images_1 = require("@loaders.gl/images");
+const draco_1 = require("@loaders.gl/draco");
+const textures_1 = require("@loaders.gl/textures");
+const url_utils_1 = require("../utils/url-utils");
+const constants_1 = require("./constants");
+const scratchVector = new core_2.Vector3([0, 0, 0]);
+function getLoaderForTextureFormat(textureFormat) {
+    switch (textureFormat) {
+        case 'jpeg':
+        case 'png':
+            return images_1.ImageLoader;
+        case 'ktx-etc2':
+        case 'dds':
+            return textures_1.CompressedTextureLoader;
+        case 'ktx2':
+            return textures_1.BasisLoader;
+        default:
+            return null;
+    }
+}
+const I3S_ATTRIBUTE_TYPE = 'i3s-attribute-type';
+async function parseI3STileContent(arrayBuffer, tile, tileset, options, context) {
+    tile.content = tile.content || {};
+    tile.content.featureIds = tile.content.featureIds || null;
+    // construct featureData from defaultGeometrySchema;
+    tile.content.featureData = constructFeatureDataStruct(tileset);
+    tile.content.attributes = {};
+    if (tile.textureUrl) {
+        const url = (0, url_utils_1.getUrlWithToken)(tile.textureUrl, options?.i3s?.token);
+        const loader = getLoaderForTextureFormat(tile.textureFormat) || images_1.ImageLoader;
+        // @ts-ignore context must be defined
+        const response = await fetch(url);
+        const arrayBuffer = await response.arrayBuffer();
+        if (options?.i3s.decodeTextures) {
+            if (loader === images_1.ImageLoader) {
+                const options = { ...tile.textureLoaderOptions, image: { type: 'data' } };
+                try {
+                    // @ts-ignore context must be defined
+                    // Image constructor is not supported in worker thread.
+                    // Do parsing image data on the main thread by using context to avoid worker issues.
+                    tile.content.texture = await context.parse(arrayBuffer, options);
+                }
+                catch (e) {
+                    // context object is different between worker and node.js conversion script.
+                    // To prevent error we parse data in ordinary way if it is not parsed by using context.
+                    tile.content.texture = await (0, core_1.parse)(arrayBuffer, loader, options);
+                }
+            }
+            else if (loader === textures_1.CompressedTextureLoader || loader === textures_1.BasisLoader) {
+                const texture = await (0, core_1.load)(arrayBuffer, loader, tile.textureLoaderOptions);
+                tile.content.texture = {
+                    compressed: true,
+                    mipmaps: false,
+                    width: texture[0].width,
+                    height: texture[0].height,
+                    data: texture
+                };
+            }
+        }
+        else {
+            tile.content.texture = arrayBuffer;
+        }
+    }
+    tile.content.material = makePbrMaterial(tile.materialDefinition, tile.content.texture);
+    if (tile.content.material) {
+        tile.content.texture = null;
+    }
+    return await parseI3SNodeGeometry(arrayBuffer, tile, options);
+}
+exports.parseI3STileContent = parseI3STileContent;
+/* eslint-disable max-statements */
+async function parseI3SNodeGeometry(arrayBuffer, tile, options) {
+    if (!tile.content) {
+        return tile;
+    }
+    const content = tile.content;
+    let attributes;
+    let vertexCount;
+    let byteOffset = 0;
+    let featureCount = 0;
+    if (tile.isDracoGeometry) {
+        const decompressedGeometry = await (0, core_1.parse)(arrayBuffer, draco_1.DracoLoader, {
+            draco: {
+                attributeNameEntry: I3S_ATTRIBUTE_TYPE
+            }
+        });
+        vertexCount = decompressedGeometry.header.vertexCount;
+        const indices = decompressedGeometry.indices.value;
+        const { POSITION, NORMAL, COLOR_0, TEXCOORD_0, ['feature-index']: featureIndex, ['uv-region']: uvRegion } = decompressedGeometry.attributes;
+        attributes = {
+            position: POSITION,
+            normal: NORMAL,
+            color: COLOR_0,
+            uv0: TEXCOORD_0,
+            uvRegion,
+            id: featureIndex,
+            indices
+        };
+        updateAttributesMetadata(attributes, decompressedGeometry);
+        const featureIds = getFeatureIdsFromFeatureIndexMetadata(featureIndex);
+        if (featureIds) {
+            flattenFeatureIdsByFeatureIndices(attributes, featureIds);
+        }
+    }
+    else {
+        const { vertexAttributes, attributesOrder, featureAttributes, featureAttributeOrder } = content.featureData;
+        // First 8 bytes reserved for header (vertexCount and featureCount)
+        const headers = parseHeaders(content, arrayBuffer);
+        byteOffset = headers.byteOffset;
+        vertexCount = headers.vertexCount;
+        featureCount = headers.featureCount;
+        // Getting vertex attributes such as positions, normals, colors, etc...
+        const { attributes: normalizedVertexAttributes, byteOffset: offset } = normalizeAttributes(arrayBuffer, byteOffset, vertexAttributes, vertexCount, 
+        // @ts-expect-error
+        attributesOrder);
+        // Getting feature attributes such as featureIds and faceRange
+        const { attributes: normalizedFeatureAttributes } = normalizeAttributes(arrayBuffer, offset, featureAttributes, featureCount, featureAttributeOrder);
+        flattenFeatureIdsByFaceRanges(normalizedFeatureAttributes);
+        attributes = concatAttributes(normalizedVertexAttributes, normalizedFeatureAttributes);
+    }
+    if (!options?.i3s?.coordinateSystem ||
+        options.i3s.coordinateSystem === constants_1.COORDINATE_SYSTEM.METER_OFFSETS) {
+        const enuMatrix = parsePositions(attributes.position, tile);
+        content.modelMatrix = enuMatrix.invert();
+        content.coordinateSystem = constants_1.COORDINATE_SYSTEM.METER_OFFSETS;
+    }
+    else {
+        content.modelMatrix = getModelMatrix(attributes.position);
+        content.coordinateSystem = constants_1.COORDINATE_SYSTEM.LNGLAT_OFFSETS;
+    }
+    content.attributes = {
+        positions: attributes.position,
+        normals: attributes.normal,
+        colors: normalizeAttribute(attributes.color),
+        texCoords: attributes.uv0,
+        uvRegions: normalizeAttribute(attributes.uvRegion) // Normalize from UInt16
+    };
+    content.indices = attributes.indices || null;
+    if (attributes.id && attributes.id.value) {
+        tile.content.featureIds = attributes.id.value;
+    }
+    // Remove undefined attributes
+    for (const attributeIndex in content.attributes) {
+        if (!content.attributes[attributeIndex]) {
+            delete content.attributes[attributeIndex];
+        }
+    }
+    content.vertexCount = vertexCount;
+    content.byteLength = arrayBuffer.byteLength;
+    return tile;
+}
+/**
+ * Update attributes with metadata from decompressed geometry.
+ * @param decompressedGeometry
+ * @param attributes
+ */
+function updateAttributesMetadata(attributes, decompressedGeometry) {
+    for (const key in decompressedGeometry.loaderData.attributes) {
+        const dracoAttribute = decompressedGeometry.loaderData.attributes[key];
+        switch (dracoAttribute.name) {
+            case 'POSITION':
+                attributes.position.metadata = dracoAttribute.metadata;
+                break;
+            case 'feature-index':
+                attributes.id.metadata = dracoAttribute.metadata;
+                break;
+            default:
+                break;
+        }
+    }
+}
+/**
+ * Do concatenation of attribute objects.
+ * Done as separate fucntion to avoid ts errors.
+ * @param normalizedVertexAttributes
+ * @param normalizedFeatureAttributes
+ * @returns - result of attributes concatenation.
+ */
+function concatAttributes(normalizedVertexAttributes, normalizedFeatureAttributes) {
+    return { ...normalizedVertexAttributes, ...normalizedFeatureAttributes };
+}
+/**
+ * Normalize attribute to range [0..1] . Eg. convert colors buffer from [255,255,255,255] to [1,1,1,1]
+ * @param attribute - geometry attribute
+ * @returns - geometry attribute in right format
+ */
+function normalizeAttribute(attribute) {
+    if (!attribute) {
+        return attribute;
+    }
+    attribute.normalized = true;
+    return attribute;
+}
+function constructFeatureDataStruct(tileset) {
+    // seed featureData from defaultGeometrySchema
+    const defaultGeometrySchema = tileset.store.defaultGeometrySchema;
+    const featureData = defaultGeometrySchema;
+    // populate the vertex attributes value types and values per element
+    for (const geometryAttribute in constants_1.I3S_NAMED_GEOMETRY_ATTRIBUTES) {
+        for (const namedAttribute in constants_1.I3S_NAMED_VERTEX_ATTRIBUTES) {
+            const attribute = defaultGeometrySchema[geometryAttribute][namedAttribute];
+            if (attribute) {
+                const { byteOffset = 0, count = 0, valueType, valuesPerElement } = attribute;
+                featureData[geometryAttribute][namedAttribute] = {
+                    valueType,
+                    valuesPerElement,
+                    byteOffset,
+                    count
+                };
+            }
+        }
+    }
+    featureData.attributesOrder = defaultGeometrySchema.ordering;
+    return featureData;
+}
+function parseHeaders(content, arrayBuffer) {
+    let byteOffset = 0;
+    // First 8 bytes reserved for header (vertexCount and featurecount)
+    let vertexCount = 0;
+    let featureCount = 0;
+    content.featureData.header.forEach(({ property, type }) => {
+        const TypedArrayTypeHeader = (0, constants_1.getConstructorForDataFormat)(type);
+        if (property === constants_1.I3S_NAMED_HEADER_ATTRIBUTES.vertexCount) {
+            // @ts-expect-error
+            vertexCount = new TypedArrayTypeHeader(arrayBuffer, 0, 4)[0];
+            byteOffset += (0, constants_1.sizeOf)(type);
+        }
+        if (property === constants_1.I3S_NAMED_HEADER_ATTRIBUTES.featureCount) {
+            // @ts-expect-error
+            featureCount = new TypedArrayTypeHeader(arrayBuffer, 4, 4)[0];
+            byteOffset += (0, constants_1.sizeOf)(type);
+        }
+    });
+    return {
+        vertexCount,
+        featureCount,
+        byteOffset
+    };
+}
+/* eslint-enable max-statements */
+function normalizeAttributes(arrayBuffer, byteOffset, vertexAttributes, vertexCount, attributesOrder) {
+    const attributes = {};
+    // the order of attributes depend on the order being added to the vertexAttributes object
+    for (const attribute of attributesOrder) {
+        if (vertexAttributes[attribute]) {
+            const { valueType, valuesPerElement } = vertexAttributes[attribute];
+            // update count and byteOffset count by calculating from defaultGeometrySchema + binnary content
+            const count = vertexCount;
+            // protect from arrayBuffer read overunns by NOT assuming node has regions always even though its declared in defaultGeometrySchema.
+            // In i3s 1.6: client is required to decide that based on ./shared resource of the node (materialDefinitions.[Mat_id].params.vertexRegions == true)
+            // In i3s 1.7 the property has been rolled into the 3d scene layer json/node pages.
+            // Code below does not account when the bytelength is actually bigger than
+            // the calculated value (b\c the tile potentially could have mesh segmentation information).
+            // In those cases tiles without regions could fail or have garbage values.
+            if (byteOffset + count * valuesPerElement > arrayBuffer.byteLength) {
+                break;
+            }
+            const buffer = arrayBuffer.slice(byteOffset);
+            let value = [];
+            if (valueType === 'UInt64') {
+                value = parseUint64Values(buffer, count * valuesPerElement, (0, constants_1.sizeOf)(valueType));
+            }
+            else {
+                const TypedArrayType = (0, constants_1.getConstructorForDataFormat)(valueType);
+                // @ts-expect-error
+                value = new TypedArrayType(buffer, 0, count * valuesPerElement);
+            }
+            attributes[attribute] = {
+                value,
+                type: constants_1.GL_TYPE_MAP[valueType],
+                size: valuesPerElement
+            };
+            switch (attribute) {
+                case 'color':
+                    attributes.color.normalized = true;
+                    break;
+                case 'position':
+                case 'region':
+                case 'normal':
+                default:
+            }
+            byteOffset = byteOffset + count * valuesPerElement * (0, constants_1.sizeOf)(valueType);
+        }
+    }
+    return { attributes, byteOffset };
+}
+/**
+ * Parse buffer to return array of uint64 values
+ *
+ * @param buffer
+ * @param elementsCount
+ * @returns 64-bit array of values until precision is lost after Number.MAX_SAFE_INTEGER
+ */
+function parseUint64Values(buffer, elementsCount, attributeSize) {
+    const values = [];
+    const dataView = new DataView(buffer);
+    let offset = 0;
+    for (let index = 0; index < elementsCount; index++) {
+        // split 64-bit number into two 32-bit parts
+        const left = dataView.getUint32(offset, true);
+        const right = dataView.getUint32(offset + 4, true);
+        // combine the two 32-bit values
+        const value = left + 2 ** 32 * right;
+        values.push(value);
+        offset += attributeSize;
+    }
+    return values;
+}
+function parsePositions(attribute, tile) {
+    const mbs = tile.mbs;
+    const value = attribute.value;
+    const metadata = attribute.metadata;
+    const enuMatrix = new core_2.Matrix4();
+    const cartographicOrigin = new core_2.Vector3(mbs[0], mbs[1], mbs[2]);
+    const cartesianOrigin = new core_2.Vector3();
+    geospatial_1.Ellipsoid.WGS84.cartographicToCartesian(cartographicOrigin, cartesianOrigin);
+    geospatial_1.Ellipsoid.WGS84.eastNorthUpToFixedFrame(cartesianOrigin, enuMatrix);
+    attribute.value = offsetsToCartesians(value, metadata, cartographicOrigin);
+    return enuMatrix;
+}
+/**
+ * Converts position coordinates to absolute cartesian coordinates
+ * @param vertices - "position" attribute data
+ * @param metadata - When the geometry is DRACO compressed, contain position attribute's metadata
+ *  https://github.com/Esri/i3s-spec/blob/master/docs/1.7/compressedAttributes.cmn.md
+ * @param cartographicOrigin - Cartographic origin coordinates
+ * @returns - converted "position" data
+ */
+function offsetsToCartesians(vertices, metadata = {}, cartographicOrigin) {
+    const positions = new Float64Array(vertices.length);
+    const scaleX = (metadata['i3s-scale_x'] && metadata['i3s-scale_x'].double) || 1;
+    const scaleY = (metadata['i3s-scale_y'] && metadata['i3s-scale_y'].double) || 1;
+    for (let i = 0; i < positions.length; i += 3) {
+        positions[i] = vertices[i] * scaleX + cartographicOrigin.x;
+        positions[i + 1] = vertices[i + 1] * scaleY + cartographicOrigin.y;
+        positions[i + 2] = vertices[i + 2] + cartographicOrigin.z;
+    }
+    for (let i = 0; i < positions.length; i += 3) {
+        // @ts-ignore
+        geospatial_1.Ellipsoid.WGS84.cartographicToCartesian(positions.subarray(i, i + 3), scratchVector);
+        positions[i] = scratchVector.x;
+        positions[i + 1] = scratchVector.y;
+        positions[i + 2] = scratchVector.z;
+    }
+    return positions;
+}
+/**
+ * Get model matrix for loaded vertices
+ * @param positions positions attribute
+ * @returns Matrix4 - model matrix for geometry transformation
+ */
+function getModelMatrix(positions) {
+    const metadata = positions.metadata;
+    const scaleX = metadata?.['i3s-scale_x']?.double || 1;
+    const scaleY = metadata?.['i3s-scale_y']?.double || 1;
+    const modelMatrix = new core_2.Matrix4();
+    modelMatrix[0] = scaleX;
+    modelMatrix[5] = scaleY;
+    return modelMatrix;
+}
+/**
+ * Makes a glTF-compatible PBR material from an I3S material definition
+ * @param materialDefinition - i3s material definition
+ *  https://github.com/Esri/i3s-spec/blob/master/docs/1.7/materialDefinitions.cmn.md
+ * @param texture - texture image
+ * @returns {object}
+ */
+function makePbrMaterial(materialDefinition, texture) {
+    let pbrMaterial;
+    if (materialDefinition) {
+        pbrMaterial = {
+            ...materialDefinition,
+            pbrMetallicRoughness: materialDefinition.pbrMetallicRoughness
+                ? { ...materialDefinition.pbrMetallicRoughness }
+                : { baseColorFactor: [255, 255, 255, 255] }
+        };
+    }
+    else {
+        pbrMaterial = {
+            pbrMetallicRoughness: {}
+        };
+        if (texture) {
+            pbrMaterial.pbrMetallicRoughness.baseColorTexture = { texCoord: 0 };
+        }
+        else {
+            pbrMaterial.pbrMetallicRoughness.baseColorFactor = [255, 255, 255, 255];
+        }
+    }
+    // Set default 0.25 per spec https://github.com/Esri/i3s-spec/blob/master/docs/1.7/materialDefinitions.cmn.md
+    pbrMaterial.alphaCutoff = pbrMaterial.alphaCutoff || 0.25;
+    if (pbrMaterial.alphaMode) {
+        // I3S contain alphaMode in lowerCase
+        pbrMaterial.alphaMode = pbrMaterial.alphaMode.toUpperCase();
+    }
+    // Convert colors from [255,255,255,255] to [1,1,1,1]
+    if (pbrMaterial.emissiveFactor) {
+        pbrMaterial.emissiveFactor = convertColorFormat(pbrMaterial.emissiveFactor);
+    }
+    if (pbrMaterial.pbrMetallicRoughness && pbrMaterial.pbrMetallicRoughness.baseColorFactor) {
+        pbrMaterial.pbrMetallicRoughness.baseColorFactor = convertColorFormat(pbrMaterial.pbrMetallicRoughness.baseColorFactor);
+    }
+    setMaterialTexture(pbrMaterial, texture);
+    return pbrMaterial;
+}
+/**
+ * Convert color from [255,255,255,255] to [1,1,1,1]
+ * @param colorFactor - color array
+ * @returns - new color array
+ */
+function convertColorFormat(colorFactor) {
+    const normalizedColor = [...colorFactor];
+    for (let index = 0; index < colorFactor.length; index++) {
+        normalizedColor[index] = colorFactor[index] / 255;
+    }
+    return normalizedColor;
+}
+/**
+ * Set texture in PBR material
+ * @param {object} material - i3s material definition
+ * @param image - texture image
+ * @returns
+ */
+function setMaterialTexture(material, image) {
+    const texture = { source: { image } };
+    // I3SLoader now support loading only one texture. This elseif sequence will assign this texture to one of
+    // properties defined in materialDefinition
+    if (material.pbrMetallicRoughness && material.pbrMetallicRoughness.baseColorTexture) {
+        material.pbrMetallicRoughness.baseColorTexture = {
+            ...material.pbrMetallicRoughness.baseColorTexture,
+            texture
+        };
+    }
+    else if (material.emissiveTexture) {
+        material.emissiveTexture = { ...material.emissiveTexture, texture };
+    }
+    else if (material.pbrMetallicRoughness &&
+        material.pbrMetallicRoughness.metallicRoughnessTexture) {
+        material.pbrMetallicRoughness.metallicRoughnessTexture = {
+            ...material.pbrMetallicRoughness.metallicRoughnessTexture,
+            texture
+        };
+    }
+    else if (material.normalTexture) {
+        material.normalTexture = { ...material.normalTexture, texture };
+    }
+    else if (material.occlusionTexture) {
+        material.occlusionTexture = { ...material.occlusionTexture, texture };
+    }
+}
+/**
+ * Flatten feature ids using face ranges
+ * @param normalizedFeatureAttributes
+ * @returns
+ */
+function flattenFeatureIdsByFaceRanges(normalizedFeatureAttributes) {
+    const { id, faceRange } = normalizedFeatureAttributes;
+    if (!id || !faceRange) {
+        return;
+    }
+    const featureIds = id.value;
+    const range = faceRange.value;
+    const featureIdsLength = range[range.length - 1] + 1;
+    const orderedFeatureIndices = new Uint32Array(featureIdsLength * 3);
+    let featureIndex = 0;
+    let startIndex = 0;
+    for (let index = 1; index < range.length; index += 2) {
+        const fillId = Number(featureIds[featureIndex]);
+        const endValue = range[index];
+        const prevValue = range[index - 1];
+        const trianglesCount = endValue - prevValue + 1;
+        const endIndex = startIndex + trianglesCount * 3;
+        orderedFeatureIndices.fill(fillId, startIndex, endIndex);
+        featureIndex++;
+        startIndex = endIndex;
+    }
+    normalizedFeatureAttributes.id.value = orderedFeatureIndices;
+}
+/**
+ * Flatten feature ids using featureIndices
+ * @param attributes
+ * @param featureIds
+ * @returns
+ */
+function flattenFeatureIdsByFeatureIndices(attributes, featureIds) {
+    const featureIndices = attributes.id.value;
+    const result = new Float32Array(featureIndices.length);
+    for (let index = 0; index < featureIndices.length; index++) {
+        result[index] = featureIds[featureIndices[index]];
+    }
+    attributes.id.value = result;
+}
+/**
+ * Flatten feature ids using featureIndices
+ * @param featureIndex
+ * @returns
+ */
+function getFeatureIdsFromFeatureIndexMetadata(featureIndex) {
+    return (featureIndex &&
+        featureIndex.metadata &&
+        featureIndex.metadata['i3s-feature-ids'] &&
+        featureIndex.metadata['i3s-feature-ids'].intArray);
+}

package/dist/lib/parsers/parse-i3s.d.ts

@@ -1,3 +1,4 @@
 export declare function normalizeTileData(tile: any, options: any, context: any): any;
 export declare function normalizeTileNonUrlData(tile: any): any;
 export declare function normalizeTilesetData(tileset: any, options: any, context: any): Promise<void>;
+//# sourceMappingURL=parse-i3s.d.ts.map

package/dist/lib/parsers/parse-i3s.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-i3s.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-i3s.ts"],"names":[],"mappings":"AAOA,wBAAgB,iBAAiB,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA,EAAE,OAAO,KAAA,OAoBvD;AAED,wBAAgB,uBAAuB,CAAC,IAAI,KAAA,OAqC3C;AAED,wBAAsB,oBAAoB,CAAC,OAAO,KAAA,EAAE,OAAO,KAAA,EAAE,OAAO,KAAA,iBAqBnE"}