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

package/dist/i3s-loader.d.ts

@@ -1,4 +1,9 @@
 import type { LoaderWithParser } from '@loaders.gl/loader-utils';
+import { I3SParseOptions } from './types';
+import { LoaderOptions } from './../../loader-utils/src/types';
+export type I3SLoaderOptions = LoaderOptions & {
+    i3s?: I3SParseOptions;
+};
 /**
  * Loader for I3S - Indexed 3D Scene Layer
  */

package/dist/i3s-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"i3s-loader.d.ts","sourceRoot":"","sources":["../src/i3s-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAc/D;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,gBAsBvB,CAAC"}
+{"version":3,"file":"i3s-loader.d.ts","sourceRoot":"","sources":["../src/i3s-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAK/D,OAAO,EAAC,eAAe,EAAC,MAAM,SAAS,CAAC;AACxC,OAAO,EAAC,aAAa,EAAC,MAAM,gCAAgC,CAAC;AAW7D,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG;IAC7C,GAAG,CAAC,EAAE,eAAe,CAAC;CACvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,gBAwBvB,CAAC"}

package/dist/i3s-loader.js

@@ -11,6 +11,7 @@ const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
 const TILESET_REGEX = /layers\/[0-9]+$/;
 const TILE_HEADER_REGEX = /nodes\/([0-9-]+|root)$/;
 const SLPK_HEX = '504b0304';
+const POINT_CLOUD = 'PointCloud';
 /**
  * Loader for I3S - Indexed 3D Scene Layer
  */
@@ -24,20 +25,22 @@ exports.I3SLoader = {
     extensions: ['bin'],
     options: {
         i3s: {
-            loadContent: true,
             token: null,
             isTileset: 'auto',
             isTileHeader: 'auto',
             tile: null,
             tileset: null,
+            _tileOptions: null,
+            _tilesetOptions: null,
             useDracoGeometry: true,
             useCompressedTextures: true,
             decodeTextures: true,
-            coordinateSystem: constants_1.COORDINATE_SYSTEM.METER_OFFSETS
+            coordinateSystem: constants_1.COORDINATE_SYSTEM.METER_OFFSETS,
+            colorsByAttribute: null
         }
     }
 };
-async function parseI3S(data, options, context) {
+async function parseI3S(data, options = {}, context) {
     const url = context.url;
     options.i3s = options.i3s || {};
     const magicNumber = getMagicNumber(data);
@@ -64,11 +67,7 @@ async function parseI3S(data, options, context) {
         data = await parseTileset(data, options, context);
     }
     else if (isTileHeader) {
-        data = await parseTile(data, options, context);
-        if (options.i3s.loadContent) {
-            options.i3s.tile = data;
-            await (0, core_1.load)(data.contentUrl, exports.I3SLoader, options);
-        }
+        data = await parseTile(data, context);
     }
     else {
         data = await parseTileContent(data, options);
@@ -80,14 +79,17 @@ async function parseTileContent(arrayBuffer, options) {
 }
 async function parseTileset(data, options, context) {
     const tilesetJson = JSON.parse(new TextDecoder().decode(data));
+    if (tilesetJson?.layerType === POINT_CLOUD) {
+        throw new Error('Point Cloud layers currently are not supported by I3SLoader');
+    }
     // eslint-disable-next-line no-use-before-define
     tilesetJson.loader = exports.I3SLoader;
     await (0, parse_i3s_1.normalizeTilesetData)(tilesetJson, options, context);
     return tilesetJson;
 }
-async function parseTile(data, options, context) {
+async function parseTile(data, context) {
     data = JSON.parse(new TextDecoder().decode(data));
-    return (0, parse_i3s_1.normalizeTileData)(data, options, context);
+    return (0, parse_i3s_1.normalizeTileData)(data, context);
 }
 function getMagicNumber(data) {
     if (data instanceof ArrayBuffer) {

package/dist/index.d.ts

@@ -3,6 +3,6 @@ export { I3SContentLoader } from './i3s-content-loader';
 export { I3SAttributeLoader, loadFeatureAttributes } from './i3s-attribute-loader';
 export { I3SBuildingSceneLayerLoader } from './i3s-building-scene-layer-loader';
 export { ArcGisWebSceneLoader } from './arcgis-webscene-loader';
-export type { BoundingVolumes, Mbs, Obb, SceneLayer3D, AttributeStorageInfo, Field, ESRIField, PopupInfo, Node3DIndexDocument, LodSelection, NodeReference, Resource, MaxScreenThresholdSQ, NodeInPage, SharedResources, Attribute, Extent, FeatureAttribute, FieldInfo, I3SMaterialDefinition, TextureDefinitionInfo, MaterialDefinitionInfo, FullExtent } from './types';
+export type { BoundingVolumes, Mbs, Obb, SceneLayer3D, AttributeStorageInfo, Field, ESRIField, PopupInfo, Node3DIndexDocument, LodSelection, NodeReference, Resource, MaxScreenThresholdSQ, NodeInPage, SharedResources, Attribute, Extent, FeatureAttribute, FieldInfo, I3SMaterialDefinition, TextureDefinitionInfo, MaterialDefinitionInfo, FullExtent, StatisticsInfo, StatsInfo, Histogram, ValueCount, BuildingSceneSublayer, DATA_TYPE, OperationalLayer } from './types';
 export { COORDINATE_SYSTEM } from './lib/parsers/constants';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AACvC,OAAO,EAAC,gBAAgB,EAAC,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAC,kBAAkB,EAAE,qBAAqB,EAAC,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAC,2BAA2B,EAAC,MAAM,mCAAmC,CAAC;AAC9E,OAAO,EAAC,oBAAoB,EAAC,MAAM,0BAA0B,CAAC;AAC9D,YAAY,EACV,eAAe,EACf,GAAG,EACH,GAAG,EACH,YAAY,EACZ,oBAAoB,EACpB,KAAK,EACL,SAAS,EACT,SAAS,EACT,mBAAmB,EACnB,YAAY,EACZ,aAAa,EACb,QAAQ,EACR,oBAAoB,EACpB,UAAU,EACV,eAAe,EACf,SAAS,EACT,MAAM,EACN,gBAAgB,EAChB,SAAS,EACT,qBAAqB,EACrB,qBAAqB,EACrB,sBAAsB,EACtB,UAAU,EACX,MAAM,SAAS,CAAC;AACjB,OAAO,EAAC,iBAAiB,EAAC,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AACvC,OAAO,EAAC,gBAAgB,EAAC,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAC,kBAAkB,EAAE,qBAAqB,EAAC,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAC,2BAA2B,EAAC,MAAM,mCAAmC,CAAC;AAC9E,OAAO,EAAC,oBAAoB,EAAC,MAAM,0BAA0B,CAAC;AAC9D,YAAY,EACV,eAAe,EACf,GAAG,EACH,GAAG,EACH,YAAY,EACZ,oBAAoB,EACpB,KAAK,EACL,SAAS,EACT,SAAS,EACT,mBAAmB,EACnB,YAAY,EACZ,aAAa,EACb,QAAQ,EACR,oBAAoB,EACpB,UAAU,EACV,eAAe,EACf,SAAS,EACT,MAAM,EACN,gBAAgB,EAChB,SAAS,EACT,qBAAqB,EACrB,qBAAqB,EACrB,sBAAsB,EACtB,UAAU,EACV,cAAc,EACd,SAAS,EACT,SAAS,EACT,UAAU,EACV,qBAAqB,EACrB,SAAS,EACT,gBAAgB,EACjB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAC,iBAAiB,EAAC,MAAM,yBAAyB,CAAC"}

package/dist/lib/parsers/constants.js

@@ -25,7 +25,7 @@ function getConstructorForDataFormat(dataType) {
 exports.getConstructorForDataFormat = getConstructorForDataFormat;
 exports.GL_TYPE_MAP = {
     UInt8: constants_1.default.UNSIGNED_BYTE,
-    UInt16: constants_1.default.UNSIGNED_INT,
+    UInt16: constants_1.default.UNSIGNED_SHORT,
     Float32: constants_1.default.FLOAT,
     UInt32: constants_1.default.UNSIGNED_INT,
     UInt64: constants_1.default.DOUBLE

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

@@ -1 +1 @@
-{"version":3,"file":"parse-arcgis-webscene.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-arcgis-webscene.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,kBAAkB,EAAmB,MAAM,aAAa,CAAC;AAgBtE;;;GAGG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAQlF"}
+{"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"}

package/dist/lib/parsers/parse-arcgis-webscene.js

@@ -1,9 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseWebscene = void 0;
+const core_1 = require("@loaders.gl/core");
+/**
+ * WKID, or Well-Known ID, of the CRS. Specify either WKID or WKT of the CRS.
+ * Spec - https://github.com/Esri/i3s-spec/blob/master/docs/1.8/spatialReference.cmn.md
+ */
+const SUPPORTED_WKID = 4326;
 const ARCGIS_SCENE_SERVER_LAYER_TYPE = 'ArcGISSceneServiceLayer';
 const BUILDING_SCENE_LAYER = 'BuildingSceneLayer';
 const INTEGRATED_MESH_LAYER = 'IntegratedMeshLayer';
+const GROUP_LAYER = 'GroupLayer';
 /**
  * Supported layers list
  * Possible operational layers in WebScene: https://developers.arcgis.com/web-scene-specification/objects/operationalLayers/
@@ -11,8 +18,11 @@ const INTEGRATED_MESH_LAYER = 'IntegratedMeshLayer';
 const SUPPORTED_LAYERS_TYPES = [
     ARCGIS_SCENE_SERVER_LAYER_TYPE,
     INTEGRATED_MESH_LAYER,
-    BUILDING_SCENE_LAYER
+    BUILDING_SCENE_LAYER,
+    GROUP_LAYER
 ];
+const NO_AVAILABLE_SUPPORTED_LAYERS_ERROR = 'NO_AVAILABLE_SUPPORTED_LAYERS_ERROR';
+const NOT_SUPPORTED_CRS_ERROR = 'NOT_SUPPORTED_CRS_ERROR';
 /**
  * Parses ArcGIS WebScene
  * @param data
@@ -20,9 +30,14 @@ const SUPPORTED_LAYERS_TYPES = [
 async function parseWebscene(data) {
     const layer0 = JSON.parse(new TextDecoder().decode(data));
     const { operationalLayers } = layer0;
+    const { layers, unsupportedLayers } = await parseOperationalLayers(operationalLayers, true);
+    if (!layers.length) {
+        throw new Error(NO_AVAILABLE_SUPPORTED_LAYERS_ERROR);
+    }
     return {
         header: layer0,
-        layers: parseOperationalLayers(operationalLayers)
+        layers,
+        unsupportedLayers
     };
 }
 exports.parseWebscene = parseWebscene;
@@ -30,16 +45,43 @@ exports.parseWebscene = parseWebscene;
  * Recursively parses WebScene operational layers.
  * @param layersList
  */
-function parseOperationalLayers(layersList) {
-    let layers = [];
+async function parseOperationalLayers(layersList, needToCheckCRS) {
+    const layers = [];
+    let unsupportedLayers = [];
     for (let index = 0; index < layersList.length; index++) {
         const layer = layersList[index];
-        if (SUPPORTED_LAYERS_TYPES.includes(layer.layerType)) {
+        const isLayerSupported = SUPPORTED_LAYERS_TYPES.includes(layer.layerType);
+        if (isLayerSupported) {
+            if (needToCheckCRS && layer.layerType !== GROUP_LAYER) {
+                await checkSupportedIndexCRS(layer);
+                needToCheckCRS = false;
+            }
             layers.push(layer);
         }
+        else {
+            unsupportedLayers.push(layer);
+        }
         if (layer.layers?.length) {
-            layers = [...layers, ...parseOperationalLayers(layer.layers)];
+            const { layers: childLayers, unsupportedLayers: childUnsupportedLayers } = await parseOperationalLayers(layer.layers, needToCheckCRS);
+            layer.layers = childLayers;
+            unsupportedLayers = [...unsupportedLayers, ...childUnsupportedLayers];
+        }
+    }
+    return { layers, unsupportedLayers };
+}
+/**
+ * Check if layer has supported CRS
+ * @param layer
+ */
+async function checkSupportedIndexCRS(layer) {
+    try {
+        const layerJson = await (0, core_1.load)(layer.url, core_1.JSONLoader);
+        const wkid = layerJson?.spatialReference?.wkid;
+        if (wkid !== SUPPORTED_WKID) {
+            throw new Error(NOT_SUPPORTED_CRS_ERROR);
         }
     }
-    return layers;
+    catch (error) {
+        throw error;
+    }
 }

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"parse-i3s-tile-content.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-i3s-tile-content.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAK3E,OAAO,EACL,gBAAgB,EAChB,aAAa,EAQd,MAAM,aAAa,CAAC;AAuBrB,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,gBAAgB,EACzB,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,0BAkDxB"}
+{"version":3,"file":"parse-i3s-tile-content.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-i3s-tile-content.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAK3E,OAAO,EAQL,cAAc,EACd,cAAc,EACd,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAyBrB,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,WAAW,EACxB,WAAW,EAAE,cAAc,EAC3B,cAAc,EAAE,iBAAiB,EACjC,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,cAAc,CAAC,CAuDzB"}

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

@@ -10,6 +10,7 @@ const textures_1 = require("@loaders.gl/textures");
 const types_1 = require("../../types");
 const url_utils_1 = require("../utils/url-utils");
 const constants_1 = require("./constants");
+const customizeColors_1 = require("../utils/customizeColors");
 const scratchVector = new core_2.Vector3([0, 0, 0]);
 function getLoaderForTextureFormat(textureFormat) {
     switch (textureFormat) {
@@ -25,36 +26,43 @@ function getLoaderForTextureFormat(textureFormat) {
     }
 }
 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;
-    tile.content.attributes = {};
-    if (tile.textureUrl) {
-        const url = (0, url_utils_1.getUrlWithToken)(tile.textureUrl, options?.i3s?.token);
-        const loader = getLoaderForTextureFormat(tile.textureFormat);
+async function parseI3STileContent(arrayBuffer, tileOptions, tilesetOptions, options, context) {
+    const content = {
+        attributes: {},
+        indices: null,
+        featureIds: [],
+        vertexCount: 0,
+        modelMatrix: new core_2.Matrix4(),
+        coordinateSystem: 0,
+        byteLength: 0,
+        texture: null
+    };
+    if (tileOptions.textureUrl) {
+        const url = (0, url_utils_1.getUrlWithToken)(tileOptions.textureUrl, options?.i3s?.token);
+        const loader = getLoaderForTextureFormat(tileOptions.textureFormat);
         const response = await fetch(url, options?.fetch);
         const arrayBuffer = await response.arrayBuffer();
         if (options?.i3s.decodeTextures) {
             if (loader === images_1.ImageLoader) {
-                const options = { ...tile.textureLoaderOptions, image: { type: 'data' } };
+                const options = { ...tileOptions.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);
+                    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);
+                    content.texture = await (0, core_1.parse)(arrayBuffer, loader, options);
                 }
             }
             else if (loader === textures_1.CompressedTextureLoader || loader === textures_1.BasisLoader) {
-                let texture = await (0, core_1.load)(arrayBuffer, loader, tile.textureLoaderOptions);
+                let texture = await (0, core_1.load)(arrayBuffer, loader, tileOptions.textureLoaderOptions);
                 if (loader === textures_1.BasisLoader) {
                     texture = texture[0];
                 }
-                tile.content.texture = {
+                content.texture = {
                     compressed: true,
                     mipmaps: false,
                     width: texture[0].width,
@@ -64,29 +72,25 @@ async function parseI3STileContent(arrayBuffer, tile, tileset, options, context)
             }
         }
         else {
-            tile.content.texture = arrayBuffer;
+            content.texture = arrayBuffer;
         }
     }
-    tile.content.material = makePbrMaterial(tile.materialDefinition, tile.content.texture);
-    if (tile.content.material) {
-        tile.content.texture = null;
+    content.material = makePbrMaterial(tileOptions.materialDefinition, content.texture);
+    if (content.material) {
+        content.texture = null;
     }
-    return await parseI3SNodeGeometry(arrayBuffer, tile, tileset, options);
+    return await parseI3SNodeGeometry(arrayBuffer, content, tileOptions, tilesetOptions, options);
 }
 exports.parseI3STileContent = parseI3STileContent;
 /* eslint-disable max-statements */
-async function parseI3SNodeGeometry(arrayBuffer, tile, tileset, options) {
-    if (!tile.content) {
-        return tile;
-    }
-    const content = tile.content;
+async function parseI3SNodeGeometry(arrayBuffer, content, tileOptions, tilesetOptions, options) {
     const contentByteLength = arrayBuffer.byteLength;
     let attributes;
     let vertexCount;
     let byteOffset = 0;
     let featureCount = 0;
     let indices;
-    if (tile.isDracoGeometry) {
+    if (tileOptions.isDracoGeometry) {
         const decompressedGeometry = await (0, core_1.parse)(arrayBuffer, draco_1.DracoLoader, {
             draco: {
                 attributeNameEntry: I3S_ATTRIBUTE_TYPE
@@ -111,9 +115,9 @@ async function parseI3SNodeGeometry(arrayBuffer, tile, tileset, options) {
         }
     }
     else {
-        const { vertexAttributes, ordering: attributesOrder, featureAttributes, featureAttributeOrder } = tileset.store.defaultGeometrySchema;
+        const { vertexAttributes, ordering: attributesOrder, featureAttributes, featureAttributeOrder } = tilesetOptions.store.defaultGeometrySchema;
         // First 8 bytes reserved for header (vertexCount and featureCount)
-        const headers = parseHeaders(tileset, arrayBuffer);
+        const headers = parseHeaders(arrayBuffer, tilesetOptions);
         byteOffset = headers.byteOffset;
         vertexCount = headers.vertexCount;
         featureCount = headers.featureCount;
@@ -126,7 +130,7 @@ async function parseI3SNodeGeometry(arrayBuffer, tile, tileset, options) {
     }
     if (!options?.i3s?.coordinateSystem ||
         options.i3s.coordinateSystem === constants_1.COORDINATE_SYSTEM.METER_OFFSETS) {
-        const enuMatrix = parsePositions(attributes.position, tile);
+        const enuMatrix = parsePositions(attributes.position, tileOptions);
         content.modelMatrix = enuMatrix.invert();
         content.coordinateSystem = constants_1.COORDINATE_SYSTEM.METER_OFFSETS;
     }
@@ -134,16 +138,17 @@ async function parseI3SNodeGeometry(arrayBuffer, tile, tileset, options) {
         content.modelMatrix = getModelMatrix(attributes.position);
         content.coordinateSystem = constants_1.COORDINATE_SYSTEM.LNGLAT_OFFSETS;
     }
+    attributes.color = await (0, customizeColors_1.customizeColors)(attributes.color, attributes.id, tileOptions, tilesetOptions, options);
     content.attributes = {
         positions: attributes.position,
         normals: attributes.normal,
         colors: normalizeAttribute(attributes.color),
         texCoords: attributes.uv0,
-        uvRegions: normalizeAttribute(attributes.uvRegion) // Normalize from UInt16
+        uvRegions: normalizeAttribute(attributes.uvRegion || attributes.region) // Normalize from UInt16
     };
     content.indices = indices || null;
     if (attributes.id && attributes.id.value) {
-        tile.content.featureIds = attributes.id.value;
+        content.featureIds = attributes.id.value;
     }
     // Remove undefined attributes
     for (const attributeIndex in content.attributes) {
@@ -153,7 +158,7 @@ async function parseI3SNodeGeometry(arrayBuffer, tile, tileset, options) {
     }
     content.vertexCount = vertexCount;
     content.byteLength = contentByteLength;
-    return tile;
+    return content;
 }
 /**
  * Update attributes with metadata from decompressed geometry.
@@ -197,12 +202,12 @@ function normalizeAttribute(attribute) {
     attribute.normalized = true;
     return attribute;
 }
-function parseHeaders(tileset, arrayBuffer) {
+function parseHeaders(arrayBuffer, options) {
     let byteOffset = 0;
     // First 8 bytes reserved for header (vertexCount and featurecount)
     let vertexCount = 0;
     let featureCount = 0;
-    for (const { property, type } of tileset.store.defaultGeometrySchema.header) {
+    for (const { property, type } of options.store.defaultGeometrySchema.header) {
         const TypedArrayTypeHeader = (0, constants_1.getConstructorForDataFormat)(type);
         switch (property) {
             case types_1.HeaderAttributeProperty.vertexCount:
@@ -292,8 +297,8 @@ function parseUint64Values(buffer, elementsCount, attributeSize) {
     }
     return new Uint32Array(values);
 }
-function parsePositions(attribute, tile) {
-    const mbs = tile.mbs;
+function parsePositions(attribute, options) {
+    const mbs = options.mbs;
     const value = attribute.value;
     const metadata = attribute.metadata;
     const enuMatrix = new core_2.Matrix4();

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

@@ -1,6 +1,6 @@
 import { I3STilesetHeader, I3STileHeader, I3SMinimalNodeData, Node3DIndexDocument } from '../../types';
 import type { LoaderOptions, LoaderContext } from '@loaders.gl/loader-utils';
-export declare function normalizeTileData(tile: Node3DIndexDocument, options: LoaderOptions, context: LoaderContext): I3STileHeader;
+export declare function normalizeTileData(tile: Node3DIndexDocument, context: LoaderContext): I3STileHeader;
 export declare function normalizeTileNonUrlData(tile: I3SMinimalNodeData): I3STileHeader;
 export declare function normalizeTilesetData(tileset: I3STilesetHeader, options: LoaderOptions, context: LoaderContext): Promise<void>;
 //# sourceMappingURL=parse-i3s.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"parse-i3s.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-i3s.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,gBAAgB,EAChB,aAAa,EAEb,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAE3E,wBAAgB,iBAAiB,CAAC,IAAI,EAAG,mBAAmB,EAAE,OAAO,EAAG,aAAa,EAAE,OAAO,EAAE,aAAa,GAAG,aAAa,CAyB5H;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAG,kBAAkB,GAAG,aAAa,CAmChF;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAG,gBAAgB,EAAE,OAAO,EAAG,aAAa,EAAE,OAAO,EAAE,aAAa,iBAwBrH"}
+{"version":3,"file":"parse-i3s.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-i3s.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,gBAAgB,EAChB,aAAa,EAEb,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAE3E,wBAAgB,iBAAiB,CAAC,IAAI,EAAG,mBAAmB,EAAE,OAAO,EAAE,aAAa,GAAG,aAAa,CAyBnG;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAG,kBAAkB,GAAG,aAAa,CAmChF;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAG,gBAAgB,EAAE,OAAO,EAAG,aAAa,EAAE,OAAO,EAAE,aAAa,iBAwBrH"}

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

@@ -10,7 +10,7 @@ const core_1 = require("@loaders.gl/core");
 const tiles_1 = require("@loaders.gl/tiles");
 const i3s_nodepages_tiles_1 = __importDefault(require("../helpers/i3s-nodepages-tiles"));
 const url_utils_1 = require("../utils/url-utils");
-function normalizeTileData(tile, options, context) {
+function normalizeTileData(tile, context) {
     const url = context.url || '';
     let contentUrl;
     if (tile.geometryData) {

package/dist/lib/utils/customizeColors.d.ts

@@ -0,0 +1,14 @@
+import type { MeshAttribute } from '@loaders.gl/schema';
+import type { I3STileOptions, I3STilesetOptions } from '../../types';
+import { I3SLoaderOptions } from '../../i3s-loader';
+/**
+ * Modify vertex colors array to visualize 3D objects in a attribute driven way
+ * @param colors - vertex colors attribute
+ * @param featureIds - feature Ids attribute
+ * @param tileOptions - tile - related options
+ * @param tilesetOptions - tileset-related options
+ * @param options - loader options
+ * @returns midified colors attribute
+ */
+export declare function customizeColors(colors: MeshAttribute, featureIds: MeshAttribute, tileOptions: I3STileOptions, tilesetOptions: I3STilesetOptions, options?: I3SLoaderOptions): Promise<MeshAttribute>;
+//# sourceMappingURL=customizeColors.d.ts.map

package/dist/lib/utils/customizeColors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customizeColors.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/customizeColors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAQ,cAAc,EAAE,iBAAiB,EAAC,MAAM,aAAa,CAAC;AAI1E,OAAO,EAAC,gBAAgB,EAAC,MAAM,kBAAkB,CAAC;AAGlD;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,aAAa,EACzB,WAAW,EAAE,cAAc,EAC3B,cAAc,EAAE,iBAAiB,EACjC,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,aAAa,CAAC,CA2DxB"}

package/dist/lib/utils/customizeColors.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customizeColors = void 0;
+const core_1 = require("@loaders.gl/core");
+const i3s_attribute_loader_1 = require("../../i3s-attribute-loader");
+const url_utils_1 = require("../utils/url-utils");
+/**
+ * Modify vertex colors array to visualize 3D objects in a attribute driven way
+ * @param colors - vertex colors attribute
+ * @param featureIds - feature Ids attribute
+ * @param tileOptions - tile - related options
+ * @param tilesetOptions - tileset-related options
+ * @param options - loader options
+ * @returns midified colors attribute
+ */
+async function customizeColors(colors, featureIds, tileOptions, tilesetOptions, options) {
+    if (!options?.i3s?.colorsByAttribute) {
+        return colors;
+    }
+    const colorizeAttributeField = tilesetOptions.fields.find(({ name }) => name === options?.i3s?.colorsByAttribute?.attributeName);
+    if (!colorizeAttributeField ||
+        !['esriFieldTypeDouble', 'esriFieldTypeInteger', 'esriFieldTypeSmallInteger'].includes(colorizeAttributeField.type)) {
+        return colors;
+    }
+    const colorizeAttributeData = await loadFeatureAttributeData(colorizeAttributeField.name, tileOptions, tilesetOptions, options);
+    if (!colorizeAttributeData) {
+        return colors;
+    }
+    const objectIdField = tilesetOptions.fields.find(({ type }) => type === 'esriFieldTypeOID');
+    if (!objectIdField) {
+        return colors;
+    }
+    const objectIdAttributeData = await loadFeatureAttributeData(objectIdField.name, tileOptions, tilesetOptions, options);
+    if (!objectIdAttributeData) {
+        return colors;
+    }
+    const attributeValuesMap = {};
+    for (let i = 0; i < objectIdAttributeData[objectIdField.name].length; i++) {
+        attributeValuesMap[objectIdAttributeData[objectIdField.name][i]] = calculateColorForAttribute(colorizeAttributeData[colorizeAttributeField.name][i], options);
+    }
+    for (let i = 0; i < featureIds.value.length; i++) {
+        const color = attributeValuesMap[featureIds.value[i]];
+        if (!color) {
+            continue; // eslint-disable-line no-continue
+        }
+        colors.value.set(color, i * 4);
+    }
+    return colors;
+}
+exports.customizeColors = customizeColors;
+/**
+ * Calculate rgba color from the attribute value
+ * @param attributeValue - value of the attribute
+ * @param options - loader options
+ * @returns - color array for a specific attribute value
+ */
+function calculateColorForAttribute(attributeValue, options) {
+    if (!options?.i3s?.colorsByAttribute) {
+        return [255, 255, 255, 255];
+    }
+    const { minValue, maxValue, minColor, maxColor } = options.i3s.colorsByAttribute;
+    const rate = (attributeValue - minValue) / (maxValue - minValue);
+    const color = [255, 255, 255, 255];
+    for (let i = 0; i < minColor.length; i++) {
+        color[i] = Math.round((maxColor[i] - minColor[i]) * rate + minColor[i]);
+    }
+    return color;
+}
+/**
+ * Load feature attribute data from the ArcGIS rest service
+ * @param attributeName - attribute name
+ * @param tileOptions - tile-related options
+ * @param tilesetOptions - tileset-related options
+ * @param options - loader options
+ * @returns - Array-like list of the attribute values
+ */
+async function loadFeatureAttributeData(attributeName, { attributeUrls }, { attributeStorageInfo }, options) {
+    const attributeIndex = attributeStorageInfo.findIndex(({ name }) => attributeName === name);
+    if (attributeIndex === -1) {
+        return null;
+    }
+    const objectIdAttributeUrl = (0, url_utils_1.getUrlWithToken)(attributeUrls[attributeIndex], options?.i3s?.token);
+    const attributeType = (0, i3s_attribute_loader_1.getAttributeValueType)(attributeStorageInfo[attributeIndex]);
+    const objectIdAttributeData = await (0, core_1.load)(objectIdAttributeUrl, i3s_attribute_loader_1.I3SAttributeLoader, {
+        attributeName,
+        attributeType
+    });
+    return objectIdAttributeData;
+}