@map-colonies/react-components 3.12.2 → 3.12.3

package/dist/cesium-map/terrain-providers/custom/quantized-mesh-decoder.js

@@ -1,202 +1,202 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decode = exports.DECODING_STEPS = void 0;
-var LITTLE_ENDIAN = true;
-var MAX_VERTEX_COUNT = 65536;
-exports.DECODING_STEPS = {
-    header: 0,
-    vertices: 1,
-    triangleIndices: 2,
-    edgeIndices: 3,
-    extensions: 4,
-};
-var QUANTIZED_MESH_HEADER = {
-    centerX: Float64Array.BYTES_PER_ELEMENT,
-    centerY: Float64Array.BYTES_PER_ELEMENT,
-    centerZ: Float64Array.BYTES_PER_ELEMENT,
-    minHeight: Float32Array.BYTES_PER_ELEMENT,
-    maxHeight: Float32Array.BYTES_PER_ELEMENT,
-    boundingSphereCenterX: Float64Array.BYTES_PER_ELEMENT,
-    boundingSphereCenterY: Float64Array.BYTES_PER_ELEMENT,
-    boundingSphereCenterZ: Float64Array.BYTES_PER_ELEMENT,
-    boundingSphereRadius: Float64Array.BYTES_PER_ELEMENT,
-    horizonOcclusionPointX: Float64Array.BYTES_PER_ELEMENT,
-    horizonOcclusionPointY: Float64Array.BYTES_PER_ELEMENT,
-    horizonOcclusionPointZ: Float64Array.BYTES_PER_ELEMENT,
-};
-var decodeZigZag = function (value) {
-    return (value >> 1) ^ -(value & 1);
-};
-var decodeIndex = function (buffer, position, indicesCount, bytesPerIndex, encoded) {
-    var indices;
-    if (bytesPerIndex === 2) {
-        indices = new Uint16Array(buffer, position, indicesCount);
-    }
-    else {
-        indices = new Uint32Array(buffer, position, indicesCount);
-    }
-    if (!encoded) {
-        return indices;
-    }
-    var highest = 0;
-    for (var i = 0; i < indices.length; ++i) {
-        var code = indices[i];
-        indices[i] = highest - code;
-        if (code === 0) {
-            ++highest;
-        }
-    }
-    return indices;
-};
-var convertFromTypedArrayToNumbersArray = function (array) {
-    var numbersArray = [];
-    for (var i = 0; i < array.length; ++i) {
-        numbersArray.push(array[i]);
-    }
-    return numbersArray;
-};
-var decode = function (data) {
-    var maxDecodingStep = exports.DECODING_STEPS.extensions;
-    var view = new DataView(data);
-    var header = {};
-    var position = 0;
-    // Decode Header
-    Object.keys(QUANTIZED_MESH_HEADER).forEach(function (key, bytesCount) {
-        // @ts-ignore
-        // eslint-disable-next-line
-        header[key] =
-            bytesCount === 8
-                ? view.getFloat64(position, LITTLE_ENDIAN)
-                : view.getFloat32(position, LITTLE_ENDIAN);
-        position += bytesCount;
-    });
-    var headerEndPosition = position;
-    // if (maxDecodingStep < DECODING_STEPS.vertices) {
-    //   return { header };
-    // }
-    // Decode Vertex Data
-    position = headerEndPosition;
-    var vertexCount = view.getUint32(position, LITTLE_ENDIAN);
-    var vertexData = new Uint16Array(vertexCount * 3);
-    position += Uint32Array.BYTES_PER_ELEMENT;
-    var bytesPerArrayElement = Uint16Array.BYTES_PER_ELEMENT;
-    var elementArrayLength = vertexCount * bytesPerArrayElement;
-    var uArrayStartPosition = position;
-    var vArrayStartPosition = uArrayStartPosition + elementArrayLength;
-    var heightArrayStartPosition = vArrayStartPosition + elementArrayLength;
-    var u = 0;
-    var v = 0;
-    var height = 0;
-    for (var i = 0; i < vertexCount; i++) {
-        u += decodeZigZag(view.getUint16(uArrayStartPosition + bytesPerArrayElement * i, LITTLE_ENDIAN));
-        v += decodeZigZag(view.getUint16(vArrayStartPosition + bytesPerArrayElement * i, LITTLE_ENDIAN));
-        height += decodeZigZag(view.getUint16(heightArrayStartPosition + bytesPerArrayElement * i, LITTLE_ENDIAN));
-        vertexData[i] = u;
-        vertexData[i + vertexCount] = v;
-        vertexData[i + vertexCount * 2] = height;
-    }
-    position += elementArrayLength * 3;
-    var vertexDataEndPosition = position;
-    // if (maxDecodingStep < DECODING_STEPS.triangleIndices) {
-    //   return { header, vertexData };
-    // }
-    // Decode Triangle Indices
-    position = vertexDataEndPosition;
-    vertexCount = vertexData.length / 3;
-    var bytesPerIndex = vertexCount > MAX_VERTEX_COUNT
-        ? Uint32Array.BYTES_PER_ELEMENT
-        : Uint16Array.BYTES_PER_ELEMENT;
-    if (position % bytesPerIndex !== 0) {
-        position += bytesPerIndex - (position % bytesPerIndex);
-    }
-    var triangleCount = view.getUint32(position, LITTLE_ENDIAN);
-    position += Uint32Array.BYTES_PER_ELEMENT;
-    var triangleIndicesCount = triangleCount * 3;
-    var triangleIndices = decodeIndex(view.buffer, position, triangleIndicesCount, bytesPerIndex, true);
-    position += triangleIndicesCount * bytesPerIndex;
-    var triangleIndicesEndPosition = position;
-    // if (maxDecodingStep < DECODING_STEPS.edgeIndices) {
-    //   return { header, vertexData, triangleIndices };
-    // }
-    // Decode Edge Indices
-    position = triangleIndicesEndPosition;
-    vertexCount = vertexData.length / 3;
-    // bytesPerIndex = vertexCount > MAX_VERTEX_COUNT
-    //   ? Uint32Array.BYTES_PER_ELEMENT
-    //   : Uint16Array.BYTES_PER_ELEMENT;
-    var westVertexCount = view.getUint32(position, LITTLE_ENDIAN);
-    position += Uint32Array.BYTES_PER_ELEMENT;
-    var westIndices = convertFromTypedArrayToNumbersArray(decodeIndex(view.buffer, position, westVertexCount, bytesPerIndex, false));
-    position += westVertexCount * bytesPerIndex;
-    var southVertexCount = view.getUint32(position, LITTLE_ENDIAN);
-    position += Uint32Array.BYTES_PER_ELEMENT;
-    var southIndices = convertFromTypedArrayToNumbersArray(decodeIndex(view.buffer, position, southVertexCount, bytesPerIndex, false));
-    position += southVertexCount * bytesPerIndex;
-    var eastVertexCount = view.getUint32(position, LITTLE_ENDIAN);
-    position += Uint32Array.BYTES_PER_ELEMENT;
-    var eastIndices = convertFromTypedArrayToNumbersArray(decodeIndex(view.buffer, position, eastVertexCount, bytesPerIndex, false));
-    position += eastVertexCount * bytesPerIndex;
-    var northVertexCount = view.getUint32(position, LITTLE_ENDIAN);
-    position += Uint32Array.BYTES_PER_ELEMENT;
-    var northIndices = convertFromTypedArrayToNumbersArray(decodeIndex(view.buffer, position, northVertexCount, bytesPerIndex, false));
-    position += northVertexCount * bytesPerIndex;
-    var edgeIndicesEndPosition = position;
-    if (maxDecodingStep < exports.DECODING_STEPS.extensions) {
-        return {
-            header: header,
-            vertexData: vertexData,
-            triangleIndices: triangleIndices,
-            westIndices: westIndices,
-            northIndices: northIndices,
-            eastIndices: eastIndices,
-            southIndices: southIndices,
-        };
-    }
-    // Decode Extensions
-    var extensions = {};
-    if (view.byteLength > edgeIndicesEndPosition) {
-        position = edgeIndicesEndPosition;
-        while (position < view.byteLength) {
-            var extensionId = view.getUint8(position);
-            position += Uint8Array.BYTES_PER_ELEMENT;
-            var extensionLength = view.getUint32(position, true);
-            position += Uint32Array.BYTES_PER_ELEMENT;
-            var extensionView = new DataView(view.buffer, position, extensionLength);
-            switch (extensionId) {
-                case 1: {
-                    extensions.vertexNormals = new Uint8Array(extensionView.buffer, extensionView.byteOffset, extensionView.byteLength);
-                    break;
-                }
-                case 2: {
-                    extensions.waterMask = extensionView.buffer.slice(extensionView.byteOffset, extensionView.byteOffset + extensionView.byteLength);
-                    break;
-                }
-                case 4: {
-                    var jsonLength = extensionView.getUint32(0, LITTLE_ENDIAN);
-                    var jsonString = '';
-                    for (var i = 0; i < jsonLength; ++i) {
-                        jsonString += String.fromCharCode(extensionView.getUint8(Uint32Array.BYTES_PER_ELEMENT + i));
-                    }
-                    // eslint-disable-next-line
-                    extensions.metadata = JSON.parse(jsonString);
-                    break;
-                }
-                default: {
-                    console.warn("Unknown extension with id " + extensionId);
-                }
-            }
-            position += extensionLength;
-        }
-    }
-    return {
-        header: header,
-        vertexData: vertexData,
-        triangleIndices: triangleIndices,
-        westIndices: westIndices,
-        northIndices: northIndices,
-        eastIndices: eastIndices,
-        southIndices: southIndices,
-        extensions: extensions,
-    };
-};
-exports.decode = decode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.DECODING_STEPS = void 0;
+var LITTLE_ENDIAN = true;
+var MAX_VERTEX_COUNT = 65536;
+exports.DECODING_STEPS = {
+    header: 0,
+    vertices: 1,
+    triangleIndices: 2,
+    edgeIndices: 3,
+    extensions: 4,
+};
+var QUANTIZED_MESH_HEADER = {
+    centerX: Float64Array.BYTES_PER_ELEMENT,
+    centerY: Float64Array.BYTES_PER_ELEMENT,
+    centerZ: Float64Array.BYTES_PER_ELEMENT,
+    minHeight: Float32Array.BYTES_PER_ELEMENT,
+    maxHeight: Float32Array.BYTES_PER_ELEMENT,
+    boundingSphereCenterX: Float64Array.BYTES_PER_ELEMENT,
+    boundingSphereCenterY: Float64Array.BYTES_PER_ELEMENT,
+    boundingSphereCenterZ: Float64Array.BYTES_PER_ELEMENT,
+    boundingSphereRadius: Float64Array.BYTES_PER_ELEMENT,
+    horizonOcclusionPointX: Float64Array.BYTES_PER_ELEMENT,
+    horizonOcclusionPointY: Float64Array.BYTES_PER_ELEMENT,
+    horizonOcclusionPointZ: Float64Array.BYTES_PER_ELEMENT,
+};
+var decodeZigZag = function (value) {
+    return (value >> 1) ^ -(value & 1);
+};
+var decodeIndex = function (buffer, position, indicesCount, bytesPerIndex, encoded) {
+    var indices;
+    if (bytesPerIndex === 2) {
+        indices = new Uint16Array(buffer, position, indicesCount);
+    }
+    else {
+        indices = new Uint32Array(buffer, position, indicesCount);
+    }
+    if (!encoded) {
+        return indices;
+    }
+    var highest = 0;
+    for (var i = 0; i < indices.length; ++i) {
+        var code = indices[i];
+        indices[i] = highest - code;
+        if (code === 0) {
+            ++highest;
+        }
+    }
+    return indices;
+};
+var convertFromTypedArrayToNumbersArray = function (array) {
+    var numbersArray = [];
+    for (var i = 0; i < array.length; ++i) {
+        numbersArray.push(array[i]);
+    }
+    return numbersArray;
+};
+var decode = function (data) {
+    var maxDecodingStep = exports.DECODING_STEPS.extensions;
+    var view = new DataView(data);
+    var header = {};
+    var position = 0;
+    // Decode Header
+    Object.keys(QUANTIZED_MESH_HEADER).forEach(function (key, bytesCount) {
+        // @ts-ignore
+        // eslint-disable-next-line
+        header[key] =
+            bytesCount === 8
+                ? view.getFloat64(position, LITTLE_ENDIAN)
+                : view.getFloat32(position, LITTLE_ENDIAN);
+        position += bytesCount;
+    });
+    var headerEndPosition = position;
+    // if (maxDecodingStep < DECODING_STEPS.vertices) {
+    //   return { header };
+    // }
+    // Decode Vertex Data
+    position = headerEndPosition;
+    var vertexCount = view.getUint32(position, LITTLE_ENDIAN);
+    var vertexData = new Uint16Array(vertexCount * 3);
+    position += Uint32Array.BYTES_PER_ELEMENT;
+    var bytesPerArrayElement = Uint16Array.BYTES_PER_ELEMENT;
+    var elementArrayLength = vertexCount * bytesPerArrayElement;
+    var uArrayStartPosition = position;
+    var vArrayStartPosition = uArrayStartPosition + elementArrayLength;
+    var heightArrayStartPosition = vArrayStartPosition + elementArrayLength;
+    var u = 0;
+    var v = 0;
+    var height = 0;
+    for (var i = 0; i < vertexCount; i++) {
+        u += decodeZigZag(view.getUint16(uArrayStartPosition + bytesPerArrayElement * i, LITTLE_ENDIAN));
+        v += decodeZigZag(view.getUint16(vArrayStartPosition + bytesPerArrayElement * i, LITTLE_ENDIAN));
+        height += decodeZigZag(view.getUint16(heightArrayStartPosition + bytesPerArrayElement * i, LITTLE_ENDIAN));
+        vertexData[i] = u;
+        vertexData[i + vertexCount] = v;
+        vertexData[i + vertexCount * 2] = height;
+    }
+    position += elementArrayLength * 3;
+    var vertexDataEndPosition = position;
+    // if (maxDecodingStep < DECODING_STEPS.triangleIndices) {
+    //   return { header, vertexData };
+    // }
+    // Decode Triangle Indices
+    position = vertexDataEndPosition;
+    vertexCount = vertexData.length / 3;
+    var bytesPerIndex = vertexCount > MAX_VERTEX_COUNT
+        ? Uint32Array.BYTES_PER_ELEMENT
+        : Uint16Array.BYTES_PER_ELEMENT;
+    if (position % bytesPerIndex !== 0) {
+        position += bytesPerIndex - (position % bytesPerIndex);
+    }
+    var triangleCount = view.getUint32(position, LITTLE_ENDIAN);
+    position += Uint32Array.BYTES_PER_ELEMENT;
+    var triangleIndicesCount = triangleCount * 3;
+    var triangleIndices = decodeIndex(view.buffer, position, triangleIndicesCount, bytesPerIndex, true);
+    position += triangleIndicesCount * bytesPerIndex;
+    var triangleIndicesEndPosition = position;
+    // if (maxDecodingStep < DECODING_STEPS.edgeIndices) {
+    //   return { header, vertexData, triangleIndices };
+    // }
+    // Decode Edge Indices
+    position = triangleIndicesEndPosition;
+    vertexCount = vertexData.length / 3;
+    // bytesPerIndex = vertexCount > MAX_VERTEX_COUNT
+    //   ? Uint32Array.BYTES_PER_ELEMENT
+    //   : Uint16Array.BYTES_PER_ELEMENT;
+    var westVertexCount = view.getUint32(position, LITTLE_ENDIAN);
+    position += Uint32Array.BYTES_PER_ELEMENT;
+    var westIndices = convertFromTypedArrayToNumbersArray(decodeIndex(view.buffer, position, westVertexCount, bytesPerIndex, false));
+    position += westVertexCount * bytesPerIndex;
+    var southVertexCount = view.getUint32(position, LITTLE_ENDIAN);
+    position += Uint32Array.BYTES_PER_ELEMENT;
+    var southIndices = convertFromTypedArrayToNumbersArray(decodeIndex(view.buffer, position, southVertexCount, bytesPerIndex, false));
+    position += southVertexCount * bytesPerIndex;
+    var eastVertexCount = view.getUint32(position, LITTLE_ENDIAN);
+    position += Uint32Array.BYTES_PER_ELEMENT;
+    var eastIndices = convertFromTypedArrayToNumbersArray(decodeIndex(view.buffer, position, eastVertexCount, bytesPerIndex, false));
+    position += eastVertexCount * bytesPerIndex;
+    var northVertexCount = view.getUint32(position, LITTLE_ENDIAN);
+    position += Uint32Array.BYTES_PER_ELEMENT;
+    var northIndices = convertFromTypedArrayToNumbersArray(decodeIndex(view.buffer, position, northVertexCount, bytesPerIndex, false));
+    position += northVertexCount * bytesPerIndex;
+    var edgeIndicesEndPosition = position;
+    if (maxDecodingStep < exports.DECODING_STEPS.extensions) {
+        return {
+            header: header,
+            vertexData: vertexData,
+            triangleIndices: triangleIndices,
+            westIndices: westIndices,
+            northIndices: northIndices,
+            eastIndices: eastIndices,
+            southIndices: southIndices,
+        };
+    }
+    // Decode Extensions
+    var extensions = {};
+    if (view.byteLength > edgeIndicesEndPosition) {
+        position = edgeIndicesEndPosition;
+        while (position < view.byteLength) {
+            var extensionId = view.getUint8(position);
+            position += Uint8Array.BYTES_PER_ELEMENT;
+            var extensionLength = view.getUint32(position, true);
+            position += Uint32Array.BYTES_PER_ELEMENT;
+            var extensionView = new DataView(view.buffer, position, extensionLength);
+            switch (extensionId) {
+                case 1: {
+                    extensions.vertexNormals = new Uint8Array(extensionView.buffer, extensionView.byteOffset, extensionView.byteLength);
+                    break;
+                }
+                case 2: {
+                    extensions.waterMask = extensionView.buffer.slice(extensionView.byteOffset, extensionView.byteOffset + extensionView.byteLength);
+                    break;
+                }
+                case 4: {
+                    var jsonLength = extensionView.getUint32(0, LITTLE_ENDIAN);
+                    var jsonString = '';
+                    for (var i = 0; i < jsonLength; ++i) {
+                        jsonString += String.fromCharCode(extensionView.getUint8(Uint32Array.BYTES_PER_ELEMENT + i));
+                    }
+                    // eslint-disable-next-line
+                    extensions.metadata = JSON.parse(jsonString);
+                    break;
+                }
+                default: {
+                    console.warn("Unknown extension with id " + extensionId);
+                }
+            }
+            position += extensionLength;
+        }
+    }
+    return {
+        header: header,
+        vertexData: vertexData,
+        triangleIndices: triangleIndices,
+        westIndices: westIndices,
+        northIndices: northIndices,
+        eastIndices: eastIndices,
+        southIndices: southIndices,
+        extensions: extensions,
+    };
+};
+exports.decode = decode;

package/dist/cesium-map/terrain-providers/custom/quantized-mesh-terrain-provider.d.ts

@@ -1,50 +1,50 @@
-import { QuantizedMeshTerrainData, TilingScheme } from 'cesium';
-export interface IDecodedTileHeader {
-    centerX: number;
-    centerY: number;
-    centerZ: number;
-    minHeight: number;
-    maxHeight: number;
-    boundingSphereCenterX: number;
-    boundingSphereCenterY: number;
-    boundingSphereCenterZ: number;
-    boundingSphereRadius: number;
-    horizonOcclusionPointX: number;
-    horizonOcclusionPointY: number;
-    horizonOcclusionPointZ: number;
-}
-export interface IExtensions {
-    vertexNormals?: Uint8Array;
-    waterMask?: ArrayBufferLike;
-    metadata?: unknown;
-}
-export interface IDecodedTile {
-    header: IDecodedTileHeader;
-    vertexData: Uint16Array;
-    triangleIndices: Uint16Array | Uint32Array;
-    westIndices: number[];
-    northIndices: number[];
-    eastIndices: number[];
-    southIndices: number[];
-    extensions?: IExtensions;
-}
-export default class QuantizedMeshTerrainProvider {
-    tilingScheme: TilingScheme;
-    ready: boolean;
-    readyPromise: Promise<boolean>;
-    private readonly dummyTile;
-    private readonly getUrl;
-    private readonly credits;
-    constructor(options: {
-        getUrl?: (x: number, y: number, level: number) => string;
-        credit?: string;
-        tilingScheme?: TilingScheme;
-    });
-    requestTileGeometry(x: number, y: number, level: number): Promise<void | QuantizedMeshTerrainData> | undefined;
-    getTileDataAvailable(x: number, y: number, level: number): boolean;
-    getLevelMaximumGeometricError(level: number): number;
-    private generateDummyTileHeader;
-    private createQuantizedMeshData;
-    private generateDummyTile;
-    private decodeResponse;
-}
+import { QuantizedMeshTerrainData, TilingScheme } from 'cesium';
+export interface IDecodedTileHeader {
+    centerX: number;
+    centerY: number;
+    centerZ: number;
+    minHeight: number;
+    maxHeight: number;
+    boundingSphereCenterX: number;
+    boundingSphereCenterY: number;
+    boundingSphereCenterZ: number;
+    boundingSphereRadius: number;
+    horizonOcclusionPointX: number;
+    horizonOcclusionPointY: number;
+    horizonOcclusionPointZ: number;
+}
+export interface IExtensions {
+    vertexNormals?: Uint8Array;
+    waterMask?: ArrayBufferLike;
+    metadata?: unknown;
+}
+export interface IDecodedTile {
+    header: IDecodedTileHeader;
+    vertexData: Uint16Array;
+    triangleIndices: Uint16Array | Uint32Array;
+    westIndices: number[];
+    northIndices: number[];
+    eastIndices: number[];
+    southIndices: number[];
+    extensions?: IExtensions;
+}
+export default class QuantizedMeshTerrainProvider {
+    tilingScheme: TilingScheme;
+    ready: boolean;
+    readyPromise: Promise<boolean>;
+    private readonly dummyTile;
+    private readonly getUrl;
+    private readonly credits;
+    constructor(options: {
+        getUrl?: (x: number, y: number, level: number) => string;
+        credit?: string;
+        tilingScheme?: TilingScheme;
+    });
+    requestTileGeometry(x: number, y: number, level: number): Promise<void | QuantizedMeshTerrainData> | undefined;
+    getTileDataAvailable(x: number, y: number, level: number): boolean;
+    getLevelMaximumGeometricError(level: number): number;
+    private generateDummyTileHeader;
+    private createQuantizedMeshData;
+    private generateDummyTile;
+    private decodeResponse;
+}