itowns 2.43.2-next.2 → 2.43.2-next.21

package/lib/Layer/LabelLayer.js

@@ -195,11 +195,9 @@ class LabelLayer extends GeometryLayer {
   set visible(value) {
     super.visible = value;
     if (value) {
-      var _this$domElement;
-      (_this$domElement = this.domElement) === null || _this$domElement === void 0 ? void 0 : _this$domElement.show();
+      this.domElement?.show();
     } else {
-      var _this$domElement2;
-      (_this$domElement2 = this.domElement) === null || _this$domElement2 === void 0 ? void 0 : _this$domElement2.hide();
+      this.domElement?.hide();
     }
   }
   get submittedLabelNodes() {
@@ -231,16 +229,15 @@ class LabelLayer extends GeometryLayer {
     coord.crs = data.crs;
     context.setZoom(extent.zoom);
     data.features.forEach(f => {
-      var _f$style, _f$style$text, _f$style2, _f$style2$point;
       // TODO: add support for LINE and POLYGON
       if (f.type !== FEATURE_TYPES.POINT) {
         return;
       }
       context.setFeature(f);
-      const featureField = (_f$style = f.style) === null || _f$style === void 0 ? void 0 : (_f$style$text = _f$style.text) === null || _f$style$text === void 0 ? void 0 : _f$style$text.field;
+      const featureField = f.style?.text?.field;
 
       // determine if altitude style is specified by the user
-      const altitudeStyle = (_f$style2 = f.style) === null || _f$style2 === void 0 ? void 0 : (_f$style2$point = _f$style2.point) === null || _f$style2$point === void 0 ? void 0 : _f$style2$point.base_altitude;
+      const altitudeStyle = f.style?.point?.base_altitude;
       const isDefaultElevationStyle = altitudeStyle instanceof Function && altitudeStyle.name == 'baseAltitudeDefault';
 
       // determine if the altitude needs update with ElevationLayer
@@ -292,19 +289,14 @@ class LabelLayer extends GeometryLayer {
     this.toHide.add(labelsNode);
   }
   #findClosestDomElement(node) {
-    var _node$parent;
-    if ((_node$parent = node.parent) !== null && _node$parent !== void 0 && _node$parent.isTileMesh) {
-      var _node$parent$link$thi;
-      return ((_node$parent$link$thi = node.parent.link[this.id]) === null || _node$parent$link$thi === void 0 ? void 0 : _node$parent$link$thi.domElements) || this.#findClosestDomElement(node.parent);
+    if (node.parent?.isTileMesh) {
+      return node.parent.link[this.id]?.domElements || this.#findClosestDomElement(node.parent);
     } else {
       return this.domElement;
     }
   }
   #hasLabelChildren(object) {
-    return object.children.every(c => {
-      var _c$layerUpdateState$t;
-      return c.layerUpdateState && ((_c$layerUpdateState$t = c.layerUpdateState[this.id]) === null || _c$layerUpdateState$t === void 0 ? void 0 : _c$layerUpdateState$t.hasFinished());
-    });
+    return object.children.every(c => c.layerUpdateState && c.layerUpdateState[this.id]?.hasFinished());
   }
 
   // Remove all labels invisible with pre-culling with screen grid
@@ -439,8 +431,7 @@ class LabelLayer extends GeometryLayer {
     this.removeNodeDomElement(node);
   }
   removeNodeDomElement(node) {
-    var _node$link$this$id;
-    if ((_node$link$this$id = node.link[this.id]) !== null && _node$link$this$id !== void 0 && _node$link$this$id.domElements) {
+    if (node.link[this.id]?.domElements) {
       const child = node.link[this.id].domElements.dom;
       child.parentElement.removeChild(child);
       delete node.link[this.id].domElements;

package/lib/Layer/Layer.js

@@ -66,6 +66,7 @@ class Layer extends THREE.EventDispatcher {
    * @param {boolean} [config.addLabelLayer.performance=false] - In case label layer adding, so remove labels that have no chance of being visible.
    * Indeed, even in the best case, labels will never be displayed. By example, if there's many labels.
    * @param {boolean} [config.addLabelLayer.forceClampToTerrain=false] - use elevation layer to clamp label on terrain.
+   * @param {number} [config.subdivisionThreshold=256] - set the texture size and, if applied to the globe, affects the tile subdivision.
    *
    * @example
    * // Add and create a new Layer
@@ -100,8 +101,7 @@ class Layer extends THREE.EventDispatcher {
     super();
     this.isLayer = true;
     if (config.style && !(config.style instanceof Style)) {
-      var _config$style$fill;
-      if (typeof ((_config$style$fill = config.style.fill) === null || _config$style$fill === void 0 ? void 0 : _config$style$fill.pattern) === 'string') {
+      if (typeof config.style.fill?.pattern === 'string') {
         console.warn('Using style.fill.pattern = { source: Img|url } is adviced');
         config.style.fill.pattern = {
           source: config.style.fill.pattern
@@ -110,6 +110,8 @@ class Layer extends THREE.EventDispatcher {
       config.style = new Style(config.style);
     }
     this.style = config.style || new Style();
+    this.subdivisionThreshold = config.subdivisionThreshold || 256;
+    this.sizeDiagonalTexture = (2 * (this.subdivisionThreshold * this.subdivisionThreshold)) ** 0.5;
     Object.assign(this, config);
     Object.defineProperty(this, 'id', {
       value: id,

package/lib/Layer/PointCloudLayer.js

@@ -73,16 +73,13 @@ function markForDeletion(elt) {
   }
 }
 function changeIntensityRange(layer) {
-  var _layer$material$inten;
-  (_layer$material$inten = layer.material.intensityRange) === null || _layer$material$inten === void 0 ? void 0 : _layer$material$inten.set(layer.minIntensityRange, layer.maxIntensityRange);
+  layer.material.intensityRange?.set(layer.minIntensityRange, layer.maxIntensityRange);
 }
 function changeElevationRange(layer) {
-  var _layer$material$eleva;
-  (_layer$material$eleva = layer.material.elevationRange) === null || _layer$material$eleva === void 0 ? void 0 : _layer$material$eleva.set(layer.minElevationRange, layer.maxElevationRange);
+  layer.material.elevationRange?.set(layer.minElevationRange, layer.maxElevationRange);
 }
 function changeAngleRange(layer) {
-  var _layer$material$angle;
-  (_layer$material$angle = layer.material.angleRange) === null || _layer$material$angle === void 0 ? void 0 : _layer$material$angle.set(layer.minAngleRange, layer.maxAngleRange);
+  layer.material.angleRange?.set(layer.minAngleRange, layer.maxAngleRange);
 }
 
 /**
@@ -137,7 +134,7 @@ class PointCloudLayer extends GeometryLayer {
    */
   constructor(id) {
     let config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    super(id, new THREE.Group(), config);
+    super(id, config.object3d || new THREE.Group(), config);
     this.isPointCloudLayer = true;
     this.protocol = 'pointcloud';
     this.group = config.group || new THREE.Group();
@@ -176,7 +173,7 @@ class PointCloudLayer extends GeometryLayer {
     if (this.material) {
       this.material.visible = this.visible;
       this.material.opacity = this.opacity;
-      this.material.transparent = this.opacity < 1;
+      this.material.transparent = this.opacity < 1 || this.material.userData.needTransparency[this.material.mode];
       this.material.size = this.pointSize;
       this.material.scale = context.camera.preSSE;
       if (this.material.updateUniforms) {

package/lib/Layer/Potree2Layer.js

@@ -0,0 +1,165 @@
+/*
+============
+== POTREE ==
+============
+
+http://potree.org
+
+Copyright (c) 2011-2020, Markus Schütz
+All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    The views and conclusions contained in the software and documentation are those
+of the authors and should not be interpreted as representing official policies,
+    either expressed or implied, of the FreeBSD Project.
+ */
+
+import * as THREE from 'three';
+import PointCloudLayer from "./PointCloudLayer.js";
+import Potree2Node from "../Core/Potree2Node.js";
+import Extent from "../Core/Geographic/Extent.js";
+import { PointAttribute, Potree2PointAttributes, PointAttributeTypes } from "../Core/Potree2PointAttributes.js";
+const bboxMesh = new THREE.Mesh();
+const box3 = new THREE.Box3();
+bboxMesh.geometry.boundingBox = box3;
+const typeNameAttributeMap = {
+  double: PointAttributeTypes.DATA_TYPE_DOUBLE,
+  float: PointAttributeTypes.DATA_TYPE_FLOAT,
+  int8: PointAttributeTypes.DATA_TYPE_INT8,
+  uint8: PointAttributeTypes.DATA_TYPE_UINT8,
+  int16: PointAttributeTypes.DATA_TYPE_INT16,
+  uint16: PointAttributeTypes.DATA_TYPE_UINT16,
+  int32: PointAttributeTypes.DATA_TYPE_INT32,
+  uint32: PointAttributeTypes.DATA_TYPE_UINT32,
+  int64: PointAttributeTypes.DATA_TYPE_INT64,
+  uint64: PointAttributeTypes.DATA_TYPE_UINT64
+};
+function parseAttributes(jsonAttributes) {
+  const attributes = new Potree2PointAttributes();
+  const replacements = {
+    rgb: 'rgba'
+  };
+  for (const jsonAttribute of jsonAttributes) {
+    const {
+      name,
+      numElements,
+      min,
+      max
+    } = jsonAttribute;
+    const type = typeNameAttributeMap[jsonAttribute.type];
+    const potreeAttributeName = replacements[name] ? replacements[name] : name;
+    const attribute = new PointAttribute(potreeAttributeName, type, numElements);
+    if (numElements === 1) {
+      attribute.range = [min[0], max[0]];
+    } else {
+      attribute.range = [min, max];
+    }
+    if (name === 'gps-time') {
+      // HACK: Guard against bad gpsTime range in metadata, see potree/potree#909
+      if (attribute.range[0] === attribute.range[1]) {
+        attribute.range[1] += 1;
+      }
+    }
+    attribute.initialRange = attribute.range;
+    attributes.add(attribute);
+  }
+  {
+    // check if it has normals
+    const hasNormals = attributes.attributes.find(a => a.name === 'NormalX') !== undefined && attributes.attributes.find(a => a.name === 'NormalY') !== undefined && attributes.attributes.find(a => a.name === 'NormalZ') !== undefined;
+    if (hasNormals) {
+      attributes.addVector({
+        name: 'NORMAL',
+        attributes: ['NormalX', 'NormalY', 'NormalZ']
+      });
+    }
+  }
+  return attributes;
+}
+
+/**
+ * @property {boolean} isPotreeLayer - Used to checkout whether this layer
+ * is a Potree2Layer. Default is `true`. You should not change this, as it is
+ * used internally for optimisation.
+ */
+class Potree2Layer extends PointCloudLayer {
+  /**
+   * Constructs a new instance of Potree2 layer.
+   *
+   * @constructor
+   * @extends PointCloudLayer
+   *
+   * @example
+   * // Create a new point cloud layer
+   * const points = new Potree2Layer('points',
+   *  {
+   *      source: new Potree2Source({
+   *          url: 'https://pointsClouds/',
+   *          file: 'metadata.json',
+   *      }
+   *  });
+   *
+   * View.prototype.addLayer.call(view, points);
+   *
+   * @param {string} id - The id of the layer, that should be unique. It is
+   * not mandatory, but an error will be emitted if this layer is added a
+   * {@link View} that already has a layer going by that id.
+   * @param {Object} config - Configuration, all elements in it
+   * will be merged as is in the layer. For example, if the configuration
+   * contains three elements `name, protocol, extent`, these elements will be
+   * available using `layer.name` or something else depending on the property
+   * name. See the list of properties to know which one can be specified.
+   * @param {string} [config.crs=ESPG:4326] - The CRS of the {@link View} this
+   * layer will be attached to. This is used to determine the extent of this
+   * layer.  Default to `EPSG:4326`.
+   */
+  constructor(id, config) {
+    super(id, config);
+    this.isPotreeLayer = true;
+    const resolve = this.addInitializationStep();
+    this.source.whenReady.then(metadata => {
+      this.scale = new THREE.Vector3(1, 1, 1);
+      this.metadata = metadata;
+      this.pointAttributes = parseAttributes(metadata.attributes);
+      this.spacing = metadata.spacing;
+      const normal = Array.isArray(this.pointAttributes.attributes) && this.pointAttributes.attributes.find(elem => elem.name.startsWith('NORMAL'));
+      if (normal) {
+        this.material.defines[normal.name] = 1;
+      }
+      const min = new THREE.Vector3(...metadata.boundingBox.min);
+      const max = new THREE.Vector3(...metadata.boundingBox.max);
+      const boundingBox = new THREE.Box3(min, max);
+      const root = new Potree2Node(0, 0, this);
+      root.bbox = boundingBox;
+      root.boundingSphere = boundingBox.getBoundingSphere(new THREE.Sphere());
+      root.id = 'r';
+      root.depth = 0;
+      root.nodeType = 2;
+      root.hierarchyByteOffset = 0n;
+      root.hierarchyByteSize = BigInt(metadata.hierarchy.firstChunkSize);
+      root.byteOffset = 0;
+      this.root = root;
+      this.extent = Extent.fromBox3(this.source.crs || 'EPSG:4326', boundingBox);
+      return this.root.loadOctree().then(resolve);
+    });
+  }
+}
+export default Potree2Layer;

package/lib/Layer/ReferencingLayerProperties.js

@@ -1,6 +1,5 @@
 // next step is move these properties to Style class
 // and hide transparent mechanism
-
 function ReferLayerProperties(material, layer) {
   if (layer && layer.isGeometryLayer) {
     let transparent = material.transparent;
@@ -39,14 +38,20 @@ function ReferLayerProperties(material, layer) {
         get: () => material.layer.pntsMaxAttenuatedSize
       });
     }
+    if (material.uniforms && material.uniforms.scale != undefined) {
+      Object.defineProperty(material.uniforms.scale, 'value', {
+        get: () => material.layer.scale
+      });
+    }
     Object.defineProperty(material, 'wireframe', {
       get: () => material.layer.wireframe
     });
     Object.defineProperty(material, 'transparent', {
       get: () => {
-        if (transparent != material.layer.opacity < 1.0) {
+        const needTransparency = material.userData.needTransparency?.[material.mode] || material.layer.opacity < 1.0;
+        if (transparent != needTransparency) {
           material.needsUpdate = true;
-          transparent = material.layer.opacity < 1.0;
+          transparent = needTransparency;
         }
         return transparent;
       }

package/lib/Layer/TiledGeometryLayer.js

@@ -4,7 +4,6 @@ import { InfoTiledGeometryLayer } from "./InfoLayer.js";
 import Picking from "../Core/Picking.js";
 import convertToTile from "../Converter/convertToTile.js";
 import ObjectRemovalHelper from "../Process/ObjectRemovalHelper.js";
-import { SIZE_DIAGONAL_TEXTURE } from "../Process/LayeredMaterialNodeProcessing.js";
 import { ImageryLayers } from "./Layer.js";
 import { CACHE_POLICIES } from "../Core/Scheduler/Cache.js";
 const subdivisionVector = new THREE.Vector3();
@@ -68,7 +67,7 @@ class TiledGeometryLayer extends GeometryLayer {
     // TODO : this should be add in a preprocess method specific to GeoidLayer.
     this.object3d.geoidHeight = 0;
     this.protocol = 'tile';
-    this._hideSkirt = false;
+    this._hideSkirt = !!config.hideSkirt;
     this.sseSubdivisionThreshold = this.sseSubdivisionThreshold || 1.0;
     this.schemeTile = schemeTile;
     this.builder = builder;
@@ -89,12 +88,15 @@ class TiledGeometryLayer extends GeometryLayer {
       this.object3d.add(...level0s);
       this.object3d.updateMatrixWorld();
     }));
-    this.maxScreenSizeNode = this.sseSubdivisionThreshold * (SIZE_DIAGONAL_TEXTURE * 2);
+    this.maxScreenSizeNode = this.sseSubdivisionThreshold * (this.sizeDiagonalTexture * 2);
   }
   get hideSkirt() {
     return this._hideSkirt;
   }
   set hideSkirt(value) {
+    if (!this.level0Nodes) {
+      return;
+    }
     this._hideSkirt = value;
     for (const node of this.level0Nodes) {
       node.traverse(obj => {
@@ -408,7 +410,7 @@ class TiledGeometryLayer extends GeometryLayer {
 
     // The screen space error is calculated to have a correct texture display.
     // For the projection of a texture's texel to be less than or equal to one pixel
-    const sse = node.screenSize / (SIZE_DIAGONAL_TEXTURE * 2);
+    const sse = node.screenSize / (this.sizeDiagonalTexture * 2);
     return this.sseSubdivisionThreshold < sse;
   }
 }

package/lib/Loader/Potree2BrotliLoader.js

@@ -0,0 +1,261 @@
+/*
+============
+== POTREE ==
+============
+
+http://potree.org
+
+Copyright (c) 2011-2020, Markus Schütz
+All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    The views and conclusions contained in the software and documentation are those
+of the authors and should not be interpreted as representing official policies,
+    either expressed or implied, of the FreeBSD Project.
+ */
+
+import { PointAttribute, PointAttributeTypes } from "../Core/Potree2PointAttributes.js";
+import { decompress } from 'brotli-compress/js.mjs';
+const typedArrayMapping = {
+  int8: Int8Array,
+  int16: Int16Array,
+  int32: Int32Array,
+  int64: Float64Array,
+  uint8: Uint8Array,
+  uint16: Uint16Array,
+  uint32: Uint32Array,
+  uint64: Float64Array,
+  float: Float32Array,
+  double: Float64Array
+};
+function dealign24b(mortoncode) {
+  // see https://stackoverflow.com/questions/45694690/how-i-can-remove-all-odds-bits-in-c
+
+  // input alignment of desired bits
+  // ..a..b..c..d..e..f..g..h..i..j..k..l..m..n..o..p
+  let x = mortoncode;
+
+  //          ..a..b..c..d..e..f..g..h..i..j..k..l..m..n..o..p                     ..a..b..c..d..e..f..g..h..i..j..k..l..m..n..o..p
+  //          ..a.....c.....e.....g.....i.....k.....m.....o...                     .....b.....d.....f.....h.....j.....l.....n.....p
+  //          ....a.....c.....e.....g.....i.....k.....m.....o.                     .....b.....d.....f.....h.....j.....l.....n.....p
+  x = (x & 0b001000001000001000001000) >> 2 | (x & 0b000001000001000001000001) >> 0;
+  //          ....ab....cd....ef....gh....ij....kl....mn....op                     ....ab....cd....ef....gh....ij....kl....mn....op
+  //          ....ab..........ef..........ij..........mn......                     ..........cd..........gh..........kl..........op
+  //          ........ab..........ef..........ij..........mn..                     ..........cd..........gh..........kl..........op
+  x = (x & 0b000011000000000011000000) >> 4 | (x & 0b000000000011000000000011) >> 0;
+  //          ........abcd........efgh........ijkl........mnop                     ........abcd........efgh........ijkl........mnop
+  //          ........abcd....................ijkl............                     ....................efgh....................mnop
+  //          ................abcd....................ijkl....                     ....................efgh....................mnop
+  x = (x & 0b000000001111000000000000) >> 8 | (x & 0b000000000000000000001111) >> 0;
+  //          ................abcdefgh................ijklmnop                     ................abcdefgh................ijklmnop
+  //          ................abcdefgh........................                     ........................................ijklmnop
+  //          ................................abcdefgh........                     ........................................ijklmnop
+  x = (x & 0b000000000000000000000000) >> 16 | (x & 0b000000000000000011111111) >> 0;
+
+  // sucessfully realigned!
+  // ................................abcdefghijklmnop
+
+  return x;
+}
+export default async function load(buffer, options) {
+  const {
+    pointAttributes,
+    scale,
+    min,
+    size,
+    offset,
+    numPoints
+  } = options;
+  let bytes;
+  if (numPoints === 0) {
+    bytes = {
+      buffer: new ArrayBuffer(0)
+    };
+  } else {
+    try {
+      bytes = await decompress(new Int8Array(buffer));
+    } catch (e) {
+      bytes = {
+        buffer: new ArrayBuffer(numPoints * (pointAttributes.byteSize + 12))
+      };
+      console.error(`problem with node ${name}: `, e);
+    }
+  }
+  const view = new DataView(bytes.buffer);
+  const attributeBuffers = {};
+  const gridSize = 32;
+  const grid = new Uint32Array(gridSize ** 3);
+  const toIndex = (x, y, z) => {
+    // min is already subtracted
+    const dx = gridSize * x / size.x;
+    const dy = gridSize * y / size.y;
+    const dz = gridSize * z / size.z;
+    const ix = Math.min(parseInt(dx, 10), gridSize - 1);
+    const iy = Math.min(parseInt(dy, 10), gridSize - 1);
+    const iz = Math.min(parseInt(dz, 10), gridSize - 1);
+    return ix + iy * gridSize + iz * gridSize * gridSize;
+  };
+  let numOccupiedCells = 0;
+  let byteOffset = 0;
+  for (const pointAttribute of pointAttributes.attributes) {
+    if (['POSITION_CARTESIAN', 'position'].includes(pointAttribute.name)) {
+      const buff = new ArrayBuffer(numPoints * 4 * 3);
+      const positions = new Float32Array(buff);
+      for (let j = 0; j < numPoints; j++) {
+        const mc_0 = view.getUint32(byteOffset + 4, true);
+        const mc_1 = view.getUint32(byteOffset + 0, true);
+        const mc_2 = view.getUint32(byteOffset + 12, true);
+        const mc_3 = view.getUint32(byteOffset + 8, true);
+        byteOffset += 16;
+        let X = dealign24b((mc_3 & 0x00FFFFFF) >>> 0) | dealign24b((mc_3 >>> 24 | mc_2 << 8) >>> 0) << 8;
+        let Y = dealign24b((mc_3 & 0x00FFFFFF) >>> 1) | dealign24b((mc_3 >>> 24 | mc_2 << 8) >>> 1) << 8;
+        let Z = dealign24b((mc_3 & 0x00FFFFFF) >>> 2) | dealign24b((mc_3 >>> 24 | mc_2 << 8) >>> 2) << 8;
+        if (mc_1 != 0 || mc_2 != 0) {
+          X = X | dealign24b((mc_1 & 0x00FFFFFF) >>> 0) << 16 | dealign24b((mc_1 >>> 24 | mc_0 << 8) >>> 0) << 24;
+          Y = Y | dealign24b((mc_1 & 0x00FFFFFF) >>> 1) << 16 | dealign24b((mc_1 >>> 24 | mc_0 << 8) >>> 1) << 24;
+          Z = Z | dealign24b((mc_1 & 0x00FFFFFF) >>> 2) << 16 | dealign24b((mc_1 >>> 24 | mc_0 << 8) >>> 2) << 24;
+        }
+        const x = parseInt(X, 10) * scale[0] + offset[0] - min.x;
+        const y = parseInt(Y, 10) * scale[1] + offset[1] - min.y;
+        const z = parseInt(Z, 10) * scale[2] + offset[2] - min.z;
+        const index = toIndex(x, y, z);
+        const count = grid[index]++;
+        if (count === 0) {
+          numOccupiedCells++;
+        }
+        positions[3 * j + 0] = x;
+        positions[3 * j + 1] = y;
+        positions[3 * j + 2] = z;
+      }
+      attributeBuffers[pointAttribute.name] = {
+        buffer: buff,
+        attribute: pointAttribute
+      };
+    } else if (['RGBA', 'rgba'].includes(pointAttribute.name)) {
+      const buff = new ArrayBuffer(numPoints * 4);
+      const colors = new Uint8Array(buff);
+      for (let j = 0; j < numPoints; j++) {
+        const mc_0 = view.getUint32(byteOffset + 4, true);
+        const mc_1 = view.getUint32(byteOffset + 0, true);
+        byteOffset += 8;
+        const r = dealign24b((mc_1 & 0x00FFFFFF) >>> 0) | dealign24b((mc_1 >>> 24 | mc_0 << 8) >>> 0) << 8;
+        const g = dealign24b((mc_1 & 0x00FFFFFF) >>> 1) | dealign24b((mc_1 >>> 24 | mc_0 << 8) >>> 1) << 8;
+        const b = dealign24b((mc_1 & 0x00FFFFFF) >>> 2) | dealign24b((mc_1 >>> 24 | mc_0 << 8) >>> 2) << 8;
+        colors[4 * j + 0] = r > 255 ? r / 256 : r;
+        colors[4 * j + 1] = g > 255 ? g / 256 : g;
+        colors[4 * j + 2] = b > 255 ? b / 256 : b;
+      }
+      attributeBuffers[pointAttribute.name] = {
+        buffer: buff,
+        attribute: pointAttribute
+      };
+    } else {
+      const buff = new ArrayBuffer(numPoints * 4);
+      const f32 = new Float32Array(buff);
+      const TypedArray = typedArrayMapping[pointAttribute.type.name];
+      const preciseBuffer = new TypedArray(numPoints);
+      let [offset, scale] = [0, 1];
+      const getterMap = {
+        int8: view.getInt8,
+        int16: view.getInt16,
+        int32: view.getInt32,
+        uint8: view.getUint8,
+        uint16: view.getUint16,
+        uint32: view.getUint32,
+        float: view.getFloat32,
+        double: view.getFloat64
+      };
+      const getter = getterMap[pointAttribute.type.name].bind(view);
+
+      // compute offset and scale to pack larger types into 32 bit floats
+      if (pointAttribute.type.size > 4) {
+        const [amin, amax] = pointAttribute.range;
+        offset = amin;
+        scale = 1 / (amax - amin);
+      }
+      for (let j = 0; j < numPoints; j++) {
+        const value = getter(byteOffset, true);
+        byteOffset += pointAttribute.byteSize;
+        f32[j] = (value - offset) * scale;
+        preciseBuffer[j] = value;
+      }
+      attributeBuffers[pointAttribute.name] = {
+        buffer: buff,
+        preciseBuffer,
+        attribute: pointAttribute,
+        offset,
+        scale
+      };
+    }
+  }
+  const occupancy = parseInt(numPoints / numOccupiedCells, 10);
+  {
+    // add indices
+    const buff = new ArrayBuffer(numPoints * 4);
+    const indices = new Uint32Array(buff);
+    for (let i = 0; i < numPoints; i++) {
+      indices[i] = i;
+    }
+    attributeBuffers.INDICES = {
+      buffer: buff,
+      attribute: PointAttribute.INDICES
+    };
+  }
+  {
+    // handle attribute vectors
+    const vectors = pointAttributes.vectors;
+    for (const vector of vectors) {
+      const {
+        name,
+        attributes
+      } = vector;
+      const numVectorElements = attributes.length;
+      const buffer = new ArrayBuffer(numVectorElements * numPoints * 4);
+      const f32 = new Float32Array(buffer);
+      let iElement = 0;
+      for (const sourceName of attributes) {
+        const sourceBuffer = attributeBuffers[sourceName];
+        const {
+          offset,
+          scale
+        } = sourceBuffer;
+        const view = new DataView(sourceBuffer.buffer);
+        const getter = view.getFloat32.bind(view);
+        for (let j = 0; j < numPoints; j++) {
+          const value = getter(j * 4, true);
+          f32[j * numVectorElements + iElement] = value / scale + offset;
+        }
+        iElement++;
+      }
+      const vecAttribute = new PointAttribute(name, PointAttributeTypes.DATA_TYPE_FLOAT, 3);
+      attributeBuffers[name] = {
+        buffer,
+        attribute: vecAttribute
+      };
+    }
+  }
+  return {
+    buffer,
+    attributeBuffers,
+    density: occupancy
+  };
+}