@loaders.gl/3d-tiles 4.0.0-alpha.4 → 4.0.0-alpha.6

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

@@ -0,0 +1,40 @@
+import { padToNBytes, copyBinaryToDataView, copyPaddedStringToDataView } from '@loaders.gl/loader-utils';
+import { MAGIC_ARRAY } from '../constants';
+import { encode3DTileHeader, encode3DTileByteLength } from './helpers/encode-3d-tile-header';
+export function encodeBatchedModel3DTile(tile, dataView, byteOffset, options) {
+  const {
+    featuresLength = 0,
+    batchTable
+  } = tile;
+  const featureTableJson = {
+    BATCH_LENGTH: featuresLength
+  };
+  const featureTableJsonString = JSON.stringify(featureTableJson);
+  const batchTableJsonString = batchTable ? JSON.stringify(batchTable) : '';
+  const featureTableJsonByteLength = padToNBytes(featureTableJsonString.length, 8);
+  const batchTableJsonByteLength = batchTableJsonString ? padToNBytes(batchTableJsonString.length, 8) : 0;
+  tile = {
+    magic: MAGIC_ARRAY.BATCHED_MODEL,
+    ...tile
+  };
+  const byteOffsetStart = byteOffset;
+  byteOffset = encode3DTileHeader(tile, dataView, byteOffset);
+  if (dataView) {
+    dataView.setUint32(12, featureTableJsonByteLength, true);
+    dataView.setUint32(16, 0, true);
+    dataView.setUint32(20, batchTableJsonByteLength, true);
+    dataView.setUint32(24, 0, true);
+  }
+  byteOffset += 16;
+  byteOffset = copyPaddedStringToDataView(dataView, byteOffset, featureTableJsonString, 8);
+  if (batchTable) {
+    byteOffset = copyPaddedStringToDataView(dataView, byteOffset, batchTableJsonString, 8);
+  }
+  const gltfEncoded = tile.gltfEncoded;
+  if (gltfEncoded) {
+    byteOffset = copyBinaryToDataView(dataView, byteOffset, gltfEncoded, gltfEncoded.byteLength);
+  }
+  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
+  return byteOffset;
+}
+//# sourceMappingURL=encode-3d-tile-batched-model.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encode-3d-tile-batched-model.js","names":["padToNBytes","copyBinaryToDataView","copyPaddedStringToDataView","MAGIC_ARRAY","encode3DTileHeader","encode3DTileByteLength","encodeBatchedModel3DTile","tile","dataView","byteOffset","options","featuresLength","batchTable","featureTableJson","BATCH_LENGTH","featureTableJsonString","JSON","stringify","batchTableJsonString","featureTableJsonByteLength","length","batchTableJsonByteLength","magic","BATCHED_MODEL","byteOffsetStart","setUint32","gltfEncoded","byteLength"],"sources":["../../../../src/lib/encoders/encode-3d-tile-batched-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 {\n  padToNBytes,\n  copyBinaryToDataView,\n  copyPaddedStringToDataView\n} 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 dataView for testing purposes\nexport function encodeBatchedModel3DTile(tile, dataView, byteOffset, options) {\n  const {featuresLength = 0, batchTable} = tile;\n\n  const featureTableJson = {\n    BATCH_LENGTH: featuresLength\n  };\n  const featureTableJsonString = JSON.stringify(featureTableJson);\n  const batchTableJsonString = batchTable ? JSON.stringify(batchTable) : '';\n  const featureTableJsonByteLength = padToNBytes(featureTableJsonString.length, 8);\n  const batchTableJsonByteLength = batchTableJsonString\n    ? padToNBytes(batchTableJsonString.length, 8)\n    : 0;\n\n  // Add default magic for this tile type\n  tile = {magic: MAGIC_ARRAY.BATCHED_MODEL, ...tile};\n\n  const byteOffsetStart = byteOffset;\n\n  byteOffset = encode3DTileHeader(tile, dataView, byteOffset);\n\n  if (dataView) {\n    dataView.setUint32(12, featureTableJsonByteLength, true); // featureTableJsonByteLength\n    dataView.setUint32(16, 0, true); // featureTableBinaryByteLength\n    dataView.setUint32(20, batchTableJsonByteLength, true); // batchTableJsonByteLength\n    dataView.setUint32(24, 0, true); // batchTableBinaryByteLength\n  }\n  byteOffset += 16;\n\n  // TODO feature table binary\n  byteOffset = copyPaddedStringToDataView(dataView, byteOffset, featureTableJsonString, 8);\n\n  if (batchTable) {\n    byteOffset = copyPaddedStringToDataView(dataView, byteOffset, batchTableJsonString, 8);\n  }\n\n  // Add encoded GLTF to the end of data\n  const gltfEncoded = tile.gltfEncoded;\n  if (gltfEncoded) {\n    byteOffset = copyBinaryToDataView(dataView, byteOffset, gltfEncoded, gltfEncoded.byteLength);\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,SACEA,WAAW,EACXC,oBAAoB,EACpBC,0BAA0B,QACrB,0BAA0B;AACjC,SAAQC,WAAW,QAAO,cAAc;AACxC,SAAQC,kBAAkB,EAAEC,sBAAsB,QAAO,iCAAiC;AAG1F,OAAO,SAASC,wBAAwBA,CAACC,IAAI,EAAEC,QAAQ,EAAEC,UAAU,EAAEC,OAAO,EAAE;EAC5E,MAAM;IAACC,cAAc,GAAG,CAAC;IAAEC;EAAU,CAAC,GAAGL,IAAI;EAE7C,MAAMM,gBAAgB,GAAG;IACvBC,YAAY,EAAEH;EAChB,CAAC;EACD,MAAMI,sBAAsB,GAAGC,IAAI,CAACC,SAAS,CAACJ,gBAAgB,CAAC;EAC/D,MAAMK,oBAAoB,GAAGN,UAAU,GAAGI,IAAI,CAACC,SAAS,CAACL,UAAU,CAAC,GAAG,EAAE;EACzE,MAAMO,0BAA0B,GAAGnB,WAAW,CAACe,sBAAsB,CAACK,MAAM,EAAE,CAAC,CAAC;EAChF,MAAMC,wBAAwB,GAAGH,oBAAoB,GACjDlB,WAAW,CAACkB,oBAAoB,CAACE,MAAM,EAAE,CAAC,CAAC,GAC3C,CAAC;EAGLb,IAAI,GAAG;IAACe,KAAK,EAAEnB,WAAW,CAACoB,aAAa;IAAE,GAAGhB;EAAI,CAAC;EAElD,MAAMiB,eAAe,GAAGf,UAAU;EAElCA,UAAU,GAAGL,kBAAkB,CAACG,IAAI,EAAEC,QAAQ,EAAEC,UAAU,CAAC;EAE3D,IAAID,QAAQ,EAAE;IACZA,QAAQ,CAACiB,SAAS,CAAC,EAAE,EAAEN,0BAA0B,EAAE,IAAI,CAAC;IACxDX,QAAQ,CAACiB,SAAS,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,CAAC;IAC/BjB,QAAQ,CAACiB,SAAS,CAAC,EAAE,EAAEJ,wBAAwB,EAAE,IAAI,CAAC;IACtDb,QAAQ,CAACiB,SAAS,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,CAAC;EACjC;EACAhB,UAAU,IAAI,EAAE;EAGhBA,UAAU,GAAGP,0BAA0B,CAACM,QAAQ,EAAEC,UAAU,EAAEM,sBAAsB,EAAE,CAAC,CAAC;EAExF,IAAIH,UAAU,EAAE;IACdH,UAAU,GAAGP,0BAA0B,CAACM,QAAQ,EAAEC,UAAU,EAAES,oBAAoB,EAAE,CAAC,CAAC;EACxF;EAGA,MAAMQ,WAAW,GAAGnB,IAAI,CAACmB,WAAW;EACpC,IAAIA,WAAW,EAAE;IACfjB,UAAU,GAAGR,oBAAoB,CAACO,QAAQ,EAAEC,UAAU,EAAEiB,WAAW,EAAEA,WAAW,CAACC,UAAU,CAAC;EAC9F;EAGAtB,sBAAsB,CAACG,QAAQ,EAAEgB,eAAe,EAAEf,UAAU,GAAGe,eAAe,CAAC;EAE/E,OAAOf,UAAU;AACnB"}

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

@@ -0,0 +1,21 @@
+import { MAGIC_ARRAY } from '../constants';
+import { encode3DTileHeader, encode3DTileByteLength } from './helpers/encode-3d-tile-header';
+export function encodeComposite3DTile(tile, dataView, byteOffset, options, encode3DTile) {
+  tile = {
+    magic: MAGIC_ARRAY.COMPOSITE,
+    tiles: [],
+    ...tile
+  };
+  const byteOffsetStart = byteOffset;
+  byteOffset += encode3DTileHeader(tile, dataView, byteOffset);
+  if (dataView) {
+    dataView.setUint32(byteOffset, tile.tiles.length, true);
+  }
+  byteOffset += 4;
+  for (let i = 0; i < tile.tiles.length; ++i) {
+    byteOffset += encode3DTile(tile.tiles[i], dataView, byteOffset, options);
+  }
+  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
+  return byteOffset;
+}
+//# sourceMappingURL=encode-3d-tile-composite.js.map

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

@@ -0,0 +1 @@
+{"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,qBAAqBA,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

@@ -0,0 +1,36 @@
+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,
+    gltfFormat = 1,
+    gltfUri = ''
+  } = tile;
+  const gltfUriByteLength = gltfUri.length;
+  const featureTableJson = {
+    INSTANCES_LENGTH: featuresLength,
+    POSITION: new Array(featuresLength * 3).fill(0)
+  };
+  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);
+    dataView.setUint32(20, 0, true);
+    dataView.setUint32(24, 0, true);
+    dataView.setUint32(28, gltfFormat, true);
+  }
+  byteOffset += 20;
+  byteOffset += copyStringToDataView(dataView, byteOffset, featureTableJsonString, featureTableJsonByteLength);
+  byteOffset += copyStringToDataView(dataView, byteOffset, gltfUri, gltfUriByteLength);
+  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
+  return byteOffset;
+}
+//# sourceMappingURL=encode-3d-tile-instanced-model.js.map

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

@@ -0,0 +1 @@
+{"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,0BAA0BA,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,0BACF,CAAC;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

@@ -0,0 +1,39 @@
+import { MAGIC_ARRAY } from '../constants';
+import { encode3DTileHeader, encode3DTileByteLength } from './helpers/encode-3d-tile-header';
+import { padStringToByteAlignment, copyStringToDataView, copyBinaryToDataView } from '@loaders.gl/loader-utils';
+const DEFAULT_FEATURE_TABLE_JSON = {
+  POINTS_LENGTH: 1,
+  POSITIONS: {
+    byteOffset: 0
+  }
+};
+export function encodePointCloud3DTile(tile, dataView, byteOffset, options) {
+  const {
+    featureTableJson = DEFAULT_FEATURE_TABLE_JSON
+  } = tile;
+  let featureTableJsonString = JSON.stringify(featureTableJson);
+  featureTableJsonString = padStringToByteAlignment(featureTableJsonString, 4);
+  const {
+    featureTableJsonByteLength = featureTableJsonString.length
+  } = 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);
+    dataView.setUint32(byteOffset + 8, 0, true);
+    dataView.setUint32(byteOffset + 12, 0, true);
+  }
+  byteOffset += 16;
+  byteOffset += copyStringToDataView(dataView, byteOffset, featureTableJsonString, featureTableJsonByteLength);
+  byteOffset += copyBinaryToDataView(dataView, byteOffset, featureTableBinary, featureTableBinaryByteLength);
+  encode3DTileByteLength(dataView, byteOffsetStart, byteOffset - byteOffsetStart);
+  return byteOffset;
+}
+//# sourceMappingURL=encode-3d-tile-point-cloud.js.map

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

@@ -0,0 +1 @@
+{"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,sBAAsBA,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,0BACF,CAAC;EACDT,UAAU,IAAIJ,oBAAoB,CAChCO,QAAQ,EACRH,UAAU,EACVW,kBAAkB,EAClBE,4BACF,CAAC;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

@@ -0,0 +1,29 @@
+import { TILE3D_TYPE } from '../constants';
+import { assert } from '@loaders.gl/loader-utils';
+import { encodeComposite3DTile } from './encode-3d-tile-composite';
+import { encodeBatchedModel3DTile } from './encode-3d-tile-batched-model';
+import { encodeInstancedModel3DTile } from './encode-3d-tile-instanced-model';
+import { encodePointCloud3DTile } from './encode-3d-tile-point-cloud';
+export default function encode3DTile(tile, options) {
+  const byteLength = encode3DTileToDataView(tile, null, 0, options);
+  const arrayBuffer = new ArrayBuffer(byteLength);
+  const dataView = new DataView(arrayBuffer);
+  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');
+  }
+}
+//# sourceMappingURL=encode-3d-tile.js.map

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

@@ -0,0 +1 @@
+{"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,YAAYA,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,sBAAsBA,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;EAClD;AACF"}

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

@@ -0,0 +1,28 @@
+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,
+    byteLength = 12
+  } = tile;
+  assert(Array.isArray(magic) && Number.isFinite(version) && Number.isFinite(byteLength));
+  dataView.setUint8(byteOffset + 0, magic[0]);
+  dataView.setUint8(byteOffset + 1, magic[1]);
+  dataView.setUint8(byteOffset + 2, magic[2]);
+  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

@@ -0,0 +1 @@
+{"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,kBAAkBA,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,sBAAsBA,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

@@ -0,0 +1,70 @@
+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;
+      }
+    }
+  }
+  const ionAssetMetadata = await getIonAssetMetadata(accessToken, assetId);
+  const {
+    type,
+    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;
+  const headers = {
+    Authorization: "Bearer ".concat(accessToken)
+  };
+  const response = await fetchFile(url, {
+    fetch: {
+      headers
+    }
+  });
+  if (!response.ok) {
+    throw new Error(response.statusText);
+  }
+  return await response.json();
+}
+export async function getIonAssetMetadata(accessToken, assetId) {
+  assert(accessToken, assetId);
+  const headers = {
+    Authorization: "Bearer ".concat(accessToken)
+  };
+  const url = "".concat(CESIUM_ION_URL, "/").concat(assetId);
+  let response = await fetchFile("".concat(url), {
+    fetch: {
+      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,
+    ...tilesetInfo
+  };
+  return metadata;
+}
+//# sourceMappingURL=ion.js.map

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

@@ -0,0 +1 @@
+{"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","concat","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,qBAAqBA,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,YAAAC,MAAA,CAAYL,gBAAgB,CAACR,WAAW;EACvD,CAAC;EACD,OAAOQ,gBAAgB;AACzB;AAGA,OAAO,eAAeL,YAAYA,CAACH,WAAW,EAAE;EAC9CH,MAAM,CAACG,WAAW,CAAC;EACnB,MAAMU,GAAG,GAAGZ,cAAc;EAC1B,MAAMa,OAAO,GAAG;IAACC,aAAa,YAAAC,MAAA,CAAYb,WAAW;EAAE,CAAC;EACxD,MAAMc,QAAQ,GAAG,MAAMlB,SAAS,CAACc,GAAG,EAAE;IAACK,KAAK,EAAE;MAACJ;IAAO;EAAC,CAAC,CAAC;EACzD,IAAI,CAACG,QAAQ,CAACE,EAAE,EAAE;IAChB,MAAM,IAAIC,KAAK,CAACH,QAAQ,CAACI,UAAU,CAAC;EACtC;EACA,OAAO,MAAMJ,QAAQ,CAACK,IAAI,CAAC,CAAC;AAC9B;AAGA,OAAO,eAAeV,mBAAmBA,CAACT,WAAW,EAAEC,OAAO,EAAE;EAC9DJ,MAAM,CAACG,WAAW,EAAEC,OAAO,CAAC;EAC5B,MAAMU,OAAO,GAAG;IAACC,aAAa,YAAAC,MAAA,CAAYb,WAAW;EAAE,CAAC;EAExD,MAAMU,GAAG,MAAAG,MAAA,CAAMf,cAAc,OAAAe,MAAA,CAAIZ,OAAO,CAAE;EAG1C,IAAIa,QAAQ,GAAG,MAAMlB,SAAS,IAAAiB,MAAA,CAAIH,GAAG,GAAI;IAACK,KAAK,EAAE;MAACJ;IAAO;EAAC,CAAC,CAAC;EAC5D,IAAI,CAACG,QAAQ,CAACE,EAAE,EAAE;IAChB,MAAM,IAAIC,KAAK,CAACH,QAAQ,CAACI,UAAU,CAAC;EACtC;EACA,IAAIE,QAAQ,GAAG,MAAMN,QAAQ,CAACK,IAAI,CAAC,CAAC;EAIpCL,QAAQ,GAAG,MAAMlB,SAAS,IAAAiB,MAAA,CAAIH,GAAG,gBAAa;IAACK,KAAK,EAAE;MAACJ;IAAO;EAAC,CAAC,CAAC;EACjE,IAAI,CAACG,QAAQ,CAACE,EAAE,EAAE;IAChB,MAAM,IAAIC,KAAK,CAACH,QAAQ,CAACI,UAAU,CAAC;EACtC;EACA,MAAMG,WAAW,GAAG,MAAMP,QAAQ,CAACK,IAAI,CAAC,CAAC;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

@@ -0,0 +1,58 @@
+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');
+      const color = dimensions.map(d => d * 255);
+      colorArray[i * 3] = color[0];
+      colorArray[i * 3 + 1] = color[1];
+      colorArray[i * 3 + 2] = color[2];
+    }
+    return {
+      type: GL.UNSIGNED_BYTE,
+      value: colorArray,
+      size: 3,
+      normalized: true
+    };
+  }
+  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,
+      size: 3,
+      normalized: true
+    };
+  }
+  if (colors && colors.length === pointCount * 3) {
+    return {
+      type: GL.UNSIGNED_BYTE,
+      value: colors,
+      size: 3,
+      normalized: true
+    };
+  }
+  return {
+    type: GL.UNSIGNED_BYTE,
+    value: colors,
+    size: 4,
+    normalized: true
+  };
+}
+//# sourceMappingURL=normalize-3d-tile-colors.js.map

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

@@ -0,0 +1 @@
+{"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,6BAA6BA,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

@@ -0,0 +1,26 @@
+import { Vector3 } from '@math.gl/core';
+import { GL, octDecode } from '@loaders.gl/math';
+const scratchNormal = new Vector3();
+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,
+    value: normals
+  };
+}
+//# sourceMappingURL=normalize-3d-tile-normals.js.map

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

@@ -0,0 +1 @@
+{"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,CAAC,CAAC;AAEnC,OAAO,SAASI,8BAA8BA,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

@@ -0,0 +1,26 @@
+import { Vector3 } from '@math.gl/core';
+import { GL } from '@loaders.gl/math';
+export function normalize3DTilePositionAttribute(tile, positions, options) {
+  if (!tile.isQuantized) {
+    return positions;
+  }
+  if (options['3d-tiles'] && options['3d-tiles'].decodeQuantizedPositions) {
+    tile.isQuantized = false;
+    return decodeQuantizedPositions(tile, positions);
+  }
+  return {
+    type: GL.UNSIGNED_SHORT,
+    value: positions,
+    size: 3,
+    normalized: true
+  };
+}
+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

@@ -0,0 +1 @@
+{"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,gCAAgCA,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,wBAAwBA,CAACJ,IAAI,EAAEC,SAAS,EAAE;EACjD,MAAMS,eAAe,GAAG,IAAIb,OAAO,CAAC,CAAC;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"}