@loaders.gl/3d-tiles 3.3.0-alpha.5 → 3.3.0-alpha.7

package/dist/esm/lib/encoders/encode-3d-tile-composite.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/encoders/encode-3d-tile-composite.ts"],"names":["MAGIC_ARRAY","encode3DTileHeader","encode3DTileByteLength","encodeComposite3DTile","tile","dataView","byteOffset","options","encode3DTile","magic","COMPOSITE","tiles","byteOffsetStart","setUint32","length","i"],"mappings":"AAGA,SAAQA,WAAR,QAA0B,cAA1B;AACA,SAAQC,kBAAR,EAA4BC,sBAA5B,QAAyD,iCAAzD;AAEA,OAAO,SAASC,qBAAT,CAA+BC,IAA/B,EAAqCC,QAArC,EAA+CC,UAA/C,EAA2DC,OAA3D,EAAoEC,YAApE,EAAkF;AAEvFJ,EAAAA,IAAI,GAAG;AAACK,IAAAA,KAAK,EAAET,WAAW,CAACU,SAApB;AAA+BC,IAAAA,KAAK,EAAE,EAAtC;AAA0C,OAAGP;AAA7C,GAAP;AAEA,QAAMQ,eAAe,GAAGN,UAAxB;AAEAA,EAAAA,UAAU,IAAIL,kBAAkB,CAACG,IAAD,EAAOC,QAAP,EAAiBC,UAAjB,CAAhC;;AAEA,MAAID,QAAJ,EAAc;AACZA,IAAAA,QAAQ,CAACQ,SAAT,CAAmBP,UAAnB,EAA+BF,IAAI,CAACO,KAAL,CAAWG,MAA1C,EAAkD,IAAlD;AACD;;AACDR,EAAAA,UAAU,IAAI,CAAd;;AAEA,OAAK,IAAIS,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGX,IAAI,CAACO,KAAL,CAAWG,MAA/B,EAAuC,EAAEC,CAAzC,EAA4C;AAC1CT,IAAAA,UAAU,IAAIE,YAAY,CAACJ,IAAI,CAACO,KAAL,CAAWI,CAAX,CAAD,EAAgBV,QAAhB,EAA0BC,UAA1B,EAAsCC,OAAtC,CAA1B;AACD;;AAGDL,EAAAA,sBAAsB,CAACG,QAAD,EAAWO,eAAX,EAA4BN,UAAU,GAAGM,eAAzC,CAAtB;AAEA,SAAON,UAAP;AACD","sourcesContent":["// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport {MAGIC_ARRAY} from '../constants';\nimport {encode3DTileHeader, encode3DTileByteLength} from './helpers/encode-3d-tile-header';\n\nexport function encodeComposite3DTile(tile, dataView, byteOffset, options, encode3DTile) {\n  // Add default magic for this tile type\n  tile = {magic: MAGIC_ARRAY.COMPOSITE, tiles: [], ...tile};\n\n  const byteOffsetStart = byteOffset;\n\n  byteOffset += encode3DTileHeader(tile, dataView, byteOffset);\n\n  if (dataView) {\n    dataView.setUint32(byteOffset, tile.tiles.length, true); // tilesLength\n  }\n  byteOffset += 4;\n\n  for (let i = 0; i < tile.tiles.length; ++i) {\n    byteOffset += encode3DTile(tile.tiles[i], dataView, byteOffset, options);\n  }\n\n  // Go \"back\" and rewrite the tile's `byteLength` now that we know the value\n  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);\n\n  return byteOffset;\n}\n"],"file":"encode-3d-tile-composite.js"}
+{"version":3,"file":"encode-3d-tile-composite.js","names":["MAGIC_ARRAY","encode3DTileHeader","encode3DTileByteLength","encodeComposite3DTile","tile","dataView","byteOffset","options","encode3DTile","magic","COMPOSITE","tiles","byteOffsetStart","setUint32","length","i"],"sources":["../../../../src/lib/encoders/encode-3d-tile-composite.ts"],"sourcesContent":["// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport {MAGIC_ARRAY} from '../constants';\nimport {encode3DTileHeader, encode3DTileByteLength} from './helpers/encode-3d-tile-header';\n\nexport function encodeComposite3DTile(tile, dataView, byteOffset, options, encode3DTile) {\n  // Add default magic for this tile type\n  tile = {magic: MAGIC_ARRAY.COMPOSITE, tiles: [], ...tile};\n\n  const byteOffsetStart = byteOffset;\n\n  byteOffset += encode3DTileHeader(tile, dataView, byteOffset);\n\n  if (dataView) {\n    dataView.setUint32(byteOffset, tile.tiles.length, true); // tilesLength\n  }\n  byteOffset += 4;\n\n  for (let i = 0; i < tile.tiles.length; ++i) {\n    byteOffset += encode3DTile(tile.tiles[i], dataView, byteOffset, options);\n  }\n\n  // Go \"back\" and rewrite the tile's `byteLength` now that we know the value\n  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);\n\n  return byteOffset;\n}\n"],"mappings":";;AAGA,SAAQA,WAAW,QAAO,cAAc;AACxC,SAAQC,kBAAkB,EAAEC,sBAAsB,QAAO,iCAAiC;AAE1F,OAAO,SAASC,qBAAqB,CAACC,IAAI,EAAEC,QAAQ,EAAEC,UAAU,EAAEC,OAAO,EAAEC,YAAY,EAAE;EAEvFJ,IAAI,GAAG;IAACK,KAAK,EAAET,WAAW,CAACU,SAAS;IAAEC,KAAK,EAAE,EAAE;IAAE,GAAGP;EAAI,CAAC;EAEzD,MAAMQ,eAAe,GAAGN,UAAU;EAElCA,UAAU,IAAIL,kBAAkB,CAACG,IAAI,EAAEC,QAAQ,EAAEC,UAAU,CAAC;EAE5D,IAAID,QAAQ,EAAE;IACZA,QAAQ,CAACQ,SAAS,CAACP,UAAU,EAAEF,IAAI,CAACO,KAAK,CAACG,MAAM,EAAE,IAAI,CAAC;EACzD;;EACAR,UAAU,IAAI,CAAC;EAEf,KAAK,IAAIS,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGX,IAAI,CAACO,KAAK,CAACG,MAAM,EAAE,EAAEC,CAAC,EAAE;IAC1CT,UAAU,IAAIE,YAAY,CAACJ,IAAI,CAACO,KAAK,CAACI,CAAC,CAAC,EAAEV,QAAQ,EAAEC,UAAU,EAAEC,OAAO,CAAC;EAC1E;;EAGAL,sBAAsB,CAACG,QAAQ,EAAEO,eAAe,EAAEN,UAAU,GAAGM,eAAe,CAAC;EAE/E,OAAON,UAAU;AACnB"}

package/dist/esm/lib/encoders/encode-3d-tile-instanced-model.js

@@ -1,6 +1,9 @@
+
+
 import { copyStringToDataView } from '@loaders.gl/loader-utils';
 import { MAGIC_ARRAY } from '../constants';
 import { encode3DTileHeader, encode3DTileByteLength } from './helpers/encode-3d-tile-header';
+
 export function encodeInstancedModel3DTile(tile, dataView, byteOffset, options) {
   const {
     featuresLength = 1,
@@ -14,13 +17,13 @@ export function encodeInstancedModel3DTile(tile, dataView, byteOffset, options)
   };
   const featureTableJsonString = JSON.stringify(featureTableJson);
   const featureTableJsonByteLength = featureTableJsonString.length;
+
   tile = {
     magic: MAGIC_ARRAY.INSTANCED_MODEL,
     ...tile
   };
   const byteOffsetStart = byteOffset;
   byteOffset = encode3DTileHeader(tile, dataView, 0);
-
   if (dataView) {
     dataView.setUint32(12, featureTableJsonByteLength, true);
     dataView.setUint32(16, 0, true);
@@ -32,6 +35,7 @@ export function encodeInstancedModel3DTile(tile, dataView, byteOffset, options)
   byteOffset += 20;
   byteOffset += copyStringToDataView(dataView, byteOffset, featureTableJsonString, featureTableJsonByteLength);
   byteOffset += copyStringToDataView(dataView, byteOffset, gltfUri, gltfUriByteLength);
+
   encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
   return byteOffset;
 }

package/dist/esm/lib/encoders/encode-3d-tile-instanced-model.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/encoders/encode-3d-tile-instanced-model.ts"],"names":["copyStringToDataView","MAGIC_ARRAY","encode3DTileHeader","encode3DTileByteLength","encodeInstancedModel3DTile","tile","dataView","byteOffset","options","featuresLength","gltfFormat","gltfUri","gltfUriByteLength","length","featureTableJson","INSTANCES_LENGTH","POSITION","Array","fill","featureTableJsonString","JSON","stringify","featureTableJsonByteLength","magic","INSTANCED_MODEL","byteOffsetStart","setUint32"],"mappings":"AAGA,SAAQA,oBAAR,QAAmC,0BAAnC;AACA,SAAQC,WAAR,QAA0B,cAA1B;AACA,SAAQC,kBAAR,EAA4BC,sBAA5B,QAAyD,iCAAzD;AAIA,OAAO,SAASC,0BAAT,CAAoCC,IAApC,EAA0CC,QAA1C,EAAoDC,UAApD,EAAgEC,OAAhE,EAAyE;AAC9E,QAAM;AAACC,IAAAA,cAAc,GAAG,CAAlB;AAAqBC,IAAAA,UAAU,GAAG,CAAlC;AAAqCC,IAAAA,OAAO,GAAG;AAA/C,MAAqDN,IAA3D;AAEA,QAAMO,iBAAiB,GAAGD,OAAO,CAACE,MAAlC;AAEA,QAAMC,gBAAgB,GAAG;AACvBC,IAAAA,gBAAgB,EAAEN,cADK;AAEvBO,IAAAA,QAAQ,EAAE,IAAIC,KAAJ,CAAUR,cAAc,GAAG,CAA3B,EAA8BS,IAA9B,CAAmC,CAAnC;AAFa,GAAzB;AAIA,QAAMC,sBAAsB,GAAGC,IAAI,CAACC,SAAL,CAAeP,gBAAf,CAA/B;AACA,QAAMQ,0BAA0B,GAAGH,sBAAsB,CAACN,MAA1D;AAGAR,EAAAA,IAAI,GAAG;AAACkB,IAAAA,KAAK,EAAEtB,WAAW,CAACuB,eAApB;AAAqC,OAAGnB;AAAxC,GAAP;AAEA,QAAMoB,eAAe,GAAGlB,UAAxB;AAEAA,EAAAA,UAAU,GAAGL,kBAAkB,CAACG,IAAD,EAAOC,QAAP,EAAiB,CAAjB,CAA/B;;AAEA,MAAIA,QAAJ,EAAc;AACZA,IAAAA,QAAQ,CAACoB,SAAT,CAAmB,EAAnB,EAAuBJ,0BAAvB,EAAmD,IAAnD;AACAhB,IAAAA,QAAQ,CAACoB,SAAT,CAAmB,EAAnB,EAAuB,CAAvB,EAA0B,IAA1B;AACApB,IAAAA,QAAQ,CAACoB,SAAT,CAAmB,EAAnB,EAAuB,CAAvB,EAA0B,IAA1B;AACApB,IAAAA,QAAQ,CAACoB,SAAT,CAAmB,EAAnB,EAAuB,CAAvB,EAA0B,IAA1B;AACApB,IAAAA,QAAQ,CAACoB,SAAT,CAAmB,EAAnB,EAAuBhB,UAAvB,EAAmC,IAAnC;AACD;;AAEDH,EAAAA,UAAU,IAAI,EAAd;AAEAA,EAAAA,UAAU,IAAIP,oBAAoB,CAChCM,QADgC,EAEhCC,UAFgC,EAGhCY,sBAHgC,EAIhCG,0BAJgC,CAAlC;AAMAf,EAAAA,UAAU,IAAIP,oBAAoB,CAACM,QAAD,EAAWC,UAAX,EAAuBI,OAAvB,EAAgCC,iBAAhC,CAAlC;AAGAT,EAAAA,sBAAsB,CAACG,QAAD,EAAWmB,eAAX,EAA4BlB,UAAU,GAAGkB,eAAzC,CAAtB;AAEA,SAAOlB,UAAP;AACD","sourcesContent":["// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport {copyStringToDataView} from '@loaders.gl/loader-utils';\nimport {MAGIC_ARRAY} from '../constants';\nimport {encode3DTileHeader, encode3DTileByteLength} from './helpers/encode-3d-tile-header';\n\n// Procedurally encode the tile array buffer for testing purposes\n// eslint-disable-next-line max-statements\nexport function encodeInstancedModel3DTile(tile, dataView, byteOffset, options) {\n  const {featuresLength = 1, gltfFormat = 1, gltfUri = ''} = tile;\n\n  const gltfUriByteLength = gltfUri.length;\n\n  const featureTableJson = {\n    INSTANCES_LENGTH: featuresLength,\n    POSITION: new Array(featuresLength * 3).fill(0)\n  };\n  const featureTableJsonString = JSON.stringify(featureTableJson);\n  const featureTableJsonByteLength = featureTableJsonString.length;\n\n  // Add default magic for this tile type\n  tile = {magic: MAGIC_ARRAY.INSTANCED_MODEL, ...tile};\n\n  const byteOffsetStart = byteOffset;\n\n  byteOffset = encode3DTileHeader(tile, dataView, 0);\n\n  if (dataView) {\n    dataView.setUint32(12, featureTableJsonByteLength, true); // featureTableJsonByteLength\n    dataView.setUint32(16, 0, true); // featureTableBinaryByteLength\n    dataView.setUint32(20, 0, true); // batchTableJsonByteLength\n    dataView.setUint32(24, 0, true); // batchTableBinaryByteLength\n    dataView.setUint32(28, gltfFormat, true); // gltfFormat\n  }\n\n  byteOffset += 20;\n\n  byteOffset += copyStringToDataView(\n    dataView,\n    byteOffset,\n    featureTableJsonString,\n    featureTableJsonByteLength\n  );\n  byteOffset += copyStringToDataView(dataView, byteOffset, gltfUri, gltfUriByteLength);\n\n  // Go \"back\" and rewrite the tile's `byteLength` now that we know the value\n  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);\n\n  return byteOffset;\n}\n"],"file":"encode-3d-tile-instanced-model.js"}
+{"version":3,"file":"encode-3d-tile-instanced-model.js","names":["copyStringToDataView","MAGIC_ARRAY","encode3DTileHeader","encode3DTileByteLength","encodeInstancedModel3DTile","tile","dataView","byteOffset","options","featuresLength","gltfFormat","gltfUri","gltfUriByteLength","length","featureTableJson","INSTANCES_LENGTH","POSITION","Array","fill","featureTableJsonString","JSON","stringify","featureTableJsonByteLength","magic","INSTANCED_MODEL","byteOffsetStart","setUint32"],"sources":["../../../../src/lib/encoders/encode-3d-tile-instanced-model.ts"],"sourcesContent":["// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport {copyStringToDataView} from '@loaders.gl/loader-utils';\nimport {MAGIC_ARRAY} from '../constants';\nimport {encode3DTileHeader, encode3DTileByteLength} from './helpers/encode-3d-tile-header';\n\n// Procedurally encode the tile array buffer for testing purposes\n// eslint-disable-next-line max-statements\nexport function encodeInstancedModel3DTile(tile, dataView, byteOffset, options) {\n  const {featuresLength = 1, gltfFormat = 1, gltfUri = ''} = tile;\n\n  const gltfUriByteLength = gltfUri.length;\n\n  const featureTableJson = {\n    INSTANCES_LENGTH: featuresLength,\n    POSITION: new Array(featuresLength * 3).fill(0)\n  };\n  const featureTableJsonString = JSON.stringify(featureTableJson);\n  const featureTableJsonByteLength = featureTableJsonString.length;\n\n  // Add default magic for this tile type\n  tile = {magic: MAGIC_ARRAY.INSTANCED_MODEL, ...tile};\n\n  const byteOffsetStart = byteOffset;\n\n  byteOffset = encode3DTileHeader(tile, dataView, 0);\n\n  if (dataView) {\n    dataView.setUint32(12, featureTableJsonByteLength, true); // featureTableJsonByteLength\n    dataView.setUint32(16, 0, true); // featureTableBinaryByteLength\n    dataView.setUint32(20, 0, true); // batchTableJsonByteLength\n    dataView.setUint32(24, 0, true); // batchTableBinaryByteLength\n    dataView.setUint32(28, gltfFormat, true); // gltfFormat\n  }\n\n  byteOffset += 20;\n\n  byteOffset += copyStringToDataView(\n    dataView,\n    byteOffset,\n    featureTableJsonString,\n    featureTableJsonByteLength\n  );\n  byteOffset += copyStringToDataView(dataView, byteOffset, gltfUri, gltfUriByteLength);\n\n  // Go \"back\" and rewrite the tile's `byteLength` now that we know the value\n  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);\n\n  return byteOffset;\n}\n"],"mappings":";;AAGA,SAAQA,oBAAoB,QAAO,0BAA0B;AAC7D,SAAQC,WAAW,QAAO,cAAc;AACxC,SAAQC,kBAAkB,EAAEC,sBAAsB,QAAO,iCAAiC;;AAI1F,OAAO,SAASC,0BAA0B,CAACC,IAAI,EAAEC,QAAQ,EAAEC,UAAU,EAAEC,OAAO,EAAE;EAC9E,MAAM;IAACC,cAAc,GAAG,CAAC;IAAEC,UAAU,GAAG,CAAC;IAAEC,OAAO,GAAG;EAAE,CAAC,GAAGN,IAAI;EAE/D,MAAMO,iBAAiB,GAAGD,OAAO,CAACE,MAAM;EAExC,MAAMC,gBAAgB,GAAG;IACvBC,gBAAgB,EAAEN,cAAc;IAChCO,QAAQ,EAAE,IAAIC,KAAK,CAACR,cAAc,GAAG,CAAC,CAAC,CAACS,IAAI,CAAC,CAAC;EAChD,CAAC;EACD,MAAMC,sBAAsB,GAAGC,IAAI,CAACC,SAAS,CAACP,gBAAgB,CAAC;EAC/D,MAAMQ,0BAA0B,GAAGH,sBAAsB,CAACN,MAAM;;EAGhER,IAAI,GAAG;IAACkB,KAAK,EAAEtB,WAAW,CAACuB,eAAe;IAAE,GAAGnB;EAAI,CAAC;EAEpD,MAAMoB,eAAe,GAAGlB,UAAU;EAElCA,UAAU,GAAGL,kBAAkB,CAACG,IAAI,EAAEC,QAAQ,EAAE,CAAC,CAAC;EAElD,IAAIA,QAAQ,EAAE;IACZA,QAAQ,CAACoB,SAAS,CAAC,EAAE,EAAEJ,0BAA0B,EAAE,IAAI,CAAC;IACxDhB,QAAQ,CAACoB,SAAS,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,CAAC;IAC/BpB,QAAQ,CAACoB,SAAS,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,CAAC;IAC/BpB,QAAQ,CAACoB,SAAS,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,CAAC;IAC/BpB,QAAQ,CAACoB,SAAS,CAAC,EAAE,EAAEhB,UAAU,EAAE,IAAI,CAAC;EAC1C;;EAEAH,UAAU,IAAI,EAAE;EAEhBA,UAAU,IAAIP,oBAAoB,CAChCM,QAAQ,EACRC,UAAU,EACVY,sBAAsB,EACtBG,0BAA0B,CAC3B;EACDf,UAAU,IAAIP,oBAAoB,CAACM,QAAQ,EAAEC,UAAU,EAAEI,OAAO,EAAEC,iBAAiB,CAAC;;EAGpFT,sBAAsB,CAACG,QAAQ,EAAEmB,eAAe,EAAElB,UAAU,GAAGkB,eAAe,CAAC;EAE/E,OAAOlB,UAAU;AACnB"}

package/dist/esm/lib/encoders/encode-3d-tile-point-cloud.js

@@ -1,3 +1,5 @@
+
+
 import { MAGIC_ARRAY } from '../constants';
 import { encode3DTileHeader, encode3DTileByteLength } from './helpers/encode-3d-tile-header';
 import { padStringToByteAlignment, copyStringToDataView, copyBinaryToDataView } from '@loaders.gl/loader-utils';
@@ -18,13 +20,13 @@ export function encodePointCloud3DTile(tile, dataView, byteOffset, options) {
   } = tile;
   const featureTableBinary = new ArrayBuffer(12);
   const featureTableBinaryByteLength = featureTableBinary.byteLength;
+
   tile = {
     magic: MAGIC_ARRAY.POINT_CLOUD,
     ...tile
   };
   const byteOffsetStart = byteOffset;
   byteOffset += encode3DTileHeader(tile, dataView, 0);
-
   if (dataView) {
     dataView.setUint32(byteOffset + 0, featureTableJsonByteLength, true);
     dataView.setUint32(byteOffset + 4, featureTableBinaryByteLength, true);
@@ -35,6 +37,7 @@ export function encodePointCloud3DTile(tile, dataView, byteOffset, options) {
   byteOffset += 16;
   byteOffset += copyStringToDataView(dataView, byteOffset, featureTableJsonString, featureTableJsonByteLength);
   byteOffset += copyBinaryToDataView(dataView, byteOffset, featureTableBinary, featureTableBinaryByteLength);
+
   encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
   return byteOffset;
 }

package/dist/esm/lib/encoders/encode-3d-tile-point-cloud.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/encoders/encode-3d-tile-point-cloud.ts"],"names":["MAGIC_ARRAY","encode3DTileHeader","encode3DTileByteLength","padStringToByteAlignment","copyStringToDataView","copyBinaryToDataView","DEFAULT_FEATURE_TABLE_JSON","POINTS_LENGTH","POSITIONS","byteOffset","encodePointCloud3DTile","tile","dataView","options","featureTableJson","featureTableJsonString","JSON","stringify","featureTableJsonByteLength","length","featureTableBinary","ArrayBuffer","featureTableBinaryByteLength","byteLength","magic","POINT_CLOUD","byteOffsetStart","setUint32"],"mappings":"AAGA,SAAQA,WAAR,QAA0B,cAA1B;AACA,SAAQC,kBAAR,EAA4BC,sBAA5B,QAAyD,iCAAzD;AACA,SACEC,wBADF,EAEEC,oBAFF,EAGEC,oBAHF,QAIO,0BAJP;AAMA,MAAMC,0BAA0B,GAAG;AACjCC,EAAAA,aAAa,EAAE,CADkB;AAEjCC,EAAAA,SAAS,EAAE;AACTC,IAAAA,UAAU,EAAE;AADH;AAFsB,CAAnC;AAOA,OAAO,SAASC,sBAAT,CAAgCC,IAAhC,EAAsCC,QAAtC,EAAgDH,UAAhD,EAA4DI,OAA5D,EAAqE;AAC1E,QAAM;AAACC,IAAAA,gBAAgB,GAAGR;AAApB,MAAkDK,IAAxD;AAEA,MAAII,sBAAsB,GAAGC,IAAI,CAACC,SAAL,CAAeH,gBAAf,CAA7B;AACAC,EAAAA,sBAAsB,GAAGZ,wBAAwB,CAACY,sBAAD,EAAyB,CAAzB,CAAjD;AAEA,QAAM;AAACG,IAAAA,0BAA0B,GAAGH,sBAAsB,CAACI;AAArD,MAA+DR,IAArE;AAEA,QAAMS,kBAAkB,GAAG,IAAIC,WAAJ,CAAgB,EAAhB,CAA3B;AACA,QAAMC,4BAA4B,GAAGF,kBAAkB,CAACG,UAAxD;AAGAZ,EAAAA,IAAI,GAAG;AAACa,IAAAA,KAAK,EAAExB,WAAW,CAACyB,WAApB;AAAiC,OAAGd;AAApC,GAAP;AAEA,QAAMe,eAAe,GAAGjB,UAAxB;AAEAA,EAAAA,UAAU,IAAIR,kBAAkB,CAACU,IAAD,EAAOC,QAAP,EAAiB,CAAjB,CAAhC;;AAEA,MAAIA,QAAJ,EAAc;AACZA,IAAAA,QAAQ,CAACe,SAAT,CAAmBlB,UAAU,GAAG,CAAhC,EAAmCS,0BAAnC,EAA+D,IAA/D;AACAN,IAAAA,QAAQ,CAACe,SAAT,CAAmBlB,UAAU,GAAG,CAAhC,EAAmCa,4BAAnC,EAAiE,IAAjE;AACAV,IAAAA,QAAQ,CAACe,SAAT,CAAmBlB,UAAU,GAAG,CAAhC,EAAmC,CAAnC,EAAsC,IAAtC;AACAG,IAAAA,QAAQ,CAACe,SAAT,CAAmBlB,UAAU,GAAG,EAAhC,EAAoC,CAApC,EAAuC,IAAvC;AACD;;AACDA,EAAAA,UAAU,IAAI,EAAd;AAEAA,EAAAA,UAAU,IAAIL,oBAAoB,CAChCQ,QADgC,EAEhCH,UAFgC,EAGhCM,sBAHgC,EAIhCG,0BAJgC,CAAlC;AAMAT,EAAAA,UAAU,IAAIJ,oBAAoB,CAChCO,QADgC,EAEhCH,UAFgC,EAGhCW,kBAHgC,EAIhCE,4BAJgC,CAAlC;AAQApB,EAAAA,sBAAsB,CAACU,QAAD,EAAWc,eAAX,EAA4BjB,UAAU,GAAGiB,eAAzC,CAAtB;AAEA,SAAOjB,UAAP;AACD","sourcesContent":["// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport {MAGIC_ARRAY} from '../constants';\nimport {encode3DTileHeader, encode3DTileByteLength} from './helpers/encode-3d-tile-header';\nimport {\n  padStringToByteAlignment,\n  copyStringToDataView,\n  copyBinaryToDataView\n} from '@loaders.gl/loader-utils';\n\nconst DEFAULT_FEATURE_TABLE_JSON = {\n  POINTS_LENGTH: 1,\n  POSITIONS: {\n    byteOffset: 0\n  }\n};\n\nexport function encodePointCloud3DTile(tile, dataView, byteOffset, options) {\n  const {featureTableJson = DEFAULT_FEATURE_TABLE_JSON} = tile;\n\n  let featureTableJsonString = JSON.stringify(featureTableJson);\n  featureTableJsonString = padStringToByteAlignment(featureTableJsonString, 4);\n\n  const {featureTableJsonByteLength = featureTableJsonString.length} = tile;\n\n  const featureTableBinary = new ArrayBuffer(12); // Enough space to hold 3 floats\n  const featureTableBinaryByteLength = featureTableBinary.byteLength;\n\n  // Add default magic for this tile type\n  tile = {magic: MAGIC_ARRAY.POINT_CLOUD, ...tile};\n\n  const byteOffsetStart = byteOffset;\n\n  byteOffset += encode3DTileHeader(tile, dataView, 0);\n\n  if (dataView) {\n    dataView.setUint32(byteOffset + 0, featureTableJsonByteLength, true); // featureTableJsonByteLength\n    dataView.setUint32(byteOffset + 4, featureTableBinaryByteLength, true); // featureTableBinaryByteLength\n    dataView.setUint32(byteOffset + 8, 0, true); // batchTableJsonByteLength\n    dataView.setUint32(byteOffset + 12, 0, true); // batchTableBinaryByteLength\n  }\n  byteOffset += 16;\n\n  byteOffset += copyStringToDataView(\n    dataView,\n    byteOffset,\n    featureTableJsonString,\n    featureTableJsonByteLength\n  );\n  byteOffset += copyBinaryToDataView(\n    dataView,\n    byteOffset,\n    featureTableBinary,\n    featureTableBinaryByteLength\n  );\n\n  // Go \"back\" and rewrite the tile's `byteLength` now that we know the value\n  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);\n\n  return byteOffset;\n}\n"],"file":"encode-3d-tile-point-cloud.js"}
+{"version":3,"file":"encode-3d-tile-point-cloud.js","names":["MAGIC_ARRAY","encode3DTileHeader","encode3DTileByteLength","padStringToByteAlignment","copyStringToDataView","copyBinaryToDataView","DEFAULT_FEATURE_TABLE_JSON","POINTS_LENGTH","POSITIONS","byteOffset","encodePointCloud3DTile","tile","dataView","options","featureTableJson","featureTableJsonString","JSON","stringify","featureTableJsonByteLength","length","featureTableBinary","ArrayBuffer","featureTableBinaryByteLength","byteLength","magic","POINT_CLOUD","byteOffsetStart","setUint32"],"sources":["../../../../src/lib/encoders/encode-3d-tile-point-cloud.ts"],"sourcesContent":["// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport {MAGIC_ARRAY} from '../constants';\nimport {encode3DTileHeader, encode3DTileByteLength} from './helpers/encode-3d-tile-header';\nimport {\n  padStringToByteAlignment,\n  copyStringToDataView,\n  copyBinaryToDataView\n} from '@loaders.gl/loader-utils';\n\nconst DEFAULT_FEATURE_TABLE_JSON = {\n  POINTS_LENGTH: 1,\n  POSITIONS: {\n    byteOffset: 0\n  }\n};\n\nexport function encodePointCloud3DTile(tile, dataView, byteOffset, options) {\n  const {featureTableJson = DEFAULT_FEATURE_TABLE_JSON} = tile;\n\n  let featureTableJsonString = JSON.stringify(featureTableJson);\n  featureTableJsonString = padStringToByteAlignment(featureTableJsonString, 4);\n\n  const {featureTableJsonByteLength = featureTableJsonString.length} = tile;\n\n  const featureTableBinary = new ArrayBuffer(12); // Enough space to hold 3 floats\n  const featureTableBinaryByteLength = featureTableBinary.byteLength;\n\n  // Add default magic for this tile type\n  tile = {magic: MAGIC_ARRAY.POINT_CLOUD, ...tile};\n\n  const byteOffsetStart = byteOffset;\n\n  byteOffset += encode3DTileHeader(tile, dataView, 0);\n\n  if (dataView) {\n    dataView.setUint32(byteOffset + 0, featureTableJsonByteLength, true); // featureTableJsonByteLength\n    dataView.setUint32(byteOffset + 4, featureTableBinaryByteLength, true); // featureTableBinaryByteLength\n    dataView.setUint32(byteOffset + 8, 0, true); // batchTableJsonByteLength\n    dataView.setUint32(byteOffset + 12, 0, true); // batchTableBinaryByteLength\n  }\n  byteOffset += 16;\n\n  byteOffset += copyStringToDataView(\n    dataView,\n    byteOffset,\n    featureTableJsonString,\n    featureTableJsonByteLength\n  );\n  byteOffset += copyBinaryToDataView(\n    dataView,\n    byteOffset,\n    featureTableBinary,\n    featureTableBinaryByteLength\n  );\n\n  // Go \"back\" and rewrite the tile's `byteLength` now that we know the value\n  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);\n\n  return byteOffset;\n}\n"],"mappings":";;AAGA,SAAQA,WAAW,QAAO,cAAc;AACxC,SAAQC,kBAAkB,EAAEC,sBAAsB,QAAO,iCAAiC;AAC1F,SACEC,wBAAwB,EACxBC,oBAAoB,EACpBC,oBAAoB,QACf,0BAA0B;AAEjC,MAAMC,0BAA0B,GAAG;EACjCC,aAAa,EAAE,CAAC;EAChBC,SAAS,EAAE;IACTC,UAAU,EAAE;EACd;AACF,CAAC;AAED,OAAO,SAASC,sBAAsB,CAACC,IAAI,EAAEC,QAAQ,EAAEH,UAAU,EAAEI,OAAO,EAAE;EAC1E,MAAM;IAACC,gBAAgB,GAAGR;EAA0B,CAAC,GAAGK,IAAI;EAE5D,IAAII,sBAAsB,GAAGC,IAAI,CAACC,SAAS,CAACH,gBAAgB,CAAC;EAC7DC,sBAAsB,GAAGZ,wBAAwB,CAACY,sBAAsB,EAAE,CAAC,CAAC;EAE5E,MAAM;IAACG,0BAA0B,GAAGH,sBAAsB,CAACI;EAAM,CAAC,GAAGR,IAAI;EAEzE,MAAMS,kBAAkB,GAAG,IAAIC,WAAW,CAAC,EAAE,CAAC;EAC9C,MAAMC,4BAA4B,GAAGF,kBAAkB,CAACG,UAAU;;EAGlEZ,IAAI,GAAG;IAACa,KAAK,EAAExB,WAAW,CAACyB,WAAW;IAAE,GAAGd;EAAI,CAAC;EAEhD,MAAMe,eAAe,GAAGjB,UAAU;EAElCA,UAAU,IAAIR,kBAAkB,CAACU,IAAI,EAAEC,QAAQ,EAAE,CAAC,CAAC;EAEnD,IAAIA,QAAQ,EAAE;IACZA,QAAQ,CAACe,SAAS,CAAClB,UAAU,GAAG,CAAC,EAAES,0BAA0B,EAAE,IAAI,CAAC;IACpEN,QAAQ,CAACe,SAAS,CAAClB,UAAU,GAAG,CAAC,EAAEa,4BAA4B,EAAE,IAAI,CAAC;IACtEV,QAAQ,CAACe,SAAS,CAAClB,UAAU,GAAG,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC;IAC3CG,QAAQ,CAACe,SAAS,CAAClB,UAAU,GAAG,EAAE,EAAE,CAAC,EAAE,IAAI,CAAC;EAC9C;;EACAA,UAAU,IAAI,EAAE;EAEhBA,UAAU,IAAIL,oBAAoB,CAChCQ,QAAQ,EACRH,UAAU,EACVM,sBAAsB,EACtBG,0BAA0B,CAC3B;EACDT,UAAU,IAAIJ,oBAAoB,CAChCO,QAAQ,EACRH,UAAU,EACVW,kBAAkB,EAClBE,4BAA4B,CAC7B;;EAGDpB,sBAAsB,CAACU,QAAQ,EAAEc,eAAe,EAAEjB,UAAU,GAAGiB,eAAe,CAAC;EAE/E,OAAOjB,UAAU;AACnB"}

package/dist/esm/lib/encoders/encode-3d-tile.js

@@ -1,3 +1,5 @@
+
+
 import { TILE3D_TYPE } from '../constants';
 import { assert } from '@loaders.gl/loader-utils';
 import { encodeComposite3DTile } from './encode-3d-tile-composite';
@@ -11,23 +13,17 @@ export default function encode3DTile(tile, options) {
   encode3DTileToDataView(tile, dataView, 0, options);
   return arrayBuffer;
 }
-
 function encode3DTileToDataView(tile, dataView, byteOffset, options) {
   assert(typeof tile.type === 'string');
-
   switch (tile.type) {
     case TILE3D_TYPE.COMPOSITE:
       return encodeComposite3DTile(tile, dataView, byteOffset, options, encode3DTileToDataView);
-
     case TILE3D_TYPE.POINT_CLOUD:
       return encodePointCloud3DTile(tile, dataView, byteOffset, options);
-
     case TILE3D_TYPE.BATCHED_3D_MODEL:
       return encodeBatchedModel3DTile(tile, dataView, byteOffset, options);
-
     case TILE3D_TYPE.INSTANCED_3D_MODEL:
       return encodeInstancedModel3DTile(tile, dataView, byteOffset, options);
-
     default:
       throw new Error('3D Tiles: unknown tile type');
   }

package/dist/esm/lib/encoders/encode-3d-tile.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/encoders/encode-3d-tile.ts"],"names":["TILE3D_TYPE","assert","encodeComposite3DTile","encodeBatchedModel3DTile","encodeInstancedModel3DTile","encodePointCloud3DTile","encode3DTile","tile","options","byteLength","encode3DTileToDataView","arrayBuffer","ArrayBuffer","dataView","DataView","byteOffset","type","COMPOSITE","POINT_CLOUD","BATCHED_3D_MODEL","INSTANCED_3D_MODEL","Error"],"mappings":"AAGA,SAAQA,WAAR,QAA0B,cAA1B;AACA,SAAQC,MAAR,QAAqB,0BAArB;AAEA,SAAQC,qBAAR,QAAoC,4BAApC;AACA,SAAQC,wBAAR,QAAuC,gCAAvC;AACA,SAAQC,0BAAR,QAAyC,kCAAzC;AACA,SAAQC,sBAAR,QAAqC,8BAArC;AAEA,eAAe,SAASC,YAAT,CAAsBC,IAAtB,EAA4BC,OAA5B,EAAqC;AAClD,QAAMC,UAAU,GAAGC,sBAAsB,CAACH,IAAD,EAAO,IAAP,EAAa,CAAb,EAAgBC,OAAhB,CAAzC;AACA,QAAMG,WAAW,GAAG,IAAIC,WAAJ,CAAgBH,UAAhB,CAApB;AACA,QAAMI,QAAQ,GAAG,IAAIC,QAAJ,CAAaH,WAAb,CAAjB;AACAD,EAAAA,sBAAsB,CAACH,IAAD,EAAOM,QAAP,EAAiB,CAAjB,EAAoBL,OAApB,CAAtB;AACA,SAAOG,WAAP;AACD;;AAED,SAASD,sBAAT,CAAgCH,IAAhC,EAAsCM,QAAtC,EAAgDE,UAAhD,EAA4DP,OAA5D,EAAqE;AACnEP,EAAAA,MAAM,CAAC,OAAOM,IAAI,CAACS,IAAZ,KAAqB,QAAtB,CAAN;;AAEA,UAAQT,IAAI,CAACS,IAAb;AACE,SAAKhB,WAAW,CAACiB,SAAjB;AACE,aAAOf,qBAAqB,CAACK,IAAD,EAAOM,QAAP,EAAiBE,UAAjB,EAA6BP,OAA7B,EAAsCE,sBAAtC,CAA5B;;AACF,SAAKV,WAAW,CAACkB,WAAjB;AACE,aAAOb,sBAAsB,CAACE,IAAD,EAAOM,QAAP,EAAiBE,UAAjB,EAA6BP,OAA7B,CAA7B;;AACF,SAAKR,WAAW,CAACmB,gBAAjB;AACE,aAAOhB,wBAAwB,CAACI,IAAD,EAAOM,QAAP,EAAiBE,UAAjB,EAA6BP,OAA7B,CAA/B;;AACF,SAAKR,WAAW,CAACoB,kBAAjB;AACE,aAAOhB,0BAA0B,CAACG,IAAD,EAAOM,QAAP,EAAiBE,UAAjB,EAA6BP,OAA7B,CAAjC;;AACF;AACE,YAAM,IAAIa,KAAJ,CAAU,6BAAV,CAAN;AAVJ;AAYD","sourcesContent":["// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport {TILE3D_TYPE} from '../constants';\nimport {assert} from '@loaders.gl/loader-utils';\n\nimport {encodeComposite3DTile} from './encode-3d-tile-composite';\nimport {encodeBatchedModel3DTile} from './encode-3d-tile-batched-model';\nimport {encodeInstancedModel3DTile} from './encode-3d-tile-instanced-model';\nimport {encodePointCloud3DTile} from './encode-3d-tile-point-cloud';\n\nexport default function encode3DTile(tile, options) {\n  const byteLength = encode3DTileToDataView(tile, null, 0, options);\n  const arrayBuffer = new ArrayBuffer(byteLength);\n  const dataView = new DataView(arrayBuffer);\n  encode3DTileToDataView(tile, dataView, 0, options);\n  return arrayBuffer;\n}\n\nfunction encode3DTileToDataView(tile, dataView, byteOffset, options) {\n  assert(typeof tile.type === 'string');\n\n  switch (tile.type) {\n    case TILE3D_TYPE.COMPOSITE:\n      return encodeComposite3DTile(tile, dataView, byteOffset, options, encode3DTileToDataView);\n    case TILE3D_TYPE.POINT_CLOUD:\n      return encodePointCloud3DTile(tile, dataView, byteOffset, options);\n    case TILE3D_TYPE.BATCHED_3D_MODEL:\n      return encodeBatchedModel3DTile(tile, dataView, byteOffset, options);\n    case TILE3D_TYPE.INSTANCED_3D_MODEL:\n      return encodeInstancedModel3DTile(tile, dataView, byteOffset, options);\n    default:\n      throw new Error('3D Tiles: unknown tile type');\n  }\n}\n"],"file":"encode-3d-tile.js"}
+{"version":3,"file":"encode-3d-tile.js","names":["TILE3D_TYPE","assert","encodeComposite3DTile","encodeBatchedModel3DTile","encodeInstancedModel3DTile","encodePointCloud3DTile","encode3DTile","tile","options","byteLength","encode3DTileToDataView","arrayBuffer","ArrayBuffer","dataView","DataView","byteOffset","type","COMPOSITE","POINT_CLOUD","BATCHED_3D_MODEL","INSTANCED_3D_MODEL","Error"],"sources":["../../../../src/lib/encoders/encode-3d-tile.ts"],"sourcesContent":["// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport {TILE3D_TYPE} from '../constants';\nimport {assert} from '@loaders.gl/loader-utils';\n\nimport {encodeComposite3DTile} from './encode-3d-tile-composite';\nimport {encodeBatchedModel3DTile} from './encode-3d-tile-batched-model';\nimport {encodeInstancedModel3DTile} from './encode-3d-tile-instanced-model';\nimport {encodePointCloud3DTile} from './encode-3d-tile-point-cloud';\n\nexport default function encode3DTile(tile, options) {\n  const byteLength = encode3DTileToDataView(tile, null, 0, options);\n  const arrayBuffer = new ArrayBuffer(byteLength);\n  const dataView = new DataView(arrayBuffer);\n  encode3DTileToDataView(tile, dataView, 0, options);\n  return arrayBuffer;\n}\n\nfunction encode3DTileToDataView(tile, dataView, byteOffset, options) {\n  assert(typeof tile.type === 'string');\n\n  switch (tile.type) {\n    case TILE3D_TYPE.COMPOSITE:\n      return encodeComposite3DTile(tile, dataView, byteOffset, options, encode3DTileToDataView);\n    case TILE3D_TYPE.POINT_CLOUD:\n      return encodePointCloud3DTile(tile, dataView, byteOffset, options);\n    case TILE3D_TYPE.BATCHED_3D_MODEL:\n      return encodeBatchedModel3DTile(tile, dataView, byteOffset, options);\n    case TILE3D_TYPE.INSTANCED_3D_MODEL:\n      return encodeInstancedModel3DTile(tile, dataView, byteOffset, options);\n    default:\n      throw new Error('3D Tiles: unknown tile type');\n  }\n}\n"],"mappings":";;AAGA,SAAQA,WAAW,QAAO,cAAc;AACxC,SAAQC,MAAM,QAAO,0BAA0B;AAE/C,SAAQC,qBAAqB,QAAO,4BAA4B;AAChE,SAAQC,wBAAwB,QAAO,gCAAgC;AACvE,SAAQC,0BAA0B,QAAO,kCAAkC;AAC3E,SAAQC,sBAAsB,QAAO,8BAA8B;AAEnE,eAAe,SAASC,YAAY,CAACC,IAAI,EAAEC,OAAO,EAAE;EAClD,MAAMC,UAAU,GAAGC,sBAAsB,CAACH,IAAI,EAAE,IAAI,EAAE,CAAC,EAAEC,OAAO,CAAC;EACjE,MAAMG,WAAW,GAAG,IAAIC,WAAW,CAACH,UAAU,CAAC;EAC/C,MAAMI,QAAQ,GAAG,IAAIC,QAAQ,CAACH,WAAW,CAAC;EAC1CD,sBAAsB,CAACH,IAAI,EAAEM,QAAQ,EAAE,CAAC,EAAEL,OAAO,CAAC;EAClD,OAAOG,WAAW;AACpB;AAEA,SAASD,sBAAsB,CAACH,IAAI,EAAEM,QAAQ,EAAEE,UAAU,EAAEP,OAAO,EAAE;EACnEP,MAAM,CAAC,OAAOM,IAAI,CAACS,IAAI,KAAK,QAAQ,CAAC;EAErC,QAAQT,IAAI,CAACS,IAAI;IACf,KAAKhB,WAAW,CAACiB,SAAS;MACxB,OAAOf,qBAAqB,CAACK,IAAI,EAAEM,QAAQ,EAAEE,UAAU,EAAEP,OAAO,EAAEE,sBAAsB,CAAC;IAC3F,KAAKV,WAAW,CAACkB,WAAW;MAC1B,OAAOb,sBAAsB,CAACE,IAAI,EAAEM,QAAQ,EAAEE,UAAU,EAAEP,OAAO,CAAC;IACpE,KAAKR,WAAW,CAACmB,gBAAgB;MAC/B,OAAOhB,wBAAwB,CAACI,IAAI,EAAEM,QAAQ,EAAEE,UAAU,EAAEP,OAAO,CAAC;IACtE,KAAKR,WAAW,CAACoB,kBAAkB;MACjC,OAAOhB,0BAA0B,CAACG,IAAI,EAAEM,QAAQ,EAAEE,UAAU,EAAEP,OAAO,CAAC;IACxE;MACE,MAAM,IAAIa,KAAK,CAAC,6BAA6B,CAAC;EAAC;AAErD"}

package/dist/esm/lib/encoders/helpers/encode-3d-tile-header.js

@@ -1,11 +1,10 @@
+
 import { assert } from '@loaders.gl/loader-utils';
 export function encode3DTileHeader(tile, dataView, byteOffset) {
   const HEADER_SIZE = 12;
-
   if (!dataView) {
     return byteOffset + HEADER_SIZE;
   }
-
   const {
     magic,
     version = 1,
@@ -18,14 +17,15 @@ export function encode3DTileHeader(tile, dataView, byteOffset) {
   dataView.setUint8(byteOffset + 3, magic[3]);
   dataView.setUint32(byteOffset + 4, version, true);
   dataView.setUint32(byteOffset + 8, byteLength, true);
+
   byteOffset += HEADER_SIZE;
   return byteOffset;
 }
+
 export function encode3DTileByteLength(dataView, byteOffsetTileStart, byteLength) {
   if (!dataView) {
     return;
   }
-
   dataView.setUint32(byteOffsetTileStart + 8, byteLength, true);
 }
 //# sourceMappingURL=encode-3d-tile-header.js.map

package/dist/esm/lib/encoders/helpers/encode-3d-tile-header.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/lib/encoders/helpers/encode-3d-tile-header.ts"],"names":["assert","encode3DTileHeader","tile","dataView","byteOffset","HEADER_SIZE","magic","version","byteLength","Array","isArray","Number","isFinite","setUint8","setUint32","encode3DTileByteLength","byteOffsetTileStart"],"mappings":"AACA,SAAQA,MAAR,QAAqB,0BAArB;AAEA,OAAO,SAASC,kBAAT,CAA4BC,IAA5B,EAAkCC,QAAlC,EAA4CC,UAA5C,EAAwD;AAC7D,QAAMC,WAAW,GAAG,EAApB;;AAEA,MAAI,CAACF,QAAL,EAAe;AACb,WAAOC,UAAU,GAAGC,WAApB;AACD;;AAED,QAAM;AAACC,IAAAA,KAAD;AAAQC,IAAAA,OAAO,GAAG,CAAlB;AAAqBC,IAAAA,UAAU,GAAG;AAAlC,MAAwCN,IAA9C;AAEAF,EAAAA,MAAM,CAACS,KAAK,CAACC,OAAN,CAAcJ,KAAd,KAAwBK,MAAM,CAACC,QAAP,CAAgBL,OAAhB,CAAxB,IAAoDI,MAAM,CAACC,QAAP,CAAgBJ,UAAhB,CAArD,CAAN;AAEAL,EAAAA,QAAQ,CAACU,QAAT,CAAkBT,UAAU,GAAG,CAA/B,EAAkCE,KAAK,CAAC,CAAD,CAAvC;AACAH,EAAAA,QAAQ,CAACU,QAAT,CAAkBT,UAAU,GAAG,CAA/B,EAAkCE,KAAK,CAAC,CAAD,CAAvC;AACAH,EAAAA,QAAQ,CAACU,QAAT,CAAkBT,UAAU,GAAG,CAA/B,EAAkCE,KAAK,CAAC,CAAD,CAAvC;AACAH,EAAAA,QAAQ,CAACU,QAAT,CAAkBT,UAAU,GAAG,CAA/B,EAAkCE,KAAK,CAAC,CAAD,CAAvC;AACAH,EAAAA,QAAQ,CAACW,SAAT,CAAmBV,UAAU,GAAG,CAAhC,EAAmCG,OAAnC,EAA4C,IAA5C;AACAJ,EAAAA,QAAQ,CAACW,SAAT,CAAmBV,UAAU,GAAG,CAAhC,EAAmCI,UAAnC,EAA+C,IAA/C;AAEAJ,EAAAA,UAAU,IAAIC,WAAd;AAEA,SAAOD,UAAP;AACD;AAGD,OAAO,SAASW,sBAAT,CAAgCZ,QAAhC,EAA0Ca,mBAA1C,EAA+DR,UAA/D,EAA2E;AAChF,MAAI,CAACL,QAAL,EAAe;AACb;AACD;;AAEDA,EAAAA,QAAQ,CAACW,SAAT,CAAmBE,mBAAmB,GAAG,CAAzC,EAA4CR,UAA5C,EAAwD,IAAxD;AACD","sourcesContent":["// HELPER ENCODERS\nimport {assert} from '@loaders.gl/loader-utils';\n\nexport function encode3DTileHeader(tile, dataView, byteOffset) {\n  const HEADER_SIZE = 12;\n\n  if (!dataView) {\n    return byteOffset + HEADER_SIZE;\n  }\n\n  const {magic, version = 1, byteLength = 12} = tile;\n\n  assert(Array.isArray(magic) && Number.isFinite(version) && Number.isFinite(byteLength));\n\n  dataView.setUint8(byteOffset + 0, magic[0]);\n  dataView.setUint8(byteOffset + 1, magic[1]);\n  dataView.setUint8(byteOffset + 2, magic[2]);\n  dataView.setUint8(byteOffset + 3, magic[3]);\n  dataView.setUint32(byteOffset + 4, version, true); // version\n  dataView.setUint32(byteOffset + 8, byteLength, true); // byteLength\n\n  byteOffset += HEADER_SIZE;\n\n  return byteOffset;\n}\n\n// Bytelength is sometimes only known at the end of writing a tile\nexport function encode3DTileByteLength(dataView, byteOffsetTileStart, byteLength) {\n  if (!dataView) {\n    return;\n  }\n\n  dataView.setUint32(byteOffsetTileStart + 8, byteLength, true); // byteLength\n}\n"],"file":"encode-3d-tile-header.js"}
+{"version":3,"file":"encode-3d-tile-header.js","names":["assert","encode3DTileHeader","tile","dataView","byteOffset","HEADER_SIZE","magic","version","byteLength","Array","isArray","Number","isFinite","setUint8","setUint32","encode3DTileByteLength","byteOffsetTileStart"],"sources":["../../../../../src/lib/encoders/helpers/encode-3d-tile-header.ts"],"sourcesContent":["// HELPER ENCODERS\nimport {assert} from '@loaders.gl/loader-utils';\n\nexport function encode3DTileHeader(tile, dataView, byteOffset) {\n  const HEADER_SIZE = 12;\n\n  if (!dataView) {\n    return byteOffset + HEADER_SIZE;\n  }\n\n  const {magic, version = 1, byteLength = 12} = tile;\n\n  assert(Array.isArray(magic) && Number.isFinite(version) && Number.isFinite(byteLength));\n\n  dataView.setUint8(byteOffset + 0, magic[0]);\n  dataView.setUint8(byteOffset + 1, magic[1]);\n  dataView.setUint8(byteOffset + 2, magic[2]);\n  dataView.setUint8(byteOffset + 3, magic[3]);\n  dataView.setUint32(byteOffset + 4, version, true); // version\n  dataView.setUint32(byteOffset + 8, byteLength, true); // byteLength\n\n  byteOffset += HEADER_SIZE;\n\n  return byteOffset;\n}\n\n// Bytelength is sometimes only known at the end of writing a tile\nexport function encode3DTileByteLength(dataView, byteOffsetTileStart, byteLength) {\n  if (!dataView) {\n    return;\n  }\n\n  dataView.setUint32(byteOffsetTileStart + 8, byteLength, true); // byteLength\n}\n"],"mappings":";AACA,SAAQA,MAAM,QAAO,0BAA0B;AAE/C,OAAO,SAASC,kBAAkB,CAACC,IAAI,EAAEC,QAAQ,EAAEC,UAAU,EAAE;EAC7D,MAAMC,WAAW,GAAG,EAAE;EAEtB,IAAI,CAACF,QAAQ,EAAE;IACb,OAAOC,UAAU,GAAGC,WAAW;EACjC;EAEA,MAAM;IAACC,KAAK;IAAEC,OAAO,GAAG,CAAC;IAAEC,UAAU,GAAG;EAAE,CAAC,GAAGN,IAAI;EAElDF,MAAM,CAACS,KAAK,CAACC,OAAO,CAACJ,KAAK,CAAC,IAAIK,MAAM,CAACC,QAAQ,CAACL,OAAO,CAAC,IAAII,MAAM,CAACC,QAAQ,CAACJ,UAAU,CAAC,CAAC;EAEvFL,QAAQ,CAACU,QAAQ,CAACT,UAAU,GAAG,CAAC,EAAEE,KAAK,CAAC,CAAC,CAAC,CAAC;EAC3CH,QAAQ,CAACU,QAAQ,CAACT,UAAU,GAAG,CAAC,EAAEE,KAAK,CAAC,CAAC,CAAC,CAAC;EAC3CH,QAAQ,CAACU,QAAQ,CAACT,UAAU,GAAG,CAAC,EAAEE,KAAK,CAAC,CAAC,CAAC,CAAC;EAC3CH,QAAQ,CAACU,QAAQ,CAACT,UAAU,GAAG,CAAC,EAAEE,KAAK,CAAC,CAAC,CAAC,CAAC;EAC3CH,QAAQ,CAACW,SAAS,CAACV,UAAU,GAAG,CAAC,EAAEG,OAAO,EAAE,IAAI,CAAC;EACjDJ,QAAQ,CAACW,SAAS,CAACV,UAAU,GAAG,CAAC,EAAEI,UAAU,EAAE,IAAI,CAAC;;EAEpDJ,UAAU,IAAIC,WAAW;EAEzB,OAAOD,UAAU;AACnB;;AAGA,OAAO,SAASW,sBAAsB,CAACZ,QAAQ,EAAEa,mBAAmB,EAAER,UAAU,EAAE;EAChF,IAAI,CAACL,QAAQ,EAAE;IACb;EACF;EAEAA,QAAQ,CAACW,SAAS,CAACE,mBAAmB,GAAG,CAAC,EAAER,UAAU,EAAE,IAAI,CAAC;AAC/D"}

package/dist/esm/lib/ion/ion.js

@@ -1,10 +1,12 @@
+
+
 import { fetchFile } from '@loaders.gl/core';
 import { assert } from '@loaders.gl/loader-utils';
 const CESIUM_ION_URL = 'https://api.cesium.com/v1/assets';
+
 export async function getIonTilesetMetadata(accessToken, assetId) {
   if (!assetId) {
     const assets = await getIonAssets(accessToken);
-
     for (const item of assets.items) {
       if (item.type === '3DTILES') {
         assetId = item.id;
@@ -18,11 +20,13 @@ export async function getIonTilesetMetadata(accessToken, assetId) {
     url
   } = ionAssetMetadata;
   assert(type === '3DTILES' && url);
+
   ionAssetMetadata.headers = {
     Authorization: "Bearer ".concat(ionAssetMetadata.accessToken)
   };
   return ionAssetMetadata;
 }
+
 export async function getIonAssets(accessToken) {
   assert(accessToken);
   const url = CESIUM_ION_URL;
@@ -34,13 +38,12 @@ export async function getIonAssets(accessToken) {
       headers
     }
   });
-
   if (!response.ok) {
     throw new Error(response.statusText);
   }
-
   return await response.json();
 }
+
 export async function getIonAssetMetadata(accessToken, assetId) {
   assert(accessToken, assetId);
   const headers = {
@@ -52,24 +55,23 @@ export async function getIonAssetMetadata(accessToken, assetId) {
       headers
     }
   });
-
   if (!response.ok) {
     throw new Error(response.statusText);
   }
-
   let metadata = await response.json();
+
   response = await fetchFile("".concat(url, "/endpoint"), {
     fetch: {
       headers
     }
   });
-
   if (!response.ok) {
     throw new Error(response.statusText);
   }
-
   const tilesetInfo = await response.json();
-  metadata = { ...metadata,
+
+  metadata = {
+    ...metadata,
     ...tilesetInfo
   };
   return metadata;

package/dist/esm/lib/ion/ion.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/ion/ion.ts"],"names":["fetchFile","assert","CESIUM_ION_URL","getIonTilesetMetadata","accessToken","assetId","assets","getIonAssets","item","items","type","id","ionAssetMetadata","getIonAssetMetadata","url","headers","Authorization","response","fetch","ok","Error","statusText","json","metadata","tilesetInfo"],"mappings":"AAEA,SAAQA,SAAR,QAAwB,kBAAxB;AACA,SAAQC,MAAR,QAAqB,0BAArB;AAEA,MAAMC,cAAc,GAAG,kCAAvB;AAGA,OAAO,eAAeC,qBAAf,CAAqCC,WAArC,EAAkDC,OAAlD,EAA2D;AAEhE,MAAI,CAACA,OAAL,EAAc;AACZ,UAAMC,MAAM,GAAG,MAAMC,YAAY,CAACH,WAAD,CAAjC;;AACA,SAAK,MAAMI,IAAX,IAAmBF,MAAM,CAACG,KAA1B,EAAiC;AAC/B,UAAID,IAAI,CAACE,IAAL,KAAc,SAAlB,EAA6B;AAC3BL,QAAAA,OAAO,GAAGG,IAAI,CAACG,EAAf;AACD;AACF;AACF;;AAGD,QAAMC,gBAAgB,GAAG,MAAMC,mBAAmB,CAACT,WAAD,EAAcC,OAAd,CAAlD;AACA,QAAM;AAACK,IAAAA,IAAD;AAAOI,IAAAA;AAAP,MAAcF,gBAApB;AACAX,EAAAA,MAAM,CAACS,IAAI,KAAK,SAAT,IAAsBI,GAAvB,CAAN;AAGAF,EAAAA,gBAAgB,CAACG,OAAjB,GAA2B;AACzBC,IAAAA,aAAa,mBAAYJ,gBAAgB,CAACR,WAA7B;AADY,GAA3B;AAGA,SAAOQ,gBAAP;AACD;AAGD,OAAO,eAAeL,YAAf,CAA4BH,WAA5B,EAAyC;AAC9CH,EAAAA,MAAM,CAACG,WAAD,CAAN;AACA,QAAMU,GAAG,GAAGZ,cAAZ;AACA,QAAMa,OAAO,GAAG;AAACC,IAAAA,aAAa,mBAAYZ,WAAZ;AAAd,GAAhB;AACA,QAAMa,QAAQ,GAAG,MAAMjB,SAAS,CAACc,GAAD,EAAM;AAACI,IAAAA,KAAK,EAAE;AAACH,MAAAA;AAAD;AAAR,GAAN,CAAhC;;AACA,MAAI,CAACE,QAAQ,CAACE,EAAd,EAAkB;AAChB,UAAM,IAAIC,KAAJ,CAAUH,QAAQ,CAACI,UAAnB,CAAN;AACD;;AACD,SAAO,MAAMJ,QAAQ,CAACK,IAAT,EAAb;AACD;AAGD,OAAO,eAAeT,mBAAf,CAAmCT,WAAnC,EAAgDC,OAAhD,EAAyD;AAC9DJ,EAAAA,MAAM,CAACG,WAAD,EAAcC,OAAd,CAAN;AACA,QAAMU,OAAO,GAAG;AAACC,IAAAA,aAAa,mBAAYZ,WAAZ;AAAd,GAAhB;AAEA,QAAMU,GAAG,aAAMZ,cAAN,cAAwBG,OAAxB,CAAT;AAGA,MAAIY,QAAQ,GAAG,MAAMjB,SAAS,WAAIc,GAAJ,GAAW;AAACI,IAAAA,KAAK,EAAE;AAACH,MAAAA;AAAD;AAAR,GAAX,CAA9B;;AACA,MAAI,CAACE,QAAQ,CAACE,EAAd,EAAkB;AAChB,UAAM,IAAIC,KAAJ,CAAUH,QAAQ,CAACI,UAAnB,CAAN;AACD;;AACD,MAAIE,QAAQ,GAAG,MAAMN,QAAQ,CAACK,IAAT,EAArB;AAIAL,EAAAA,QAAQ,GAAG,MAAMjB,SAAS,WAAIc,GAAJ,gBAAoB;AAACI,IAAAA,KAAK,EAAE;AAACH,MAAAA;AAAD;AAAR,GAApB,CAA1B;;AACA,MAAI,CAACE,QAAQ,CAACE,EAAd,EAAkB;AAChB,UAAM,IAAIC,KAAJ,CAAUH,QAAQ,CAACI,UAAnB,CAAN;AACD;;AACD,QAAMG,WAAW,GAAG,MAAMP,QAAQ,CAACK,IAAT,EAA1B;AAGAC,EAAAA,QAAQ,GAAG,EACT,GAAGA,QADM;AAET,OAAGC;AAFM,GAAX;AAKA,SAAOD,QAAP;AACD","sourcesContent":["// Minimal support to load tilsets from the Cesium ION services\n\nimport {fetchFile} from '@loaders.gl/core';\nimport {assert} from '@loaders.gl/loader-utils';\n\nconst CESIUM_ION_URL = 'https://api.cesium.com/v1/assets';\n\n// Returns `{url, headers, type, attributions}` for an ion tileset\nexport async function getIonTilesetMetadata(accessToken, assetId) {\n  // Step 1, if no asset id, look for first 3DTILES asset associated with this token.\n  if (!assetId) {\n    const assets = await getIonAssets(accessToken);\n    for (const item of assets.items) {\n      if (item.type === '3DTILES') {\n        assetId = item.id;\n      }\n    }\n  }\n\n  // Step 2: Query metdatadata for this asset.\n  const ionAssetMetadata = await getIonAssetMetadata(accessToken, assetId);\n  const {type, url} = ionAssetMetadata;\n  assert(type === '3DTILES' && url);\n\n  // Prepare a headers object for fetch\n  ionAssetMetadata.headers = {\n    Authorization: `Bearer ${ionAssetMetadata.accessToken}`\n  };\n  return ionAssetMetadata;\n}\n\n// Return a list of all assets associated with accessToken\nexport async function getIonAssets(accessToken) {\n  assert(accessToken);\n  const url = CESIUM_ION_URL;\n  const headers = {Authorization: `Bearer ${accessToken}`};\n  const response = await fetchFile(url, {fetch: {headers}});\n  if (!response.ok) {\n    throw new Error(response.statusText);\n  }\n  return await response.json();\n}\n\n// Return metadata for a specific asset associated with token\nexport async function getIonAssetMetadata(accessToken, assetId) {\n  assert(accessToken, assetId);\n  const headers = {Authorization: `Bearer ${accessToken}`};\n\n  const url = `${CESIUM_ION_URL}/${assetId}`;\n  // https://cesium.com/docs/rest-api/#operation/getAsset\n  // Retrieves metadata information about a specific asset.\n  let response = await fetchFile(`${url}`, {fetch: {headers}});\n  if (!response.ok) {\n    throw new Error(response.statusText);\n  }\n  let metadata = await response.json();\n\n  // https://cesium.com/docs/rest-api/#operation/getAssetEndpoint\n  // Retrieves information and credentials that allow you to access the tiled asset data for visualization and analysis.\n  response = await fetchFile(`${url}/endpoint`, {fetch: {headers}});\n  if (!response.ok) {\n    throw new Error(response.statusText);\n  }\n  const tilesetInfo = await response.json();\n\n  // extract dataset description\n  metadata = {\n    ...metadata,\n    ...tilesetInfo\n  };\n\n  return metadata;\n}\n"],"file":"ion.js"}
+{"version":3,"file":"ion.js","names":["fetchFile","assert","CESIUM_ION_URL","getIonTilesetMetadata","accessToken","assetId","assets","getIonAssets","item","items","type","id","ionAssetMetadata","getIonAssetMetadata","url","headers","Authorization","response","fetch","ok","Error","statusText","json","metadata","tilesetInfo"],"sources":["../../../../src/lib/ion/ion.ts"],"sourcesContent":["// Minimal support to load tilsets from the Cesium ION services\n\nimport {fetchFile} from '@loaders.gl/core';\nimport {assert} from '@loaders.gl/loader-utils';\n\nconst CESIUM_ION_URL = 'https://api.cesium.com/v1/assets';\n\n// Returns `{url, headers, type, attributions}` for an ion tileset\nexport async function getIonTilesetMetadata(accessToken, assetId) {\n  // Step 1, if no asset id, look for first 3DTILES asset associated with this token.\n  if (!assetId) {\n    const assets = await getIonAssets(accessToken);\n    for (const item of assets.items) {\n      if (item.type === '3DTILES') {\n        assetId = item.id;\n      }\n    }\n  }\n\n  // Step 2: Query metdatadata for this asset.\n  const ionAssetMetadata = await getIonAssetMetadata(accessToken, assetId);\n  const {type, url} = ionAssetMetadata;\n  assert(type === '3DTILES' && url);\n\n  // Prepare a headers object for fetch\n  ionAssetMetadata.headers = {\n    Authorization: `Bearer ${ionAssetMetadata.accessToken}`\n  };\n  return ionAssetMetadata;\n}\n\n// Return a list of all assets associated with accessToken\nexport async function getIonAssets(accessToken) {\n  assert(accessToken);\n  const url = CESIUM_ION_URL;\n  const headers = {Authorization: `Bearer ${accessToken}`};\n  const response = await fetchFile(url, {fetch: {headers}});\n  if (!response.ok) {\n    throw new Error(response.statusText);\n  }\n  return await response.json();\n}\n\n// Return metadata for a specific asset associated with token\nexport async function getIonAssetMetadata(accessToken, assetId) {\n  assert(accessToken, assetId);\n  const headers = {Authorization: `Bearer ${accessToken}`};\n\n  const url = `${CESIUM_ION_URL}/${assetId}`;\n  // https://cesium.com/docs/rest-api/#operation/getAsset\n  // Retrieves metadata information about a specific asset.\n  let response = await fetchFile(`${url}`, {fetch: {headers}});\n  if (!response.ok) {\n    throw new Error(response.statusText);\n  }\n  let metadata = await response.json();\n\n  // https://cesium.com/docs/rest-api/#operation/getAssetEndpoint\n  // Retrieves information and credentials that allow you to access the tiled asset data for visualization and analysis.\n  response = await fetchFile(`${url}/endpoint`, {fetch: {headers}});\n  if (!response.ok) {\n    throw new Error(response.statusText);\n  }\n  const tilesetInfo = await response.json();\n\n  // extract dataset description\n  metadata = {\n    ...metadata,\n    ...tilesetInfo\n  };\n\n  return metadata;\n}\n"],"mappings":";;AAEA,SAAQA,SAAS,QAAO,kBAAkB;AAC1C,SAAQC,MAAM,QAAO,0BAA0B;AAE/C,MAAMC,cAAc,GAAG,kCAAkC;;AAGzD,OAAO,eAAeC,qBAAqB,CAACC,WAAW,EAAEC,OAAO,EAAE;EAEhE,IAAI,CAACA,OAAO,EAAE;IACZ,MAAMC,MAAM,GAAG,MAAMC,YAAY,CAACH,WAAW,CAAC;IAC9C,KAAK,MAAMI,IAAI,IAAIF,MAAM,CAACG,KAAK,EAAE;MAC/B,IAAID,IAAI,CAACE,IAAI,KAAK,SAAS,EAAE;QAC3BL,OAAO,GAAGG,IAAI,CAACG,EAAE;MACnB;IACF;EACF;;EAGA,MAAMC,gBAAgB,GAAG,MAAMC,mBAAmB,CAACT,WAAW,EAAEC,OAAO,CAAC;EACxE,MAAM;IAACK,IAAI;IAAEI;EAAG,CAAC,GAAGF,gBAAgB;EACpCX,MAAM,CAACS,IAAI,KAAK,SAAS,IAAII,GAAG,CAAC;;EAGjCF,gBAAgB,CAACG,OAAO,GAAG;IACzBC,aAAa,mBAAYJ,gBAAgB,CAACR,WAAW;EACvD,CAAC;EACD,OAAOQ,gBAAgB;AACzB;;AAGA,OAAO,eAAeL,YAAY,CAACH,WAAW,EAAE;EAC9CH,MAAM,CAACG,WAAW,CAAC;EACnB,MAAMU,GAAG,GAAGZ,cAAc;EAC1B,MAAMa,OAAO,GAAG;IAACC,aAAa,mBAAYZ,WAAW;EAAE,CAAC;EACxD,MAAMa,QAAQ,GAAG,MAAMjB,SAAS,CAACc,GAAG,EAAE;IAACI,KAAK,EAAE;MAACH;IAAO;EAAC,CAAC,CAAC;EACzD,IAAI,CAACE,QAAQ,CAACE,EAAE,EAAE;IAChB,MAAM,IAAIC,KAAK,CAACH,QAAQ,CAACI,UAAU,CAAC;EACtC;EACA,OAAO,MAAMJ,QAAQ,CAACK,IAAI,EAAE;AAC9B;;AAGA,OAAO,eAAeT,mBAAmB,CAACT,WAAW,EAAEC,OAAO,EAAE;EAC9DJ,MAAM,CAACG,WAAW,EAAEC,OAAO,CAAC;EAC5B,MAAMU,OAAO,GAAG;IAACC,aAAa,mBAAYZ,WAAW;EAAE,CAAC;EAExD,MAAMU,GAAG,aAAMZ,cAAc,cAAIG,OAAO,CAAE;EAG1C,IAAIY,QAAQ,GAAG,MAAMjB,SAAS,WAAIc,GAAG,GAAI;IAACI,KAAK,EAAE;MAACH;IAAO;EAAC,CAAC,CAAC;EAC5D,IAAI,CAACE,QAAQ,CAACE,EAAE,EAAE;IAChB,MAAM,IAAIC,KAAK,CAACH,QAAQ,CAACI,UAAU,CAAC;EACtC;EACA,IAAIE,QAAQ,GAAG,MAAMN,QAAQ,CAACK,IAAI,EAAE;;EAIpCL,QAAQ,GAAG,MAAMjB,SAAS,WAAIc,GAAG,gBAAa;IAACI,KAAK,EAAE;MAACH;IAAO;EAAC,CAAC,CAAC;EACjE,IAAI,CAACE,QAAQ,CAACE,EAAE,EAAE;IAChB,MAAM,IAAIC,KAAK,CAACH,QAAQ,CAACI,UAAU,CAAC;EACtC;EACA,MAAMG,WAAW,GAAG,MAAMP,QAAQ,CAACK,IAAI,EAAE;;EAGzCC,QAAQ,GAAG;IACT,GAAGA,QAAQ;IACX,GAAGC;EACL,CAAC;EAED,OAAOD,QAAQ;AACjB"}

package/dist/esm/lib/parsers/helpers/normalize-3d-tile-colors.js

@@ -1,18 +1,16 @@
 import { decodeRGB565, GL } from '@loaders.gl/math';
+
 export function normalize3DTileColorAttribute(tile, colors, batchTable) {
   if (!colors && (!tile || !tile.batchIds || !batchTable)) {
     return null;
   }
-
   const {
     batchIds,
     isRGB565,
     pointCount
   } = tile;
-
   if (batchIds && batchTable) {
     const colorArray = new Uint8ClampedArray(pointCount * 3);
-
     for (let i = 0; i < pointCount; i++) {
       const batchId = batchIds[i];
       const dimensions = batchTable.getProperty(batchId, 'dimensions');
@@ -21,7 +19,6 @@ export function normalize3DTileColorAttribute(tile, colors, batchTable) {
       colorArray[i * 3 + 1] = color[1];
       colorArray[i * 3 + 2] = color[2];
     }
-
     return {
       type: GL.UNSIGNED_BYTE,
       value: colorArray,
@@ -32,14 +29,12 @@ export function normalize3DTileColorAttribute(tile, colors, batchTable) {
 
   if (isRGB565) {
     const colorArray = new Uint8ClampedArray(pointCount * 3);
-
     for (let i = 0; i < pointCount; i++) {
       const color = decodeRGB565(colors[i]);
       colorArray[i * 3] = color[0];
       colorArray[i * 3 + 1] = color[1];
       colorArray[i * 3 + 2] = color[2];
     }
-
     return {
       type: GL.UNSIGNED_BYTE,
       value: colorArray,

package/dist/esm/lib/parsers/helpers/normalize-3d-tile-colors.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/lib/parsers/helpers/normalize-3d-tile-colors.ts"],"names":["decodeRGB565","GL","normalize3DTileColorAttribute","tile","colors","batchTable","batchIds","isRGB565","pointCount","colorArray","Uint8ClampedArray","i","batchId","dimensions","getProperty","color","map","d","type","UNSIGNED_BYTE","value","size","normalized","length"],"mappings":"AAAA,SAAQA,YAAR,EAAsBC,EAAtB,QAA+B,kBAA/B;AAGA,OAAO,SAASC,6BAAT,CAAuCC,IAAvC,EAA6CC,MAA7C,EAAqDC,UAArD,EAAkE;AAEvE,MAAI,CAACD,MAAD,KAAY,CAACD,IAAD,IAAS,CAACA,IAAI,CAACG,QAAf,IAA2B,CAACD,UAAxC,CAAJ,EAAyD;AACvD,WAAO,IAAP;AACD;;AAED,QAAM;AAACC,IAAAA,QAAD;AAAWC,IAAAA,QAAX;AAAqBC,IAAAA;AAArB,MAAmCL,IAAzC;;AAEA,MAAIG,QAAQ,IAAID,UAAhB,EAA4B;AAC1B,UAAMI,UAAU,GAAG,IAAIC,iBAAJ,CAAsBF,UAAU,GAAG,CAAnC,CAAnB;;AACA,SAAK,IAAIG,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGH,UAApB,EAAgCG,CAAC,EAAjC,EAAqC;AACnC,YAAMC,OAAO,GAAGN,QAAQ,CAACK,CAAD,CAAxB;AAEA,YAAME,UAAU,GAAGR,UAAU,CAACS,WAAX,CAAuBF,OAAvB,EAAgC,YAAhC,CAAnB;AACA,YAAMG,KAAK,GAAGF,UAAU,CAACG,GAAX,CAAgBC,CAAD,IAAOA,CAAC,GAAG,GAA1B,CAAd;AACAR,MAAAA,UAAU,CAACE,CAAC,GAAG,CAAL,CAAV,GAAoBI,KAAK,CAAC,CAAD,CAAzB;AACAN,MAAAA,UAAU,CAACE,CAAC,GAAG,CAAJ,GAAQ,CAAT,CAAV,GAAwBI,KAAK,CAAC,CAAD,CAA7B;AACAN,MAAAA,UAAU,CAACE,CAAC,GAAG,CAAJ,GAAQ,CAAT,CAAV,GAAwBI,KAAK,CAAC,CAAD,CAA7B;AACD;;AACD,WAAO;AACLG,MAAAA,IAAI,EAAEjB,EAAE,CAACkB,aADJ;AAELC,MAAAA,KAAK,EAAEX,UAFF;AAGLY,MAAAA,IAAI,EAAE,CAHD;AAILC,MAAAA,UAAU,EAAE;AAJP,KAAP;AAMD;;AAGD,MAAIf,QAAJ,EAAc;AACZ,UAAME,UAAU,GAAG,IAAIC,iBAAJ,CAAsBF,UAAU,GAAG,CAAnC,CAAnB;;AACA,SAAK,IAAIG,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGH,UAApB,EAAgCG,CAAC,EAAjC,EAAqC;AACnC,YAAMI,KAAK,GAAGf,YAAY,CAACI,MAAM,CAACO,CAAD,CAAP,CAA1B;AACAF,MAAAA,UAAU,CAACE,CAAC,GAAG,CAAL,CAAV,GAAoBI,KAAK,CAAC,CAAD,CAAzB;AACAN,MAAAA,UAAU,CAACE,CAAC,GAAG,CAAJ,GAAQ,CAAT,CAAV,GAAwBI,KAAK,CAAC,CAAD,CAA7B;AACAN,MAAAA,UAAU,CAACE,CAAC,GAAG,CAAJ,GAAQ,CAAT,CAAV,GAAwBI,KAAK,CAAC,CAAD,CAA7B;AACD;;AACD,WAAO;AACLG,MAAAA,IAAI,EAAEjB,EAAE,CAACkB,aADJ;AAELC,MAAAA,KAAK,EAAEX,UAFF;AAGLY,MAAAA,IAAI,EAAE,CAHD;AAILC,MAAAA,UAAU,EAAE;AAJP,KAAP;AAMD;;AAGD,MAAIlB,MAAM,IAAIA,MAAM,CAACmB,MAAP,KAAkBf,UAAU,GAAG,CAA7C,EAAgD;AAC9C,WAAO;AACLU,MAAAA,IAAI,EAAEjB,EAAE,CAACkB,aADJ;AAELC,MAAAA,KAAK,EAAEhB,MAFF;AAGLiB,MAAAA,IAAI,EAAE,CAHD;AAILC,MAAAA,UAAU,EAAE;AAJP,KAAP;AAMD;;AAGD,SAAO;AACLJ,IAAAA,IAAI,EAAEjB,EAAE,CAACkB,aADJ;AAELC,IAAAA,KAAK,EAAEhB,MAFF;AAGLiB,IAAAA,IAAI,EAAE,CAHD;AAILC,IAAAA,UAAU,EAAE;AAJP,GAAP;AAMD","sourcesContent":["import {decodeRGB565, GL} from '@loaders.gl/math';\n\n/* eslint-disable complexity*/\nexport function normalize3DTileColorAttribute(tile, colors, batchTable?) {\n  // no colors defined\n  if (!colors && (!tile || !tile.batchIds || !batchTable)) {\n    return null;\n  }\n\n  const {batchIds, isRGB565, pointCount} = tile;\n  // Batch table, look up colors in table\n  if (batchIds && batchTable) {\n    const colorArray = new Uint8ClampedArray(pointCount * 3);\n    for (let i = 0; i < pointCount; i++) {\n      const batchId = batchIds[i];\n      // TODO figure out what is `dimensions` used for\n      const dimensions = batchTable.getProperty(batchId, 'dimensions');\n      const color = dimensions.map((d) => d * 255);\n      colorArray[i * 3] = color[0];\n      colorArray[i * 3 + 1] = color[1];\n      colorArray[i * 3 + 2] = color[2];\n    }\n    return {\n      type: GL.UNSIGNED_BYTE,\n      value: colorArray,\n      size: 3,\n      normalized: true\n    };\n  }\n\n  // RGB565 case, convert to RGB\n  if (isRGB565) {\n    const colorArray = new Uint8ClampedArray(pointCount * 3);\n    for (let i = 0; i < pointCount; i++) {\n      const color = decodeRGB565(colors[i]);\n      colorArray[i * 3] = color[0];\n      colorArray[i * 3 + 1] = color[1];\n      colorArray[i * 3 + 2] = color[2];\n    }\n    return {\n      type: GL.UNSIGNED_BYTE,\n      value: colorArray,\n      size: 3,\n      normalized: true\n    };\n  }\n\n  // RGB case (tile.isTranslucent)\n  if (colors && colors.length === pointCount * 3) {\n    return {\n      type: GL.UNSIGNED_BYTE,\n      value: colors,\n      size: 3,\n      normalized: true\n    };\n  }\n\n  // DEFAULT: RGBA case\n  return {\n    type: GL.UNSIGNED_BYTE,\n    value: colors,\n    size: 4,\n    normalized: true\n  };\n}\n/* eslint-enable complexity*/\n"],"file":"normalize-3d-tile-colors.js"}
+{"version":3,"file":"normalize-3d-tile-colors.js","names":["decodeRGB565","GL","normalize3DTileColorAttribute","tile","colors","batchTable","batchIds","isRGB565","pointCount","colorArray","Uint8ClampedArray","i","batchId","dimensions","getProperty","color","map","d","type","UNSIGNED_BYTE","value","size","normalized","length"],"sources":["../../../../../src/lib/parsers/helpers/normalize-3d-tile-colors.ts"],"sourcesContent":["import {decodeRGB565, GL} from '@loaders.gl/math';\n\n/* eslint-disable complexity*/\nexport function normalize3DTileColorAttribute(tile, colors, batchTable?) {\n  // no colors defined\n  if (!colors && (!tile || !tile.batchIds || !batchTable)) {\n    return null;\n  }\n\n  const {batchIds, isRGB565, pointCount} = tile;\n  // Batch table, look up colors in table\n  if (batchIds && batchTable) {\n    const colorArray = new Uint8ClampedArray(pointCount * 3);\n    for (let i = 0; i < pointCount; i++) {\n      const batchId = batchIds[i];\n      // TODO figure out what is `dimensions` used for\n      const dimensions = batchTable.getProperty(batchId, 'dimensions');\n      const color = dimensions.map((d) => d * 255);\n      colorArray[i * 3] = color[0];\n      colorArray[i * 3 + 1] = color[1];\n      colorArray[i * 3 + 2] = color[2];\n    }\n    return {\n      type: GL.UNSIGNED_BYTE,\n      value: colorArray,\n      size: 3,\n      normalized: true\n    };\n  }\n\n  // RGB565 case, convert to RGB\n  if (isRGB565) {\n    const colorArray = new Uint8ClampedArray(pointCount * 3);\n    for (let i = 0; i < pointCount; i++) {\n      const color = decodeRGB565(colors[i]);\n      colorArray[i * 3] = color[0];\n      colorArray[i * 3 + 1] = color[1];\n      colorArray[i * 3 + 2] = color[2];\n    }\n    return {\n      type: GL.UNSIGNED_BYTE,\n      value: colorArray,\n      size: 3,\n      normalized: true\n    };\n  }\n\n  // RGB case (tile.isTranslucent)\n  if (colors && colors.length === pointCount * 3) {\n    return {\n      type: GL.UNSIGNED_BYTE,\n      value: colors,\n      size: 3,\n      normalized: true\n    };\n  }\n\n  // DEFAULT: RGBA case\n  return {\n    type: GL.UNSIGNED_BYTE,\n    value: colors,\n    size: 4,\n    normalized: true\n  };\n}\n/* eslint-enable complexity*/\n"],"mappings":"AAAA,SAAQA,YAAY,EAAEC,EAAE,QAAO,kBAAkB;;AAGjD,OAAO,SAASC,6BAA6B,CAACC,IAAI,EAAEC,MAAM,EAAEC,UAAW,EAAE;EAEvE,IAAI,CAACD,MAAM,KAAK,CAACD,IAAI,IAAI,CAACA,IAAI,CAACG,QAAQ,IAAI,CAACD,UAAU,CAAC,EAAE;IACvD,OAAO,IAAI;EACb;EAEA,MAAM;IAACC,QAAQ;IAAEC,QAAQ;IAAEC;EAAU,CAAC,GAAGL,IAAI;EAE7C,IAAIG,QAAQ,IAAID,UAAU,EAAE;IAC1B,MAAMI,UAAU,GAAG,IAAIC,iBAAiB,CAACF,UAAU,GAAG,CAAC,CAAC;IACxD,KAAK,IAAIG,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGH,UAAU,EAAEG,CAAC,EAAE,EAAE;MACnC,MAAMC,OAAO,GAAGN,QAAQ,CAACK,CAAC,CAAC;MAE3B,MAAME,UAAU,GAAGR,UAAU,CAACS,WAAW,CAACF,OAAO,EAAE,YAAY,CAAC;MAChE,MAAMG,KAAK,GAAGF,UAAU,CAACG,GAAG,CAAEC,CAAC,IAAKA,CAAC,GAAG,GAAG,CAAC;MAC5CR,UAAU,CAACE,CAAC,GAAG,CAAC,CAAC,GAAGI,KAAK,CAAC,CAAC,CAAC;MAC5BN,UAAU,CAACE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAGI,KAAK,CAAC,CAAC,CAAC;MAChCN,UAAU,CAACE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAGI,KAAK,CAAC,CAAC,CAAC;IAClC;IACA,OAAO;MACLG,IAAI,EAAEjB,EAAE,CAACkB,aAAa;MACtBC,KAAK,EAAEX,UAAU;MACjBY,IAAI,EAAE,CAAC;MACPC,UAAU,EAAE;IACd,CAAC;EACH;;EAGA,IAAIf,QAAQ,EAAE;IACZ,MAAME,UAAU,GAAG,IAAIC,iBAAiB,CAACF,UAAU,GAAG,CAAC,CAAC;IACxD,KAAK,IAAIG,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGH,UAAU,EAAEG,CAAC,EAAE,EAAE;MACnC,MAAMI,KAAK,GAAGf,YAAY,CAACI,MAAM,CAACO,CAAC,CAAC,CAAC;MACrCF,UAAU,CAACE,CAAC,GAAG,CAAC,CAAC,GAAGI,KAAK,CAAC,CAAC,CAAC;MAC5BN,UAAU,CAACE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAGI,KAAK,CAAC,CAAC,CAAC;MAChCN,UAAU,CAACE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAGI,KAAK,CAAC,CAAC,CAAC;IAClC;IACA,OAAO;MACLG,IAAI,EAAEjB,EAAE,CAACkB,aAAa;MACtBC,KAAK,EAAEX,UAAU;MACjBY,IAAI,EAAE,CAAC;MACPC,UAAU,EAAE;IACd,CAAC;EACH;;EAGA,IAAIlB,MAAM,IAAIA,MAAM,CAACmB,MAAM,KAAKf,UAAU,GAAG,CAAC,EAAE;IAC9C,OAAO;MACLU,IAAI,EAAEjB,EAAE,CAACkB,aAAa;MACtBC,KAAK,EAAEhB,MAAM;MACbiB,IAAI,EAAE,CAAC;MACPC,UAAU,EAAE;IACd,CAAC;EACH;;EAGA,OAAO;IACLJ,IAAI,EAAEjB,EAAE,CAACkB,aAAa;IACtBC,KAAK,EAAEhB,MAAM;IACbiB,IAAI,EAAE,CAAC;IACPC,UAAU,EAAE;EACd,CAAC;AACH"}

package/dist/esm/lib/parsers/helpers/normalize-3d-tile-normals.js

@@ -5,22 +5,18 @@ export function normalize3DTileNormalAttribute(tile, normals) {
   if (!normals) {
     return null;
   }
-
   if (tile.isOctEncoded16P) {
     const decodedArray = new Float32Array(tile.pointsLength * 3);
-
     for (let i = 0; i < tile.pointsLength; i++) {
       octDecode(normals[i * 2], normals[i * 2 + 1], scratchNormal);
       scratchNormal.toArray(decodedArray, i * 3);
     }
-
     return {
       type: GL.FLOAT,
       size: 2,
       value: decodedArray
     };
   }
-
   return {
     type: GL.FLOAT,
     size: 2,

package/dist/esm/lib/parsers/helpers/normalize-3d-tile-normals.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/lib/parsers/helpers/normalize-3d-tile-normals.ts"],"names":["Vector3","GL","octDecode","scratchNormal","normalize3DTileNormalAttribute","tile","normals","isOctEncoded16P","decodedArray","Float32Array","pointsLength","i","toArray","type","FLOAT","size","value"],"mappings":"AAAA,SAAQA,OAAR,QAAsB,eAAtB;AACA,SAAQC,EAAR,EAAYC,SAAZ,QAA4B,kBAA5B;AAEA,MAAMC,aAAa,GAAG,IAAIH,OAAJ,EAAtB;AAEA,OAAO,SAASI,8BAAT,CAAwCC,IAAxC,EAA8CC,OAA9C,EAAuD;AAC5D,MAAI,CAACA,OAAL,EAAc;AACZ,WAAO,IAAP;AACD;;AAED,MAAID,IAAI,CAACE,eAAT,EAA0B;AACxB,UAAMC,YAAY,GAAG,IAAIC,YAAJ,CAAiBJ,IAAI,CAACK,YAAL,GAAoB,CAArC,CAArB;;AACA,SAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGN,IAAI,CAACK,YAAzB,EAAuCC,CAAC,EAAxC,EAA4C;AAC1CT,MAAAA,SAAS,CAACI,OAAO,CAACK,CAAC,GAAG,CAAL,CAAR,EAAiBL,OAAO,CAACK,CAAC,GAAG,CAAJ,GAAQ,CAAT,CAAxB,EAAqCR,aAArC,CAAT;AAEAA,MAAAA,aAAa,CAACS,OAAd,CAAsBJ,YAAtB,EAAoCG,CAAC,GAAG,CAAxC;AACD;;AAED,WAAO;AACLE,MAAAA,IAAI,EAAEZ,EAAE,CAACa,KADJ;AAELC,MAAAA,IAAI,EAAE,CAFD;AAGLC,MAAAA,KAAK,EAAER;AAHF,KAAP;AAKD;;AAED,SAAO;AACLK,IAAAA,IAAI,EAAEZ,EAAE,CAACa,KADJ;AAELC,IAAAA,IAAI,EAAE,CAFD;AAGLC,IAAAA,KAAK,EAAEV;AAHF,GAAP;AAKD","sourcesContent":["import {Vector3} from '@math.gl/core';\nimport {GL, octDecode} from '@loaders.gl/math';\n\nconst scratchNormal = new Vector3();\n\nexport function normalize3DTileNormalAttribute(tile, normals) {\n  if (!normals) {\n    return null;\n  }\n\n  if (tile.isOctEncoded16P) {\n    const decodedArray = new Float32Array(tile.pointsLength * 3);\n    for (let i = 0; i < tile.pointsLength; i++) {\n      octDecode(normals[i * 2], normals[i * 2 + 1], scratchNormal);\n      // @ts-ignore\n      scratchNormal.toArray(decodedArray, i * 3);\n    }\n\n    return {\n      type: GL.FLOAT,\n      size: 2,\n      value: decodedArray\n    };\n  }\n\n  return {\n    type: GL.FLOAT,\n    size: 2,\n    value: normals\n  };\n}\n"],"file":"normalize-3d-tile-normals.js"}
+{"version":3,"file":"normalize-3d-tile-normals.js","names":["Vector3","GL","octDecode","scratchNormal","normalize3DTileNormalAttribute","tile","normals","isOctEncoded16P","decodedArray","Float32Array","pointsLength","i","toArray","type","FLOAT","size","value"],"sources":["../../../../../src/lib/parsers/helpers/normalize-3d-tile-normals.ts"],"sourcesContent":["import {Vector3} from '@math.gl/core';\nimport {GL, octDecode} from '@loaders.gl/math';\n\nconst scratchNormal = new Vector3();\n\nexport function normalize3DTileNormalAttribute(tile, normals) {\n  if (!normals) {\n    return null;\n  }\n\n  if (tile.isOctEncoded16P) {\n    const decodedArray = new Float32Array(tile.pointsLength * 3);\n    for (let i = 0; i < tile.pointsLength; i++) {\n      octDecode(normals[i * 2], normals[i * 2 + 1], scratchNormal);\n      // @ts-ignore\n      scratchNormal.toArray(decodedArray, i * 3);\n    }\n\n    return {\n      type: GL.FLOAT,\n      size: 2,\n      value: decodedArray\n    };\n  }\n\n  return {\n    type: GL.FLOAT,\n    size: 2,\n    value: normals\n  };\n}\n"],"mappings":"AAAA,SAAQA,OAAO,QAAO,eAAe;AACrC,SAAQC,EAAE,EAAEC,SAAS,QAAO,kBAAkB;AAE9C,MAAMC,aAAa,GAAG,IAAIH,OAAO,EAAE;AAEnC,OAAO,SAASI,8BAA8B,CAACC,IAAI,EAAEC,OAAO,EAAE;EAC5D,IAAI,CAACA,OAAO,EAAE;IACZ,OAAO,IAAI;EACb;EAEA,IAAID,IAAI,CAACE,eAAe,EAAE;IACxB,MAAMC,YAAY,GAAG,IAAIC,YAAY,CAACJ,IAAI,CAACK,YAAY,GAAG,CAAC,CAAC;IAC5D,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGN,IAAI,CAACK,YAAY,EAAEC,CAAC,EAAE,EAAE;MAC1CT,SAAS,CAACI,OAAO,CAACK,CAAC,GAAG,CAAC,CAAC,EAAEL,OAAO,CAACK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAER,aAAa,CAAC;MAE5DA,aAAa,CAACS,OAAO,CAACJ,YAAY,EAAEG,CAAC,GAAG,CAAC,CAAC;IAC5C;IAEA,OAAO;MACLE,IAAI,EAAEZ,EAAE,CAACa,KAAK;MACdC,IAAI,EAAE,CAAC;MACPC,KAAK,EAAER;IACT,CAAC;EACH;EAEA,OAAO;IACLK,IAAI,EAAEZ,EAAE,CAACa,KAAK;IACdC,IAAI,EAAE,CAAC;IACPC,KAAK,EAAEV;EACT,CAAC;AACH"}

package/dist/esm/lib/parsers/helpers/normalize-3d-tile-positions.js

@@ -1,5 +1,6 @@
 import { Vector3 } from '@math.gl/core';
 import { GL } from '@loaders.gl/math';
+
 export function normalize3DTilePositionAttribute(tile, positions, options) {
   if (!tile.isQuantized) {
     return positions;
@@ -21,11 +22,9 @@ export function normalize3DTilePositionAttribute(tile, positions, options) {
 function decodeQuantizedPositions(tile, positions) {
   const scratchPosition = new Vector3();
   const decodedArray = new Float32Array(tile.pointCount * 3);
-
   for (let i = 0; i < tile.pointCount; i++) {
     scratchPosition.set(positions[i * 3], positions[i * 3 + 1], positions[i * 3 + 2]).scale(1 / tile.quantizedRange).multiply(tile.quantizedVolumeScale).add(tile.quantizedVolumeOffset).toArray(decodedArray, i * 3);
   }
-
   return decodedArray;
 }
 //# sourceMappingURL=normalize-3d-tile-positions.js.map

package/dist/esm/lib/parsers/helpers/normalize-3d-tile-positions.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/lib/parsers/helpers/normalize-3d-tile-positions.ts"],"names":["Vector3","GL","normalize3DTilePositionAttribute","tile","positions","options","isQuantized","decodeQuantizedPositions","type","UNSIGNED_SHORT","value","size","normalized","scratchPosition","decodedArray","Float32Array","pointCount","i","set","scale","quantizedRange","multiply","quantizedVolumeScale","add","quantizedVolumeOffset","toArray"],"mappings":"AAAA,SAAQA,OAAR,QAAsB,eAAtB;AACA,SAAQC,EAAR,QAAiB,kBAAjB;AAGA,OAAO,SAASC,gCAAT,CAA0CC,IAA1C,EAAgDC,SAAhD,EAA2DC,OAA3D,EAAoE;AACzE,MAAI,CAACF,IAAI,CAACG,WAAV,EAAuB;AACrB,WAAOF,SAAP;AACD;;AAMD,MAAIC,OAAO,CAAC,UAAD,CAAP,IAAuBA,OAAO,CAAC,UAAD,CAAP,CAAoBE,wBAA/C,EAAyE;AACvEJ,IAAAA,IAAI,CAACG,WAAL,GAAmB,KAAnB;AACA,WAAOC,wBAAwB,CAACJ,IAAD,EAAOC,SAAP,CAA/B;AACD;;AAID,SAAO;AACLI,IAAAA,IAAI,EAAEP,EAAE,CAACQ,cADJ;AAELC,IAAAA,KAAK,EAAEN,SAFF;AAGLO,IAAAA,IAAI,EAAE,CAHD;AAILC,IAAAA,UAAU,EAAE;AAJP,GAAP;AAMD;;AAGD,SAASL,wBAAT,CAAkCJ,IAAlC,EAAwCC,SAAxC,EAAmD;AACjD,QAAMS,eAAe,GAAG,IAAIb,OAAJ,EAAxB;AACA,QAAMc,YAAY,GAAG,IAAIC,YAAJ,CAAiBZ,IAAI,CAACa,UAAL,GAAkB,CAAnC,CAArB;;AAEA,OAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGd,IAAI,CAACa,UAAzB,EAAqCC,CAAC,EAAtC,EAA0C;AAExCJ,IAAAA,eAAe,CACZK,GADH,CACOd,SAAS,CAACa,CAAC,GAAG,CAAL,CADhB,EACyBb,SAAS,CAACa,CAAC,GAAG,CAAJ,GAAQ,CAAT,CADlC,EAC+Cb,SAAS,CAACa,CAAC,GAAG,CAAJ,GAAQ,CAAT,CADxD,EAEGE,KAFH,CAES,IAAIhB,IAAI,CAACiB,cAFlB,EAGGC,QAHH,CAGYlB,IAAI,CAACmB,oBAHjB,EAIGC,GAJH,CAIOpB,IAAI,CAACqB,qBAJZ,EAKGC,OALH,CAKWX,YALX,EAKyBG,CAAC,GAAG,CAL7B;AAMD;;AAED,SAAOH,YAAP;AACD","sourcesContent":["import {Vector3} from '@math.gl/core';\nimport {GL} from '@loaders.gl/math';\n\n// Prepare attribute for positions\nexport function normalize3DTilePositionAttribute(tile, positions, options) {\n  if (!tile.isQuantized) {\n    return positions;\n  }\n\n  // For quantized posititions, either expand to Float32Array or return custom accessor\n  // https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/TileFormats/Instanced3DModel/README.md#quantized-positions\n\n  // Optionally decodes quantized positions on GPU, for simpler renderers that don't accept normalized attributes\n  if (options['3d-tiles'] && options['3d-tiles'].decodeQuantizedPositions) {\n    tile.isQuantized = false;\n    return decodeQuantizedPositions(tile, positions);\n  }\n\n  // Default: Use normalized shorts directly, no copying/processing.\n  // NOTE: The \"missing\" offset/scaling operations are automatically added to modelMatrix if `tile.isQuantized === true`\n  return {\n    type: GL.UNSIGNED_SHORT,\n    value: positions,\n    size: 3,\n    normalized: true\n  };\n}\n\n// Pre-scale quantized positions on CPU\nfunction decodeQuantizedPositions(tile, positions) {\n  const scratchPosition = new Vector3();\n  const decodedArray = new Float32Array(tile.pointCount * 3);\n\n  for (let i = 0; i < tile.pointCount; i++) {\n    // POSITION = POSITION_QUANTIZED / 65535.0 * QUANTIZED_VOLUME_SCALE + QUANTIZED_VOLUME_OFFSET\n    scratchPosition\n      .set(positions[i * 3], positions[i * 3 + 1], positions[i * 3 + 2])\n      .scale(1 / tile.quantizedRange)\n      .multiply(tile.quantizedVolumeScale)\n      .add(tile.quantizedVolumeOffset)\n      .toArray(decodedArray, i * 3);\n  }\n\n  return decodedArray;\n}\n"],"file":"normalize-3d-tile-positions.js"}
+{"version":3,"file":"normalize-3d-tile-positions.js","names":["Vector3","GL","normalize3DTilePositionAttribute","tile","positions","options","isQuantized","decodeQuantizedPositions","type","UNSIGNED_SHORT","value","size","normalized","scratchPosition","decodedArray","Float32Array","pointCount","i","set","scale","quantizedRange","multiply","quantizedVolumeScale","add","quantizedVolumeOffset","toArray"],"sources":["../../../../../src/lib/parsers/helpers/normalize-3d-tile-positions.ts"],"sourcesContent":["import {Vector3} from '@math.gl/core';\nimport {GL} from '@loaders.gl/math';\n\n// Prepare attribute for positions\nexport function normalize3DTilePositionAttribute(tile, positions, options) {\n  if (!tile.isQuantized) {\n    return positions;\n  }\n\n  // For quantized posititions, either expand to Float32Array or return custom accessor\n  // https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/TileFormats/Instanced3DModel/README.md#quantized-positions\n\n  // Optionally decodes quantized positions on GPU, for simpler renderers that don't accept normalized attributes\n  if (options['3d-tiles'] && options['3d-tiles'].decodeQuantizedPositions) {\n    tile.isQuantized = false;\n    return decodeQuantizedPositions(tile, positions);\n  }\n\n  // Default: Use normalized shorts directly, no copying/processing.\n  // NOTE: The \"missing\" offset/scaling operations are automatically added to modelMatrix if `tile.isQuantized === true`\n  return {\n    type: GL.UNSIGNED_SHORT,\n    value: positions,\n    size: 3,\n    normalized: true\n  };\n}\n\n// Pre-scale quantized positions on CPU\nfunction decodeQuantizedPositions(tile, positions) {\n  const scratchPosition = new Vector3();\n  const decodedArray = new Float32Array(tile.pointCount * 3);\n\n  for (let i = 0; i < tile.pointCount; i++) {\n    // POSITION = POSITION_QUANTIZED / 65535.0 * QUANTIZED_VOLUME_SCALE + QUANTIZED_VOLUME_OFFSET\n    scratchPosition\n      .set(positions[i * 3], positions[i * 3 + 1], positions[i * 3 + 2])\n      .scale(1 / tile.quantizedRange)\n      .multiply(tile.quantizedVolumeScale)\n      .add(tile.quantizedVolumeOffset)\n      .toArray(decodedArray, i * 3);\n  }\n\n  return decodedArray;\n}\n"],"mappings":"AAAA,SAAQA,OAAO,QAAO,eAAe;AACrC,SAAQC,EAAE,QAAO,kBAAkB;;AAGnC,OAAO,SAASC,gCAAgC,CAACC,IAAI,EAAEC,SAAS,EAAEC,OAAO,EAAE;EACzE,IAAI,CAACF,IAAI,CAACG,WAAW,EAAE;IACrB,OAAOF,SAAS;EAClB;;EAMA,IAAIC,OAAO,CAAC,UAAU,CAAC,IAAIA,OAAO,CAAC,UAAU,CAAC,CAACE,wBAAwB,EAAE;IACvEJ,IAAI,CAACG,WAAW,GAAG,KAAK;IACxB,OAAOC,wBAAwB,CAACJ,IAAI,EAAEC,SAAS,CAAC;EAClD;;EAIA,OAAO;IACLI,IAAI,EAAEP,EAAE,CAACQ,cAAc;IACvBC,KAAK,EAAEN,SAAS;IAChBO,IAAI,EAAE,CAAC;IACPC,UAAU,EAAE;EACd,CAAC;AACH;;AAGA,SAASL,wBAAwB,CAACJ,IAAI,EAAEC,SAAS,EAAE;EACjD,MAAMS,eAAe,GAAG,IAAIb,OAAO,EAAE;EACrC,MAAMc,YAAY,GAAG,IAAIC,YAAY,CAACZ,IAAI,CAACa,UAAU,GAAG,CAAC,CAAC;EAE1D,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGd,IAAI,CAACa,UAAU,EAAEC,CAAC,EAAE,EAAE;IAExCJ,eAAe,CACZK,GAAG,CAACd,SAAS,CAACa,CAAC,GAAG,CAAC,CAAC,EAAEb,SAAS,CAACa,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAEb,SAAS,CAACa,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CACjEE,KAAK,CAAC,CAAC,GAAGhB,IAAI,CAACiB,cAAc,CAAC,CAC9BC,QAAQ,CAAClB,IAAI,CAACmB,oBAAoB,CAAC,CACnCC,GAAG,CAACpB,IAAI,CAACqB,qBAAqB,CAAC,CAC/BC,OAAO,CAACX,YAAY,EAAEG,CAAC,GAAG,CAAC,CAAC;EACjC;EAEA,OAAOH,YAAY;AACrB"}

package/dist/esm/lib/parsers/helpers/parse-3d-implicit-tiles.js

@@ -6,6 +6,7 @@ const SUBDIVISION_COUNT_MAP = {
   QUADTREE: QUADTREE_DEVISION_COUNT,
   OCTREE: OCTREE_DEVISION_COUNT
 };
+
 export async function parseImplicitTiles(params) {
   const {
     options,
@@ -48,20 +49,18 @@ export async function parseImplicitTiles(params) {
   const levelOffset = (childrenPerTile ** level - 1) / (childrenPerTile - 1);
   let childTileMortonIndex = concatBits(parentData.mortonIndex, childIndex);
   let tileAvailabilityIndex = levelOffset + childTileMortonIndex;
+
   let childTileX = concatBits(parentData.x, childX);
   let childTileY = concatBits(parentData.y, childY);
   let childTileZ = concatBits(parentData.z, childZ);
   let isChildSubtreeAvailable = false;
-
   if (level + 1 > subtreeLevels) {
     isChildSubtreeAvailable = getAvailabilityResult(subtree.childSubtreeAvailability, childTileMortonIndex);
   }
-
   const x = concatBits(globalData.x, childTileX);
   const y = concatBits(globalData.y, childTileY);
   const z = concatBits(globalData.z, childTileZ);
   const lev = level + globalData.level;
-
   if (isChildSubtreeAvailable) {
     const subtreePath = "".concat(basePath, "/").concat(subtreesUriTemplate);
     const childSubtreeUrl = replaceContentUrlTemplate(subtreePath, lev, x, y, z);
@@ -79,19 +78,14 @@ export async function parseImplicitTiles(params) {
     childTileZ = 0;
     level = 0;
   }
-
   const isTileAvailable = getAvailabilityResult(subtree.tileAvailability, tileAvailabilityIndex);
-
   if (!isTileAvailable || level > maximumLevel) {
     return tile;
   }
-
   const isContentAvailable = getAvailabilityResult(subtree.contentAvailability, tileAvailabilityIndex);
-
   if (isContentAvailable) {
     tile.contentUrl = replaceContentUrlTemplate(contentUrlTemplate, lev, x, y, z);
   }
-
   const childTileLevel = level + 1;
   const pData = {
     mortonIndex: childTileMortonIndex,
@@ -99,7 +93,6 @@ export async function parseImplicitTiles(params) {
     y: childTileY,
     z: childTileZ
   };
-
   for (let index = 0; index < childrenPerTile; index++) {
     const currentTile = await parseImplicitTiles({
       subtree,
@@ -109,7 +102,6 @@ export async function parseImplicitTiles(params) {
       level: childTileLevel,
       globalData
     });
-
     if (currentTile.contentUrl || currentTile.children.length) {
       const globalLevel = lev + 1;
       const childCoordinates = {
@@ -121,19 +113,15 @@ export async function parseImplicitTiles(params) {
       tile.children.push(formattedTile);
     }
   }
-
   return tile;
 }
-
 function getAvailabilityResult(availabilityData, index) {
   if ('constant' in availabilityData) {
     return Boolean(availabilityData.constant);
   }
-
   if (availabilityData.explicitBitstream) {
     return getBooleanValueFromBitstream(index, availabilityData.explicitBitstream);
   }
-
   return false;
 }
 
@@ -207,11 +195,9 @@ export function replaceContentUrlTemplate(templateUrl, level, x, y, z) {
 
 function generateMapUrl(items) {
   const mapUrl = {};
-
   for (const key in items) {
     mapUrl["{".concat(key, "}")] = items[key];
   }
-
   return mapUrl;
 }