@openglobus/og 1.0.0-rc33 → 1.0.0-rc35

package/lib/Globe.d.ts

@@ -43,6 +43,7 @@ export interface IGlobeParams {
     sun?: {
         active?: boolean;
         stopped?: boolean;
+        dateTime?: Date | null;
         localDateTime?: Date | null;
         useTimeZones?: boolean;
     };
@@ -109,6 +110,9 @@ export interface IGlobeParams {
  * @param {string} [options.name] - Planet name. Default is uniq identifier.
  * @param {EmptyTerrain | Array.<EmptyTerrain>} [options.terrain] - Terrain provider or providers array, where the first one becomes active. Default no terrain - og.terrain.EmptyTerrain.
  * @param {Array.<Control>} [options.controls] - Controls.
+ * @param {Object} [options.sun] - Sun control options.
+ * @param {Date|null} [options.sun.dateTime] - Fixed UTC time.
+ * @param {Date|null} [options.sun.localDateTime] - Local time. Overrides dateTime if provided; null resets fixed lighting.
  * @param {Array.<Layer>} [options.layers] - Planet layers.
  * @param {Extent | ExtentBoundingBox} [options.viewExtent] [options.viewExtent] - Viewable starting extent.
  * @param {boolean} [options.autoActivate=true] - Globe rendering auto activation flag. True is default.

package/lib/assets/LabelWorker.worker-C24YLEkW.js.map

@@ -1 +1 @@
-{"version":3,"file":"LabelWorker.worker-C24YLEkW.js","names":[],"sources":["../../src/entity/label/LabelWorker.worker.js"],"sourcesContent":["\"use strict\";\n\nfunction concatTypedArrays(dest, index, source) {\n    let len = source.length,\n        offset = index * len;\n    for (let i = 0; i < len; i++) {\n        dest[offset + i] = source[i];\n    }\n}\n\nfunction srgbToLinear(v) {\n    return Math.pow(v, 2.2);\n}\n\nself.onmessage = function (e) {\n    var labelData = e.data.labelData,\n        id = labelData[0],\n        maxLetters = labelData[1],\n        isVisible = labelData[2],\n        /*3, 4, 5*/ _positionHigh_x = labelData[3],\n        _positionHigh_y = labelData[4],\n        _positionHigh_z = labelData[5],\n        /*6, 7, 8*/ _positionLow_x = labelData[6],\n        _positionLow_y = labelData[7],\n        _positionLow_z = labelData[8],\n        /*9*/ _size = labelData[9],\n        /*10, 11*/ _offset_x = labelData[10],\n        _offset_y = labelData[11],\n        /*12, 13, 14, 15*/ _color_x = labelData[12],\n        _color_y = labelData[13],\n        _color_z = labelData[14],\n        _color_w = labelData[15],\n        /*16*/ _rotation = labelData[16],\n        /*17, 18, 19*/ _alignedAxis_x = labelData[17],\n        _alignedAxis_y = labelData[18],\n        _alignedAxis_z = labelData[19],\n        /*20*/ _fontIndex = labelData[20],\n        /*21*/ _outline = labelData[21],\n        /*22, 23, 24, 25*/ _outlineColor_x = labelData[22],\n        _outlineColor_y = labelData[23],\n        _outlineColor_z = labelData[24],\n        _outlineColor_w = labelData[25],\n        /*26, 27, 28*/ _pickingColor_x = labelData[26],\n        _pickingColor_y = labelData[27],\n        _pickingColor_z = labelData[28];\n\n    let _vertexArr = new Float32Array(maxLetters * 12),\n        _texCoordArr = new Float32Array(maxLetters * 24),\n        _gliphParamArr = new Float32Array(maxLetters * 24),\n        _positionHighArr = new Float32Array(maxLetters * 18),\n        _positionLowArr = new Float32Array(maxLetters * 18),\n        _sizeArr = new Float32Array(maxLetters * 6),\n        _offsetArr = new Float32Array(maxLetters * 12),\n        _rgbaArr = new Float32Array(maxLetters * 24),\n        _rotationArr = new Float32Array(maxLetters * 6),\n        _alignedAxisArr = new Float32Array(maxLetters * 18),\n        _fontIndexArr = new Float32Array(maxLetters * 6),\n        _outlineArr = new Float32Array(maxLetters * 6),\n        _outlineColorArr = new Float32Array(maxLetters * 24),\n        _pickingColorArr = new Float32Array(maxLetters * 18);\n\n    for (let i = 0; i < maxLetters; i++) {\n        if (isVisible !== 0) {\n            concatTypedArrays(_vertexArr, i, [0, 0, 0, -1, 1, -1, 1, -1, 1, 0, 0, 0]);\n        } else {\n            concatTypedArrays(_vertexArr, i, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);\n        }\n\n        concatTypedArrays(\n            _texCoordArr,\n            i,\n            [0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0]\n        );\n        concatTypedArrays(_gliphParamArr, i, [1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0]);\n\n        var x = _positionHigh_x,\n            y = _positionHigh_y,\n            z = _positionHigh_z,\n            w;\n        concatTypedArrays(_positionHighArr, i, [x, y, z, x, y, z, x, y, z, x, y, z, x, y, z, x, y, z]);\n\n        x = _positionLow_x;\n        y = _positionLow_y;\n        z = _positionLow_z;\n        concatTypedArrays(_positionLowArr, i, [x, y, z, x, y, z, x, y, z, x, y, z, x, y, z, x, y, z]);\n\n        x = _size;\n        concatTypedArrays(_sizeArr, i, [x, x, x, x, x, x]);\n\n        x = _offset_x;\n        y = _offset_y;\n        concatTypedArrays(_offsetArr, i, [x, y, x, y, x, y, x, y, x, y, x, y]);\n\n        x = srgbToLinear(_color_x);\n        y = srgbToLinear(_color_y);\n        z = srgbToLinear(_color_z);\n        w = _color_w;\n        concatTypedArrays(_rgbaArr, i, [x, y, z, w, x, y, z, w, x, y, z, w, x, y, z, w, x, y, z, w, x, y, z, w]);\n\n        x = _rotation;\n        concatTypedArrays(_rotationArr, i, [x, x, x, x, x, x]);\n\n        x = _alignedAxis_x;\n        y = _alignedAxis_y;\n        z = _alignedAxis_z;\n        concatTypedArrays(_alignedAxisArr, i, [x, y, z, x, y, z, x, y, z, x, y, z, x, y, z, x, y, z]);\n\n        x = _fontIndex;\n        concatTypedArrays(_fontIndexArr, i, [x, x, x, x, x, x]);\n\n        x = _outline;\n        concatTypedArrays(_outlineArr, i, [x, x, x, x, x, x]);\n\n        x = srgbToLinear(_outlineColor_x);\n        y = srgbToLinear(_outlineColor_y);\n        z = srgbToLinear(_outlineColor_z);\n        w = _outlineColor_w;\n        concatTypedArrays(_outlineColorArr, i, [\n            x,\n            y,\n            z,\n            w,\n            x,\n            y,\n            z,\n            w,\n            x,\n            y,\n            z,\n            w,\n            x,\n            y,\n            z,\n            w,\n            x,\n            y,\n            z,\n            w,\n            x,\n            y,\n            z,\n            w\n        ]);\n\n        x = _pickingColor_x / 255;\n        y = _pickingColor_y / 255;\n        z = _pickingColor_z / 255;\n        concatTypedArrays(_pickingColorArr, i, [x, y, z, x, y, z, x, y, z, x, y, z, x, y, z, x, y, z]);\n    }\n\n    self.postMessage(\n        {\n            id: id,\n            vertexArr: _vertexArr,\n            texCoordArr: _texCoordArr,\n            gliphParamArr: _gliphParamArr,\n            positionHighArr: _positionHighArr,\n            positionLowArr: _positionLowArr,\n            sizeArr: _sizeArr,\n            offsetArr: _offsetArr,\n            rgbaArr: _rgbaArr,\n            rotationArr: _rotationArr,\n            alignedAxisArr: _alignedAxisArr,\n            fontIndexArr: _fontIndexArr,\n            outlineArr: _outlineArr,\n            outlineColorArr: _outlineColorArr,\n            pickingColorArr: _pickingColorArr\n        },\n        [\n            _vertexArr.buffer,\n            _texCoordArr.buffer,\n            _gliphParamArr.buffer,\n            _positionHighArr.buffer,\n            _positionLowArr.buffer,\n            _sizeArr.buffer,\n            _offsetArr.buffer,\n            _rgbaArr.buffer,\n            _rotationArr.buffer,\n            _alignedAxisArr.buffer,\n            _fontIndexArr.buffer,\n            _outlineArr.buffer,\n            _outlineColorArr.buffer,\n            _pickingColorArr.buffer\n        ]\n    );\n};\n"],"mappings":"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"}
+{"version":3,"file":"LabelWorker.worker-C24YLEkW.js","names":["concatTypedArrays","dest","index","source","len","length","offset","i","srgbToLinear","v","Math","pow","self","onmessage","e","labelData","data","id","maxLetters","isVisible","_positionHigh_x","_positionHigh_y","_positionHigh_z","_positionLow_x","_positionLow_y","_positionLow_z","_size","_offset_x","_offset_y","_color_x","_color_y","_color_z","_color_w","_rotation","_alignedAxis_x","_alignedAxis_y","_alignedAxis_z","_fontIndex","_outline","_outlineColor_x","_outlineColor_y","_outlineColor_z","_outlineColor_w","_pickingColor_x","_pickingColor_y","_pickingColor_z","_vertexArr","Float32Array","_texCoordArr","_gliphParamArr","_positionHighArr","_positionLowArr","_sizeArr","_offsetArr","_rgbaArr","_rotationArr","_alignedAxisArr","_fontIndexArr","_outlineArr","_outlineColorArr","_pickingColorArr","w","x","y","z","postMessage","vertexArr","texCoordArr","gliphParamArr","positionHighArr","positionLowArr","sizeArr","offsetArr","rgbaArr","rotationArr","alignedAxisArr","fontIndexArr","outlineArr","outlineColorArr","pickingColorArr","buffer","r","o","a","t","e","f","n","l","A","u","i","b","w","s","y","F","c","p","d","h","v","m","M","k","z","D","H","I","L","P","j","q","B","E","G","J","K","N","O","Q","R","S","T","U","V","W","X","Y"],"sources":["../../src/entity/label/LabelWorker.worker.js"],"sourcesContent":["\"use strict\";\n\nfunction concatTypedArrays(dest, index, source) {\n    let len = source.length,\n        offset = index * len;\n    for (let i = 0; i < len; i++) {\n        dest[offset + i] = source[i];\n    }\n}\n\nfunction srgbToLinear(v) {\n    return Math.pow(v, 2.2);\n}\n\nself.onmessage = function (e) {\n    var labelData = e.data.labelData,\n        id = labelData[0],\n        maxLetters = labelData[1],\n        isVisible = labelData[2],\n        /*3, 4, 5*/ _positionHigh_x = labelData[3],\n        _positionHigh_y = labelData[4],\n        _positionHigh_z = labelData[5],\n        /*6, 7, 8*/ _positionLow_x = labelData[6],\n        _positionLow_y = labelData[7],\n        _positionLow_z = labelData[8],\n        /*9*/ _size = labelData[9],\n        /*10, 11*/ _offset_x = labelData[10],\n        _offset_y = labelData[11],\n        /*12, 13, 14, 15*/ _color_x = labelData[12],\n        _color_y = labelData[13],\n        _color_z = labelData[14],\n        _color_w = labelData[15],\n        /*16*/ _rotation = labelData[16],\n        /*17, 18, 19*/ _alignedAxis_x = labelData[17],\n        _alignedAxis_y = labelData[18],\n        _alignedAxis_z = labelData[19],\n        /*20*/ _fontIndex = labelData[20],\n        /*21*/ _outline = labelData[21],\n        /*22, 23, 24, 25*/ _outlineColor_x = labelData[22],\n        _outlineColor_y = labelData[23],\n        _outlineColor_z = labelData[24],\n        _outlineColor_w = labelData[25],\n        /*26, 27, 28*/ _pickingColor_x = labelData[26],\n        _pickingColor_y = labelData[27],\n        _pickingColor_z = labelData[28];\n\n    let _vertexArr = new Float32Array(maxLetters * 12),\n        _texCoordArr = new Float32Array(maxLetters * 24),\n        _gliphParamArr = new Float32Array(maxLetters * 24),\n        _positionHighArr = new Float32Array(maxLetters * 18),\n        _positionLowArr = new Float32Array(maxLetters * 18),\n        _sizeArr = new Float32Array(maxLetters * 6),\n        _offsetArr = new Float32Array(maxLetters * 12),\n        _rgbaArr = new Float32Array(maxLetters * 24),\n        _rotationArr = new Float32Array(maxLetters * 6),\n        _alignedAxisArr = new Float32Array(maxLetters * 18),\n        _fontIndexArr = new Float32Array(maxLetters * 6),\n        _outlineArr = new Float32Array(maxLetters * 6),\n        _outlineColorArr = new Float32Array(maxLetters * 24),\n        _pickingColorArr = new Float32Array(maxLetters * 18);\n\n    for (let i = 0; i < maxLetters; i++) {\n        if (isVisible !== 0) {\n            concatTypedArrays(_vertexArr, i, [0, 0, 0, -1, 1, -1, 1, -1, 1, 0, 0, 0]);\n        } else {\n            concatTypedArrays(_vertexArr, i, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);\n        }\n\n        concatTypedArrays(\n            _texCoordArr,\n            i,\n            [0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0]\n        );\n        concatTypedArrays(_gliphParamArr, i, [1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0]);\n\n        var x = _positionHigh_x,\n            y = _positionHigh_y,\n            z = _positionHigh_z,\n            w;\n        concatTypedArrays(_positionHighArr, i, [x, y, z, x, y, z, x, y, z, x, y, z, x, y, z, x, y, z]);\n\n        x = _positionLow_x;\n        y = _positionLow_y;\n        z = _positionLow_z;\n        concatTypedArrays(_positionLowArr, i, [x, y, z, x, y, z, x, y, z, x, y, z, x, y, z, x, y, z]);\n\n        x = _size;\n        concatTypedArrays(_sizeArr, i, [x, x, x, x, x, x]);\n\n        x = _offset_x;\n        y = _offset_y;\n        concatTypedArrays(_offsetArr, i, [x, y, x, y, x, y, x, y, x, y, x, y]);\n\n        x = srgbToLinear(_color_x);\n        y = srgbToLinear(_color_y);\n        z = srgbToLinear(_color_z);\n        w = _color_w;\n        concatTypedArrays(_rgbaArr, i, [x, y, z, w, x, y, z, w, x, y, z, w, x, y, z, w, x, y, z, w, x, y, z, w]);\n\n        x = _rotation;\n        concatTypedArrays(_rotationArr, i, [x, x, x, x, x, x]);\n\n        x = _alignedAxis_x;\n        y = _alignedAxis_y;\n        z = _alignedAxis_z;\n        concatTypedArrays(_alignedAxisArr, i, [x, y, z, x, y, z, x, y, z, x, y, z, x, y, z, x, y, z]);\n\n        x = _fontIndex;\n        concatTypedArrays(_fontIndexArr, i, [x, x, x, x, x, x]);\n\n        x = _outline;\n        concatTypedArrays(_outlineArr, i, [x, x, x, x, x, x]);\n\n        x = srgbToLinear(_outlineColor_x);\n        y = srgbToLinear(_outlineColor_y);\n        z = srgbToLinear(_outlineColor_z);\n        w = _outlineColor_w;\n        concatTypedArrays(_outlineColorArr, i, [\n            x,\n            y,\n            z,\n            w,\n            x,\n            y,\n            z,\n            w,\n            x,\n            y,\n            z,\n            w,\n            x,\n            y,\n            z,\n            w,\n            x,\n            y,\n            z,\n            w,\n            x,\n            y,\n            z,\n            w\n        ]);\n\n        x = _pickingColor_x / 255;\n        y = _pickingColor_y / 255;\n        z = _pickingColor_z / 255;\n        concatTypedArrays(_pickingColorArr, i, [x, y, z, x, y, z, x, y, z, x, y, z, x, y, z, x, y, z]);\n    }\n\n    self.postMessage(\n        {\n            id: id,\n            vertexArr: _vertexArr,\n            texCoordArr: _texCoordArr,\n            gliphParamArr: _gliphParamArr,\n            positionHighArr: _positionHighArr,\n            positionLowArr: _positionLowArr,\n            sizeArr: _sizeArr,\n            offsetArr: _offsetArr,\n            rgbaArr: _rgbaArr,\n            rotationArr: _rotationArr,\n            alignedAxisArr: _alignedAxisArr,\n            fontIndexArr: _fontIndexArr,\n            outlineArr: _outlineArr,\n            outlineColorArr: _outlineColorArr,\n            pickingColorArr: _pickingColorArr\n        },\n        [\n            _vertexArr.buffer,\n            _texCoordArr.buffer,\n            _gliphParamArr.buffer,\n            _positionHighArr.buffer,\n            _positionLowArr.buffer,\n            _sizeArr.buffer,\n            _offsetArr.buffer,\n            _rgbaArr.buffer,\n            _rotationArr.buffer,\n            _alignedAxisArr.buffer,\n            _fontIndexArr.buffer,\n            _outlineArr.buffer,\n            _outlineColorArr.buffer,\n            _pickingColorArr.buffer\n        ]\n    );\n};\n"],"mappings":"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"}

package/lib/assets/PlainSegmentWorker.worker-DJHXd0bF.js.map

@@ -1 +1 @@
-{"version":3,"file":"PlainSegmentWorker.worker-DJHXd0bF.js","names":[],"sources":["../../src/utils/PlainSegmentWorker.worker.js"],"sourcesContent":["\"use strict\";\n\nlet model = null;\n\nlet cached_ix = null;\nlet cached_iy = null;\nlet v00 = null;\nlet v01 = null;\nlet v10 = null;\nlet v11 = null;\n//let t = null;\n\nfunction rawval(ix, iy) {\n    if (iy < 0) {\n        iy = -iy;\n        ix += model.width / 2;\n    } else if (iy >= model.height) {\n        iy = 2 * (model.height - 1) - iy;\n        ix += model.width / 2;\n    }\n\n    if (ix < 0) {\n        ix += model.width;\n    } else if (ix >= model.width) {\n        ix -= model.width;\n    }\n\n    var k = (iy * model.width + ix) * 2 + model.i;\n\n    return (model.rawfile[k] << 8) | model.rawfile[k + 1];\n}\n\nfunction getHeightMSL(lon, lat) {\n    if (!model) return 0;\n\n    if (lon < 0) lon += 360.0;\n\n    var fy = (90 - lat) * model.rlatres;\n    var fx = lon * model.rlonres;\n    var iy = Math.floor(fy);\n    var ix = Math.floor(fx);\n\n    fx -= ix;\n    fy -= iy;\n\n    if (iy === model.height - 1) {\n        iy--;\n    }\n\n    if (cached_ix !== ix || cached_iy !== iy) {\n        cached_ix = ix;\n        cached_iy = iy;\n\n        v00 = rawval(ix, iy);\n        v01 = rawval(ix + 1, iy);\n        v10 = rawval(ix, iy + 1);\n        v11 = rawval(ix + 1, iy + 1);\n    }\n\n    let h = null;\n\n    var a = (1 - fx) * v00 + fx * v01;\n    var b = (1 - fx) * v10 + fx * v11;\n\n    h = (1 - fy) * a + fy * b;\n\n    return model.offset + model.scale * h;\n}\n\nconst HALF_PI = Math.PI * 0.5;\nconst POLE = 20037508.34;\nconst PI_BY_POLE = Math.PI / POLE;\nconst INV_POLE_BY_180 = 180.0 / POLE;\nconst INV_PI_BY_180 = 180.0 / Math.PI;\nconst INV_PI_BY_180_HALF_PI = INV_PI_BY_180 * HALF_PI;\nconst RADIANS = Math.PI / 180.0;\nconst INV_PI_BY_360 = INV_PI_BY_180 * 2.0;\n\nlet E2 = 0.0,\n    A = 0.0;\n\nlet _projFunc = null;\n\nconst Vec3 = function (x, y, z) {\n    this.x = x;\n    this.y = y;\n    this.z = z;\n};\n\nvar geodeticToCartesian = function (lon, lat, heightFactor, res) {\n    let h = getHeightMSL(lon, lat) * heightFactor;\n\n    let latrad = RADIANS * lat,\n        lonrad = RADIANS * lon;\n\n    let slt = Math.sin(latrad);\n\n    let N = A / Math.sqrt(1.0 - E2 * slt * slt);\n    let nc = (N + h) * Math.cos(latrad);\n\n    res.x = nc * Math.cos(lonrad);\n    res.y = nc * Math.sin(lonrad);\n    res.z = (N * (1 - E2) + h) * slt;\n};\n\nvar geodeticToCartesianInverse = function (lon, lat, heightFactor, res) {\n    geodeticToCartesian(\n        lon * INV_POLE_BY_180,\n        INV_PI_BY_360 * Math.atan(Math.exp(lat * PI_BY_POLE)) - INV_PI_BY_180_HALF_PI,\n        heightFactor,\n        res\n    );\n};\n\nvar worldPos = new Vec3(0.0, 0.0, 0.0);\nvar rtcPos = new Vec3(0.0, 0.0, 0.0);\nvar _tempHigh = new Vec3(0.0, 0.0, 0.0);\nvar _tempLow = new Vec3(0.0, 0.0, 0.0);\n\nvar doubleToTwoFloats = function (v, high, low) {\n    let x = v.x,\n        y = v.y,\n        z = v.z;\n\n    var doubleHigh;\n\n    if (x >= 0.0) {\n        doubleHigh = Math.floor(x / 65536.0) * 65536.0;\n        high.x = Math.fround(doubleHigh);\n        low.x = Math.fround(x - doubleHigh);\n    } else {\n        doubleHigh = Math.floor(-x / 65536.0) * 65536.0;\n        high.x = Math.fround(-doubleHigh);\n        low.x = Math.fround(x + doubleHigh);\n    }\n\n    if (y >= 0.0) {\n        doubleHigh = Math.floor(y / 65536.0) * 65536.0;\n        high.y = Math.fround(doubleHigh);\n        low.y = Math.fround(y - doubleHigh);\n    } else {\n        doubleHigh = Math.floor(-y / 65536.0) * 65536.0;\n        high.y = Math.fround(-doubleHigh);\n        low.y = Math.fround(y + doubleHigh);\n    }\n\n    if (z >= 0.0) {\n        doubleHigh = Math.floor(z / 65536.0) * 65536.0;\n        high.z = Math.fround(doubleHigh);\n        low.z = Math.fround(z - doubleHigh);\n    } else {\n        doubleHigh = Math.floor(-z / 65536.0) * 65536.0;\n        high.z = Math.fround(-doubleHigh);\n        low.z = Math.fround(z + doubleHigh);\n    }\n};\n\nself.onmessage = function (msg) {\n    if (msg.data.model) {\n        model = msg.data.model;\n        model.rawfile = msg.data.rawfile;\n    } else if (msg.data.params) {\n        let rtc_x = msg.data.params[14];\n        let rtc_y = msg.data.params[15];\n        let rtc_z = msg.data.params[16];\n\n        let xmin = 549755748352.0,\n            xmax = -549755748352.0,\n            ymin = 549755748352.0,\n            ymax = -549755748352.0,\n            zmin = 549755748352.0,\n            zmax = -549755748352.0;\n\n        E2 = msg.data.params[8];\n        A = msg.data.params[9];\n\n        let gridSize = msg.data.params[2],\n            fgs = msg.data.params[3],\n            r2_x = msg.data.params[10],\n            r2_y = msg.data.params[11],\n            r2_z = msg.data.params[12];\n\n        let heightFactor = msg.data.params[13];\n\n        if (msg.data.params[1] === 0.0) {\n            _projFunc = geodeticToCartesianInverse;\n        } else {\n            _projFunc = geodeticToCartesian;\n        }\n\n        let maxFgs = Math.max(fgs, gridSize);\n        let llStep = (msg.data.params[6] - msg.data.params[4]) / maxFgs;\n        let ltStep = (msg.data.params[7] - msg.data.params[5]) / maxFgs;\n\n        let esw_lon = msg.data.params[4],\n            ene_lat = msg.data.params[7];\n\n        let dg = Math.max(fgs / gridSize, 1.0),\n            gs = maxFgs + 1;\n\n        const gsgs = gs * gs;\n\n        const gridSize3 = (gridSize + 1) * (gridSize + 1) * 3;\n\n        let plainNormals = new Float32Array(gridSize3);\n\n        let plainVertices = new Float64Array(gridSize3);\n        let plainVerticesHigh = new Float32Array(gridSize3);\n        let plainVerticesLow = new Float32Array(gridSize3);\n        let normalMapNormals = new Float32Array(gsgs * 3);\n        let normalMapVertices = new Float64Array(gsgs * 3);\n\n        let ind = 0,\n            nmInd = 0;\n\n        for (let k = 0; k < gsgs; k++) {\n            let j = k % gs,\n                i = ~~(k / gs);\n\n            _projFunc(esw_lon + j * llStep, ene_lat - i * ltStep, heightFactor, worldPos);\n\n            let nx = worldPos.x * r2_x,\n                ny = worldPos.y * r2_y,\n                nz = worldPos.z * r2_z;\n            let l = 1.0 / Math.sqrt(nx * nx + ny * ny + nz * nz);\n            let nxl = nx * l,\n                nyl = ny * l,\n                nzl = nz * l;\n\n            rtcPos.x = worldPos.x - rtc_x;\n            rtcPos.y = worldPos.y - rtc_y;\n            rtcPos.z = worldPos.z - rtc_z;\n\n            normalMapVertices[nmInd] = rtcPos.x;\n            normalMapNormals[nmInd++] = nxl;\n\n            normalMapVertices[nmInd] = rtcPos.y;\n            normalMapNormals[nmInd++] = nyl;\n\n            normalMapVertices[nmInd] = rtcPos.z;\n            normalMapNormals[nmInd++] = nzl;\n\n            if (i % dg === 0 && j % dg === 0) {\n                doubleToTwoFloats(rtcPos, _tempHigh, _tempLow);\n\n                plainVertices[ind] = rtcPos.x;\n                plainVerticesHigh[ind] = _tempHigh.x;\n                plainVerticesLow[ind] = _tempLow.x;\n                plainNormals[ind++] = nxl;\n\n                plainVertices[ind] = rtcPos.y;\n                plainVerticesHigh[ind] = _tempHigh.y;\n                plainVerticesLow[ind] = _tempLow.y;\n                plainNormals[ind++] = nyl;\n\n                plainVertices[ind] = rtcPos.z;\n                plainVerticesHigh[ind] = _tempHigh.z;\n                plainVerticesLow[ind] = _tempLow.z;\n                plainNormals[ind++] = nzl;\n\n                if (worldPos.x < xmin) xmin = worldPos.x;\n                if (worldPos.x > xmax) xmax = worldPos.x;\n                if (worldPos.y < ymin) ymin = worldPos.y;\n                if (worldPos.y > ymax) ymax = worldPos.y;\n                if (worldPos.z < zmin) zmin = worldPos.z;\n                if (worldPos.z > zmax) zmax = worldPos.z;\n            }\n        }\n\n        let x = (xmax - xmin) * 0.5,\n            y = (ymax - ymin) * 0.5,\n            z = (zmax - zmin) * 0.5;\n\n        let plainRadius = Math.sqrt(x * x + y * y + z * z);\n\n        self.postMessage(\n            {\n                id: msg.data.params[0],\n                plainVertices: plainVertices,\n                plainVerticesHigh: plainVerticesHigh,\n                plainVerticesLow: plainVerticesLow,\n                plainNormals: plainNormals,\n                normalMapNormals: normalMapNormals,\n                normalMapVertices: normalMapVertices,\n                plainRadius: plainRadius,\n                relativeCenter: [rtc_x, rtc_y, rtc_z]\n            },\n            [\n                plainVertices.buffer,\n                plainVerticesHigh.buffer,\n                plainVerticesLow.buffer,\n                plainNormals.buffer,\n                normalMapNormals.buffer,\n                normalMapVertices.buffer\n            ]\n        );\n    }\n};\n"],"mappings":"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"}
+{"version":3,"file":"PlainSegmentWorker.worker-DJHXd0bF.js","names":["model","cached_ix","cached_iy","v00","v01","v10","v11","rawval","ix","iy","width","height","k","i","rawfile","HALF_PI","Math","PI","POLE","PI_BY_POLE","INV_POLE_BY_180","INV_PI_BY_180","INV_PI_BY_180_HALF_PI","RADIANS","INV_PI_BY_360","E2","A","_projFunc","Vec3","x","y","z","this","geodeticToCartesian","lon","lat","heightFactor","res","h","fy","rlatres","fx","rlonres","floor","offset","scale","getHeightMSL","latrad","lonrad","slt","sin","N","sqrt","nc","cos","geodeticToCartesianInverse","atan","exp","worldPos","rtcPos","_tempHigh","_tempLow","doubleToTwoFloats","v","high","low","doubleHigh","fround","self","onmessage","msg","data","params","rtc_x","rtc_y","rtc_z","xmin","xmax","ymin","ymax","zmin","zmax","gridSize","fgs","r2_x","r2_y","r2_z","maxFgs","max","llStep","ltStep","esw_lon","ene_lat","dg","gs","gsgs","gridSize3","plainNormals","Float32Array","plainVertices","Float64Array","plainVerticesHigh","plainVerticesLow","normalMapNormals","normalMapVertices","ind","nmInd","j","nx","ny","nz","l","nxl","nyl","nzl","plainRadius","postMessage","id","relativeCenter","buffer","a","r","e","l","n","f","d","M","m","y","w","x","c","z","u","h","i","p","b","g","A","F","v","I","P","V","q","N","C","H","L","R","j","k","B","D","E","G","J","K","O","Q","S","T"],"sources":["../../src/utils/PlainSegmentWorker.worker.js"],"sourcesContent":["\"use strict\";\n\nlet model = null;\n\nlet cached_ix = null;\nlet cached_iy = null;\nlet v00 = null;\nlet v01 = null;\nlet v10 = null;\nlet v11 = null;\n//let t = null;\n\nfunction rawval(ix, iy) {\n    if (iy < 0) {\n        iy = -iy;\n        ix += model.width / 2;\n    } else if (iy >= model.height) {\n        iy = 2 * (model.height - 1) - iy;\n        ix += model.width / 2;\n    }\n\n    if (ix < 0) {\n        ix += model.width;\n    } else if (ix >= model.width) {\n        ix -= model.width;\n    }\n\n    var k = (iy * model.width + ix) * 2 + model.i;\n\n    return (model.rawfile[k] << 8) | model.rawfile[k + 1];\n}\n\nfunction getHeightMSL(lon, lat) {\n    if (!model) return 0;\n\n    if (lon < 0) lon += 360.0;\n\n    var fy = (90 - lat) * model.rlatres;\n    var fx = lon * model.rlonres;\n    var iy = Math.floor(fy);\n    var ix = Math.floor(fx);\n\n    fx -= ix;\n    fy -= iy;\n\n    if (iy === model.height - 1) {\n        iy--;\n    }\n\n    if (cached_ix !== ix || cached_iy !== iy) {\n        cached_ix = ix;\n        cached_iy = iy;\n\n        v00 = rawval(ix, iy);\n        v01 = rawval(ix + 1, iy);\n        v10 = rawval(ix, iy + 1);\n        v11 = rawval(ix + 1, iy + 1);\n    }\n\n    let h = null;\n\n    var a = (1 - fx) * v00 + fx * v01;\n    var b = (1 - fx) * v10 + fx * v11;\n\n    h = (1 - fy) * a + fy * b;\n\n    return model.offset + model.scale * h;\n}\n\nconst HALF_PI = Math.PI * 0.5;\nconst POLE = 20037508.34;\nconst PI_BY_POLE = Math.PI / POLE;\nconst INV_POLE_BY_180 = 180.0 / POLE;\nconst INV_PI_BY_180 = 180.0 / Math.PI;\nconst INV_PI_BY_180_HALF_PI = INV_PI_BY_180 * HALF_PI;\nconst RADIANS = Math.PI / 180.0;\nconst INV_PI_BY_360 = INV_PI_BY_180 * 2.0;\n\nlet E2 = 0.0,\n    A = 0.0;\n\nlet _projFunc = null;\n\nconst Vec3 = function (x, y, z) {\n    this.x = x;\n    this.y = y;\n    this.z = z;\n};\n\nvar geodeticToCartesian = function (lon, lat, heightFactor, res) {\n    let h = getHeightMSL(lon, lat) * heightFactor;\n\n    let latrad = RADIANS * lat,\n        lonrad = RADIANS * lon;\n\n    let slt = Math.sin(latrad);\n\n    let N = A / Math.sqrt(1.0 - E2 * slt * slt);\n    let nc = (N + h) * Math.cos(latrad);\n\n    res.x = nc * Math.cos(lonrad);\n    res.y = nc * Math.sin(lonrad);\n    res.z = (N * (1 - E2) + h) * slt;\n};\n\nvar geodeticToCartesianInverse = function (lon, lat, heightFactor, res) {\n    geodeticToCartesian(\n        lon * INV_POLE_BY_180,\n        INV_PI_BY_360 * Math.atan(Math.exp(lat * PI_BY_POLE)) - INV_PI_BY_180_HALF_PI,\n        heightFactor,\n        res\n    );\n};\n\nvar worldPos = new Vec3(0.0, 0.0, 0.0);\nvar rtcPos = new Vec3(0.0, 0.0, 0.0);\nvar _tempHigh = new Vec3(0.0, 0.0, 0.0);\nvar _tempLow = new Vec3(0.0, 0.0, 0.0);\n\nvar doubleToTwoFloats = function (v, high, low) {\n    let x = v.x,\n        y = v.y,\n        z = v.z;\n\n    var doubleHigh;\n\n    if (x >= 0.0) {\n        doubleHigh = Math.floor(x / 65536.0) * 65536.0;\n        high.x = Math.fround(doubleHigh);\n        low.x = Math.fround(x - doubleHigh);\n    } else {\n        doubleHigh = Math.floor(-x / 65536.0) * 65536.0;\n        high.x = Math.fround(-doubleHigh);\n        low.x = Math.fround(x + doubleHigh);\n    }\n\n    if (y >= 0.0) {\n        doubleHigh = Math.floor(y / 65536.0) * 65536.0;\n        high.y = Math.fround(doubleHigh);\n        low.y = Math.fround(y - doubleHigh);\n    } else {\n        doubleHigh = Math.floor(-y / 65536.0) * 65536.0;\n        high.y = Math.fround(-doubleHigh);\n        low.y = Math.fround(y + doubleHigh);\n    }\n\n    if (z >= 0.0) {\n        doubleHigh = Math.floor(z / 65536.0) * 65536.0;\n        high.z = Math.fround(doubleHigh);\n        low.z = Math.fround(z - doubleHigh);\n    } else {\n        doubleHigh = Math.floor(-z / 65536.0) * 65536.0;\n        high.z = Math.fround(-doubleHigh);\n        low.z = Math.fround(z + doubleHigh);\n    }\n};\n\nself.onmessage = function (msg) {\n    if (msg.data.model) {\n        model = msg.data.model;\n        model.rawfile = msg.data.rawfile;\n    } else if (msg.data.params) {\n        let rtc_x = msg.data.params[14];\n        let rtc_y = msg.data.params[15];\n        let rtc_z = msg.data.params[16];\n\n        let xmin = 549755748352.0,\n            xmax = -549755748352.0,\n            ymin = 549755748352.0,\n            ymax = -549755748352.0,\n            zmin = 549755748352.0,\n            zmax = -549755748352.0;\n\n        E2 = msg.data.params[8];\n        A = msg.data.params[9];\n\n        let gridSize = msg.data.params[2],\n            fgs = msg.data.params[3],\n            r2_x = msg.data.params[10],\n            r2_y = msg.data.params[11],\n            r2_z = msg.data.params[12];\n\n        let heightFactor = msg.data.params[13];\n\n        if (msg.data.params[1] === 0.0) {\n            _projFunc = geodeticToCartesianInverse;\n        } else {\n            _projFunc = geodeticToCartesian;\n        }\n\n        let maxFgs = Math.max(fgs, gridSize);\n        let llStep = (msg.data.params[6] - msg.data.params[4]) / maxFgs;\n        let ltStep = (msg.data.params[7] - msg.data.params[5]) / maxFgs;\n\n        let esw_lon = msg.data.params[4],\n            ene_lat = msg.data.params[7];\n\n        let dg = Math.max(fgs / gridSize, 1.0),\n            gs = maxFgs + 1;\n\n        const gsgs = gs * gs;\n\n        const gridSize3 = (gridSize + 1) * (gridSize + 1) * 3;\n\n        let plainNormals = new Float32Array(gridSize3);\n\n        let plainVertices = new Float64Array(gridSize3);\n        let plainVerticesHigh = new Float32Array(gridSize3);\n        let plainVerticesLow = new Float32Array(gridSize3);\n        let normalMapNormals = new Float32Array(gsgs * 3);\n        let normalMapVertices = new Float64Array(gsgs * 3);\n\n        let ind = 0,\n            nmInd = 0;\n\n        for (let k = 0; k < gsgs; k++) {\n            let j = k % gs,\n                i = ~~(k / gs);\n\n            _projFunc(esw_lon + j * llStep, ene_lat - i * ltStep, heightFactor, worldPos);\n\n            let nx = worldPos.x * r2_x,\n                ny = worldPos.y * r2_y,\n                nz = worldPos.z * r2_z;\n            let l = 1.0 / Math.sqrt(nx * nx + ny * ny + nz * nz);\n            let nxl = nx * l,\n                nyl = ny * l,\n                nzl = nz * l;\n\n            rtcPos.x = worldPos.x - rtc_x;\n            rtcPos.y = worldPos.y - rtc_y;\n            rtcPos.z = worldPos.z - rtc_z;\n\n            normalMapVertices[nmInd] = rtcPos.x;\n            normalMapNormals[nmInd++] = nxl;\n\n            normalMapVertices[nmInd] = rtcPos.y;\n            normalMapNormals[nmInd++] = nyl;\n\n            normalMapVertices[nmInd] = rtcPos.z;\n            normalMapNormals[nmInd++] = nzl;\n\n            if (i % dg === 0 && j % dg === 0) {\n                doubleToTwoFloats(rtcPos, _tempHigh, _tempLow);\n\n                plainVertices[ind] = rtcPos.x;\n                plainVerticesHigh[ind] = _tempHigh.x;\n                plainVerticesLow[ind] = _tempLow.x;\n                plainNormals[ind++] = nxl;\n\n                plainVertices[ind] = rtcPos.y;\n                plainVerticesHigh[ind] = _tempHigh.y;\n                plainVerticesLow[ind] = _tempLow.y;\n                plainNormals[ind++] = nyl;\n\n                plainVertices[ind] = rtcPos.z;\n                plainVerticesHigh[ind] = _tempHigh.z;\n                plainVerticesLow[ind] = _tempLow.z;\n                plainNormals[ind++] = nzl;\n\n                if (worldPos.x < xmin) xmin = worldPos.x;\n                if (worldPos.x > xmax) xmax = worldPos.x;\n                if (worldPos.y < ymin) ymin = worldPos.y;\n                if (worldPos.y > ymax) ymax = worldPos.y;\n                if (worldPos.z < zmin) zmin = worldPos.z;\n                if (worldPos.z > zmax) zmax = worldPos.z;\n            }\n        }\n\n        let x = (xmax - xmin) * 0.5,\n            y = (ymax - ymin) * 0.5,\n            z = (zmax - zmin) * 0.5;\n\n        let plainRadius = Math.sqrt(x * x + y * y + z * z);\n\n        self.postMessage(\n            {\n                id: msg.data.params[0],\n                plainVertices: plainVertices,\n                plainVerticesHigh: plainVerticesHigh,\n                plainVerticesLow: plainVerticesLow,\n                plainNormals: plainNormals,\n                normalMapNormals: normalMapNormals,\n                normalMapVertices: normalMapVertices,\n                plainRadius: plainRadius,\n                relativeCenter: [rtc_x, rtc_y, rtc_z]\n            },\n            [\n                plainVertices.buffer,\n                plainVerticesHigh.buffer,\n                plainVerticesLow.buffer,\n                plainNormals.buffer,\n                normalMapNormals.buffer,\n                normalMapVertices.buffer\n            ]\n        );\n    }\n};\n"],"mappings":"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"}

package/lib/assets/RgbTerrainWorker.worker-BL6dQGZ3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RgbTerrainWorker.worker-BL6dQGZ3.js","names":["getGridCells","size","isNoDataValue","noDataValues","ndMin","ndMax","h","start","end","length","k","Math","abs","getParentHeight","oneByDz2","offsetX","offsetY","heights","i","j","skipPositiveHeights","parentGridSize","sqrt","floor","getEdgeHeight","p0","p1","p2","s0","s1","interpolateRow","pixels","offset","halfSteps","out","last","min","max","prev","averagePixels","ui","uj","noDataHeight","ki","kj","sum","count","i1","j1","_around","Uint8Array","compareNeighbours","around","a","b","ha","hb","findPeaks","scale","fill","r","row","rowStart","Int32Array","cols","isPeak","c","_deviations","Float32Array","sampleSubGrid","grid","row0","col0","cells","gridSize","outOffset","peaks","NaN","gs","outGs","step","src","dst","half","inner","pr0","ceil","pr1","pc0","pc1","pr","p","hi","m","y","ci","fy","top","bottom","vertexRow","x","cj","fx","h00","h01","h10","h11","surface","deviation","v","keepPeaks","createHeightsLevels","levels","decodeRow","subarray","pixelCenters","columns","rowColumns","lastRow","vi","u","needRow","set","c0","c1","c2","vj","createVertexGrid","tileLength","tilesCount","d","ctx","self","onmessage","e","id","params","data","parentData","decode","encoding","minHeight","resolution","heightFactor","parentOffsetX","parentOffsetY","parentZoomDiff","bitmap","rgbaData","canvas","width","OffscreenCanvas","getContext","willReadFrequently","clearRect","drawImage","getImageData","parentScale","outHeights","ndv","isTerrarium","pi","k4","g","height","isNoData","decodeRgbHeightsRow","err","console","error","close","postMessage","buffer","t","e","a","l","n","i","f","s","h","u","c","M","g","y","d","w","p","x","A","b","z","D","F","v","H","S","k","I","N","P","U","q"],"sources":["../../src/terrain/terrainUtils.ts","../../src/utils/RgbTerrainWorkerParams.ts","../../src/utils/RgbTerrainWorker.worker.js"],"sourcesContent":["import type { TypedArray } from \"../utils/shared\";\nimport type { Extent } from \"../Extent\";\n\nexport const RGB_ENCODING_CUSTOM = -1;\nexport const RGB_ENCODING_RGB = 0;\nexport const RGB_ENCODING_TERRARIUM = 1;\n\n/** Segment grid sizes by zoom of the elevation terrains. */\nexport const TERRAIN_GRID_SIZE_BY_ZOOM = [\n    64, 32, 16, 8, 8, 8, 16, 16, 16, 32, 32, 32, 32, 32, 32, 64, 64, 64, 32, 32, 16, 8\n];\n\n/** Writes a row of pixel heights, NaN for no data pixels. */\nexport type DecodeHeightsRowFunc = (row: number, outHeights: Float32Array) => void;\n\nexport interface IRgbDecodeParams {\n    encoding: number;\n    minHeight: number;\n    resolution: number;\n    heightFactor: number;\n    noDataValues: number[] | TypedArray;\n    parentData: number[] | TypedArray | null;\n    parentOffsetX: number;\n    parentOffsetY: number;\n    parentZoomDiff: number;\n    skipPositiveHeights: boolean;\n}\n\nexport interface IRgbHeightsParams {\n    decode: IRgbDecodeParams;\n    size: number;\n    gridSize: number;\n    levels: number;\n    noDataHeight: number;\n}\n\n/**\n * Returns pixel grid cells for the image size, 2^n and (2^n + 1) sizes only.\n * @param {number} size - Image size.\n * @returns {number} -\n */\nexport function getGridCells(size: number): number {\n    return (size & (size - 1)) === 0 ? size : size - 1;\n}\n\n/**\n * Returns vertex grid cells for the image size. 2^n images have vertices at the pixel centers and corners,\n * (2^n + 1) images are the grid itself.\n * @param {number} size - Image size.\n * @returns {number} -\n */\nexport function getVertexGridCells(size: number): number {\n    let cells = getGridCells(size);\n    return cells === size ? cells * 2 : cells;\n}\n\n/**\n * Returns subdivision levels of the image tile. Native zoom levels are not finer than the image pixels,\n * finer data comes with their own tiles. Levels above the native zooms go down to the vertex grid.\n * @param {number} size - Image size.\n * @param {number} gridSize - Tile grid size.\n * @param {number} tileZoom - Image tile zoom.\n * @param {number} maxZoom - Maximal terrain zoom.\n * @param {number} maxNativeZoom - Maximal zoom of the terrain tiles.\n * @returns {number} -\n */\nexport function getSubdivisionLevels(\n    size: number,\n    gridSize: number,\n    tileZoom: number,\n    maxZoom: number,\n    maxNativeZoom: number\n): number {\n    let pixelCells = getGridCells(size),\n        vertexCells = getVertexGridCells(size),\n        levels = 0;\n\n    for (let k = 1; tileZoom + k <= maxZoom; k++) {\n        if ((tileZoom + k > maxNativeZoom ? vertexCells : pixelCells) >> k < gridSize) {\n            break;\n        }\n        levels = k;\n    }\n\n    return levels;\n}\n\nfunction isNoDataValue(noDataValues: number[] | TypedArray, ndMin: number, ndMax: number, h: number): boolean {\n    if (h > 50000) {\n        return true;\n    }\n    if (h <= ndMin || h >= ndMax) {\n        return false;\n    }\n    let start = 0,\n        end = noDataValues.length - 1;\n    while (start <= end) {\n        let k = (start + end) >> 1;\n        if (Math.abs(noDataValues[k] - h) < 1e-3) {\n            return true;\n        } else if (noDataValues[k] < h) {\n            start = k + 1;\n        } else {\n            end = k - 1;\n        }\n    }\n    return false;\n}\n\nexport function getParentHeight(\n    oneByDz2: number,\n    offsetX: number,\n    offsetY: number,\n    heights: TypedArray | number[],\n    i: number,\n    j: number,\n    skipPositiveHeights?: boolean\n) {\n    let parentGridSize = Math.sqrt(heights.length);\n    let pi = Math.floor(offsetY * oneByDz2 * parentGridSize + i * oneByDz2),\n        pj = Math.floor(offsetX * oneByDz2 * parentGridSize + j * oneByDz2);\n    let h = heights[pi * parentGridSize + pj];\n    return skipPositiveHeights ? (h > 0 ? 0 : h) : h;\n}\n\n/**\n * Decodes \"rgb\" or \"terrarium\" encoded pixel row heights.\n * @param {number[] | TypedArray} rgbaData - Image RGBA data.\n * @param {number} row - Pixel row.\n * @param {number} size - Image size.\n * @param {number} parentScale - Parent grid cells by image grid cells.\n * @param {IRgbDecodeParams} p - Decode parameters.\n * @param {Float32Array} outHeights - Row heights.\n * @param {number} noDataHeight - Height for no data pixels.\n */\nexport function decodeRgbHeightsRow(\n    rgbaData: number[] | TypedArray,\n    row: number,\n    size: number,\n    parentScale: number,\n    p: IRgbDecodeParams,\n    outHeights: Float32Array,\n    noDataHeight: number\n) {\n    let ndv = p.noDataValues,\n        ndMin = ndv.length ? ndv[0] - 1e-3 : 0,\n        ndMax = ndv.length ? ndv[ndv.length - 1] + 1e-3 : 0;\n\n    let isTerrarium = p.encoding === RGB_ENCODING_TERRARIUM,\n        minHeight = p.minHeight,\n        resolution = p.resolution,\n        heightFactor = p.heightFactor,\n        parentData = p.parentData;\n\n    let pi = Math.floor(row * parentScale);\n\n    for (let j = 0, k4 = row * size * 4; j < size; j++, k4 += 4) {\n        let r = rgbaData[k4],\n            g = rgbaData[k4 + 1],\n            b = rgbaData[k4 + 2];\n\n        let height = isTerrarium\n            ? r * 256 + g + b / 256 - 32768\n            : r === 255\n              ? minHeight\n              : minHeight + resolution * (r * 65536 + g * 256 + b);\n\n        height *= heightFactor;\n\n        let isNoData = isNoDataValue(ndv, ndMin, ndMax, height);\n\n        if ((isNoData || height === 0) && parentData) {\n            height = getParentHeight(\n                p.parentZoomDiff,\n                p.parentOffsetX,\n                p.parentOffsetY,\n                parentData,\n                pi,\n                Math.floor(j * parentScale),\n                p.skipPositiveHeights\n            );\n            isNoData = isNoDataValue(ndv, ndMin, ndMax, height);\n        }\n\n        outHeights[j] = isNoData ? noDataHeight : height;\n    }\n}\n\n/**\n * Returns the height at the tile edge, extrapolated from the edge pixel p0 inwards through p1 and p2.\n * The slope is limited (minmod), so peaks, pits and slope breaks at the edge are not overshot.\n * @param {number} p0 - Edge pixel height.\n * @param {number} p1 - Next pixel height.\n * @param {number} p2 - Pixel height after the next.\n * @returns {number} -\n */\nexport function getEdgeHeight(p0: number, p1: number, p2: number): number {\n    let s0 = p0 - p1,\n        s1 = p1 - p2;\n    return p0 + 0.5 * (s0 * s1 <= 0 ? 0 : Math.abs(s0) < Math.abs(s1) ? s0 : s1);\n}\n\n/**\n * Returns the ground height at the point of the tile heights grid, on the grid triangles as they are rendered.\n * @param {number} x - Point x in the tile extent projection.\n * @param {number} y - Point y in the tile extent projection.\n * @param {Extent} extent - Tile extent.\n * @param {number[] | TypedArray} heights - Tile heights grid, rows from north to south.\n * @returns {number} -\n */\nexport function getGroundHeight(x: number, y: number, extent: Extent, heights: number[] | TypedArray): number {\n    let gs = Math.sqrt(heights.length),\n        cells = gs - 1,\n        col = ((x - extent.southWest.lon) / extent.getWidth()) * cells,\n        row = ((extent.northEast.lat - y) / extent.getHeight()) * cells,\n        j = Math.min(Math.max(Math.floor(col), 0), cells - 1),\n        i = Math.min(Math.max(Math.floor(row), 0), cells - 1),\n        fx = col - j,\n        fy = 1 - (row - i);\n\n    /*\n    v2-----------v3\n    |  \\         |\n    |     \\      |\n    |        \\   |\n    v0-----------v1\n    */\n    let k = i * gs + j,\n        h2 = heights[k],\n        h3 = heights[k + 1],\n        h0 = heights[k + gs],\n        h1 = heights[k + gs + 1];\n\n    return fx + fy <= 1 ? h0 + fx * (h1 - h0) + fy * (h2 - h0) : h3 + (1 - fx) * (h2 - h3) + (1 - fy) * (h1 - h3);\n}\n\n/**\n * Writes the pixel row heights at the vertex columns: the edges, the pixel corners and, with half pixel steps,\n * the pixel centers.\n */\nfunction interpolateRow(pixels: Float32Array, offset: number, size: number, halfSteps: number, out: Float32Array) {\n    let last = offset + size - 1;\n\n    out[0] = getEdgeHeight(pixels[offset], pixels[Math.min(offset + 1, last)], pixels[Math.min(offset + 2, last)]);\n\n    out[(size * 2) / halfSteps] = getEdgeHeight(\n        pixels[last],\n        pixels[Math.max(last - 1, offset)],\n        pixels[Math.max(last - 2, offset)]\n    );\n\n    if (halfSteps === 1) {\n        let prev = pixels[offset];\n        out[1] = prev;\n        for (let k = 1; k < size; k++) {\n            let h = pixels[offset + k];\n            out[k * 2] = 0.5 * (prev + h);\n            out[k * 2 + 1] = h;\n            prev = h;\n        }\n    } else {\n        for (let k = 1; k < size; k++) {\n            out[k] = 0.5 * (pixels[offset + k - 1] + pixels[offset + k]);\n        }\n    }\n}\n\n/**\n * Converts size x size pixel heights to the vertex grid in the pixel corners, (size + 1) x (size + 1),\n * or in the pixel centers and corners, (2 * size + 1) x (2 * size + 1). Pixel center vertices keep the pixel heights.\n * @param {Float32Array} pixels - Pixel heights, NaN for no data.\n * @param {number} size - Image size.\n * @param {number} noDataHeight - Height for vertices without data around.\n * @param {boolean} [pixelCenters=true] - Vertices at the pixel centers too.\n * @returns {Float32Array} -\n */\nexport function createVertexGrid(\n    pixels: Float32Array,\n    size: number,\n    noDataHeight: number,\n    pixelCenters: boolean = true\n): Float32Array {\n    let halfSteps = pixelCenters ? 1 : 2,\n        gs = (size * 2) / halfSteps + 1,\n        last = size - 1;\n\n    // Heights at the vertex columns of the last three pixel rows, pixel row r is kept at (r % 3)\n    let columns = new Float32Array(gs * 3),\n        rowColumns = [columns.subarray(0, gs), columns.subarray(gs, gs * 2), columns.subarray(gs * 2)],\n        lastRow = -1;\n\n    let out = new Float32Array(gs * gs);\n\n    for (let vi = 0; vi < gs; vi++) {\n        let u = vi * halfSteps,\n            k = u >> 1,\n            dst = vi * gs;\n\n        let needRow = u === 0 ? Math.min(2, last) : Math.min(k, last);\n\n        while (lastRow < needRow) {\n            lastRow++;\n            interpolateRow(pixels, lastRow * size, size, halfSteps, rowColumns[lastRow % 3]);\n        }\n\n        if (u & 1) {\n            out.set(rowColumns[k % 3], dst);\n        } else if (k === 0 || k === size) {\n            let c0 = rowColumns[(k === 0 ? 0 : last) % 3],\n                c1 = rowColumns[(k === 0 ? Math.min(1, last) : Math.max(last - 1, 0)) % 3],\n                c2 = rowColumns[(k === 0 ? Math.min(2, last) : Math.max(last - 2, 0)) % 3];\n\n            for (let vj = 0; vj < gs; vj++) {\n                out[dst + vj] = getEdgeHeight(c0[vj], c1[vj], c2[vj]);\n            }\n        } else {\n            let c0 = rowColumns[(k - 1) % 3],\n                c1 = rowColumns[k % 3];\n\n            for (let vj = 0; vj < gs; vj++) {\n                out[dst + vj] = 0.5 * (c0[vj] + c1[vj]);\n            }\n        }\n\n        for (let vj = 0; vj < gs; vj++) {\n            if (out[dst + vj] !== out[dst + vj]) {\n                out[dst + vj] = averagePixels(pixels, size, u, vj * halfSteps, noDataHeight);\n            }\n        }\n    }\n\n    return out;\n}\n\nfunction averagePixels(pixels: Float32Array, size: number, ui: number, uj: number, noDataHeight: number): number {\n    let last = size - 1,\n        ki = ui >> 1,\n        kj = uj >> 1,\n        sum = 0,\n        count = 0;\n\n    for (let i = Math.max(ki - 1, 0), i1 = Math.min(ki + (ui & 1), last); i <= i1; i++) {\n        for (let j = Math.max(kj - 1, 0), j1 = Math.min(kj + (uj & 1), last); j <= j1; j++) {\n            let h = pixels[i * size + j];\n            if (h === h) {\n                sum += h;\n                count++;\n            }\n        }\n    }\n\n    return count ? sum / count : noDataHeight;\n}\n\n/** Peak and pit pixels, and their place in the vertex grid. */\nexport interface IGridPeaks {\n    pixels: Float32Array;\n    size: number;\n    /** Peaks by pixel rows, columns of row r are cols[rowStart[r]] ... cols[rowStart[r + 1] - 1]. */\n    rowStart: Int32Array;\n    cols: Int32Array;\n    /** 1 for peaks, 0 for pits. */\n    isPeak: Uint8Array;\n    /** Pixel p is at (p + offset) * scale vertex. */\n    offset: number;\n    scale: number;\n}\n\nconst HIGHER_AROUND = 1,\n    LOWER_AROUND = 2;\n\nlet _around = new Uint8Array(0);\n\n/** Marks pixels a and b with the neighbour higher or lower flags, NaN pixels are not compared. */\nfunction compareNeighbours(pixels: Float32Array, around: Uint8Array, a: number, b: number) {\n    let ha = pixels[a],\n        hb = pixels[b];\n\n    if (hb > ha) {\n        around[a] |= HIGHER_AROUND;\n        around[b] |= LOWER_AROUND;\n    } else if (hb < ha) {\n        around[a] |= LOWER_AROUND;\n        around[b] |= HIGHER_AROUND;\n    }\n}\n\n/**\n * Finds the pixels that are not lower (peaks) or not higher (pits) than the pixels around,\n * and differ from at least one of them.\n * @param {Float32Array} pixels - Pixel heights, NaN for no data.\n * @param {number} size - Image size.\n * @param {number} offset - Pixel p is at (p + offset) * scale vertex of the grid.\n * @param {number} scale - Grid vertices by pixel.\n * @returns {IGridPeaks} -\n */\nexport function findPeaks(pixels: Float32Array, size: number, offset: number, scale: number): IGridPeaks {\n    let last = size - 1,\n        length = size * size;\n\n    if (_around.length < length) {\n        _around = new Uint8Array(length);\n    } else {\n        _around.fill(0, 0, length);\n    }\n\n    let around = _around;\n\n    // Every neighbour pair is compared once, in 2x2 squares a b / c d: a-b, a-c, a-d and b-c\n    for (let r = 0; r < last; r++) {\n        let row = r * size;\n        for (let k = row, end = row + last; k < end; k++) {\n            compareNeighbours(pixels, around, k, k + 1);\n            compareNeighbours(pixels, around, k, k + size);\n            compareNeighbours(pixels, around, k, k + size + 1);\n            compareNeighbours(pixels, around, k + 1, k + size);\n        }\n        compareNeighbours(pixels, around, row + last, row + last + size);\n    }\n    for (let k = last * size, end = k + last; k < end; k++) {\n        compareNeighbours(pixels, around, k, k + 1);\n    }\n\n    let rowStart = new Int32Array(size + 1),\n        count = 0;\n\n    for (let k = 0; k < length; k++) {\n        if (around[k] === HIGHER_AROUND || around[k] === LOWER_AROUND) {\n            count++;\n        }\n    }\n\n    let cols = new Int32Array(count),\n        isPeak = new Uint8Array(count);\n\n    count = 0;\n\n    for (let r = 0; r < size; r++) {\n        rowStart[r] = count;\n        for (let c = 0, k = r * size; c < size; c++, k++) {\n            if (around[k] === HIGHER_AROUND || around[k] === LOWER_AROUND) {\n                cols[count] = c;\n                isPeak[count] = around[k] === LOWER_AROUND ? 1 : 0;\n                count++;\n            }\n        }\n    }\n\n    rowStart[size] = count;\n\n    return { pixels, size, rowStart, cols, isPeak, offset, scale };\n}\n\n// Peak deviations of the sampled grid vertices, reused\nlet _deviations = new Float32Array(0);\n\n/**\n * Takes (gridSize + 1) x (gridSize + 1) vertices of the cells x cells square starting at\n * the row0, col0 vertex of the (size + 1) x (size + 1) grid. Cells must be gridSize multiplied by a power of two.\n *\n * With peaks, peaks and pits are moved to the nearest inner vertices, slopes and edge vertices stay sampled.\n */\nexport function sampleSubGrid(\n    grid: Float32Array,\n    size: number,\n    row0: number,\n    col0: number,\n    cells: number,\n    gridSize: number,\n    out: Float32Array = new Float32Array((gridSize + 1) * (gridSize + 1)),\n    outOffset: number = 0,\n    peaks: IGridPeaks | null = null,\n    noDataHeight: number = NaN\n): Float32Array {\n    let gs = size + 1,\n        outGs = gridSize + 1,\n        step = cells / gridSize;\n\n    for (let i = 0; i < outGs; i++) {\n        let src = (row0 + i * step) * gs + col0,\n            dst = outOffset + i * outGs;\n        for (let j = 0; j < outGs; j++) {\n            out[dst + j] = grid[src + j * step];\n        }\n    }\n\n    if (peaks && step > 1 && gridSize > 1) {\n        keepPeaks(grid, gs, row0, col0, cells, gridSize, out, outOffset, peaks, noDataHeight);\n    }\n\n    return out;\n}\n\nfunction keepPeaks(\n    grid: Float32Array,\n    gs: number,\n    row0: number,\n    col0: number,\n    cells: number,\n    gridSize: number,\n    out: Float32Array,\n    outOffset: number,\n    peaks: IGridPeaks,\n    noDataHeight: number\n) {\n    let outGs = gridSize + 1,\n        step = cells / gridSize,\n        half = step >> 1,\n        inner = gridSize - 1,\n        { pixels, size, rowStart, cols, isPeak, offset, scale } = peaks;\n\n    // Pixels in the square\n    let pr0 = Math.max(Math.ceil(row0 / scale - offset), 0),\n        pr1 = Math.min(Math.floor((row0 + cells) / scale - offset), size - 1),\n        pc0 = Math.max(Math.ceil(col0 / scale - offset), 0),\n        pc1 = Math.min(Math.floor((col0 + cells) / scale - offset), size - 1);\n\n    if (_deviations.length < outGs * outGs) {\n        _deviations = new Float32Array(outGs * outGs);\n    }\n\n    _deviations.fill(0, 0, outGs * outGs);\n\n    for (let pr = pr0; pr <= pr1; pr++) {\n        let p = rowStart[pr],\n            end = rowStart[pr + 1];\n\n        for (let hi = end; p < hi;) {\n            let m = (p + hi) >> 1;\n            if (cols[m] < pc0) {\n                p = m + 1;\n            } else {\n                hi = m;\n            }\n        }\n\n        if (p === end || cols[p] > pc1) {\n            continue;\n        }\n\n        let y = (pr + offset) * scale - row0,\n            ci = Math.min(Math.floor(y / step), inner),\n            fy = y / step - ci,\n            i = Math.min(Math.max(Math.floor((y + half) / step), 1), inner),\n            top = (row0 + ci * step) * gs + col0,\n            bottom = top + step * gs,\n            vertexRow = (row0 + i * step) * gs + col0;\n\n        for (; p < end && cols[p] <= pc1; p++) {\n            let x = (cols[p] + offset) * scale - col0,\n                cj = Math.min(Math.floor(x / step), inner),\n                fx = x / step - cj,\n                k = cj * step;\n\n            let h00 = grid[top + k],\n                h01 = grid[top + k + step],\n                h10 = grid[bottom + k],\n                h11 = grid[bottom + k + step];\n\n            if (h00 === noDataHeight || h01 === noDataHeight || h10 === noDataHeight || h11 === noDataHeight) {\n                continue;\n            }\n\n            let surface = (1 - fy) * ((1 - fx) * h00 + fx * h01) + fy * ((1 - fx) * h10 + fx * h11),\n                h = pixels[pr * size + cols[p]],\n                deviation = isPeak[p] ? h - surface : surface - h;\n\n            if (deviation <= 0 || h === noDataHeight) {\n                continue;\n            }\n\n            let j = Math.min(Math.max(Math.floor((x + half) / step), 1), inner),\n                v = i * outGs + j;\n\n            if (deviation > _deviations[v] && deviation > Math.abs(surface - grid[vertexRow + j * step])) {\n                _deviations[v] = deviation;\n                out[outOffset + v] = h;\n            }\n        }\n    }\n}\n\n/**\n * Returns (gridSize + 1) x (gridSize + 1) mesh heights of (fileGridSize + 1) x (fileGridSize + 1) elevations,\n * their peaks and pits are moved to the nearest mesh vertices.\n * @param {Float32Array} elevations - Elevations grid, rows from north to south.\n * @param {number} fileGridSize - Elevations grid size.\n * @param {number} gridSize - Mesh grid size, fileGridSize divided by a power of two.\n * @param {number} noDataHeight - Height of no data elevations.\n * @param {Float32Array} [out] - Mesh heights.\n * @returns {Float32Array} -\n */\nexport function getMeshHeights(\n    elevations: Float32Array,\n    fileGridSize: number,\n    gridSize: number,\n    noDataHeight: number,\n    out: Float32Array = new Float32Array((gridSize + 1) * (gridSize + 1))\n): Float32Array {\n    return sampleSubGrid(\n        elevations,\n        fileGridSize,\n        0,\n        0,\n        fileGridSize,\n        gridSize,\n        out,\n        0,\n        findPeaks(elevations, fileGridSize + 1, 0, 1),\n        noDataHeight\n    );\n}\n\n/**\n * Creates the tile heights grid and its subdivision levels, each tile is (gridSize + 1) x (gridSize + 1).\n * Output order is the tile itself, then 2x2 tiles of the first level, 4x4 of the second and so on, row by row.\n * Peaks and pits of the pixels stay in all the levels.\n * @param {number} size - Image size, 2^n or (2^n + 1).\n * @param {number} gridSize - Tile grid size.\n * @param {number} levels - Subdivision levels.\n * @param {DecodeHeightsRowFunc} decodeRow - Decodes pixel row heights, NaN for no data.\n * @param {number} noDataHeight - Height for vertices without data.\n * @returns {Float32Array} -\n */\nexport function createHeightsLevels(\n    size: number,\n    gridSize: number,\n    levels: number,\n    decodeRow: DecodeHeightsRowFunc,\n    noDataHeight: number\n): Float32Array {\n    let pixels = new Float32Array(size * size);\n\n    for (let row = 0; row < size; row++) {\n        decodeRow(row, pixels.subarray(row * size, (row + 1) * size));\n    }\n\n    let grid: Float32Array, cells: number, peaks: IGridPeaks;\n\n    if (getGridCells(size) === size) {\n        // Vertices at the pixel centers are needed when the last level is finer than the pixels\n        let pixelCenters = size >> levels < gridSize;\n        grid = createVertexGrid(pixels, size, noDataHeight, pixelCenters);\n        cells = pixelCenters ? size * 2 : size;\n        peaks = findPeaks(pixels, size, 0.5, cells / size);\n    } else {\n        peaks = findPeaks(pixels, size, 0, 1);\n        for (let k = 0; k < pixels.length; k++) {\n            if (pixels[k] !== pixels[k]) {\n                pixels[k] = noDataHeight;\n            }\n        }\n        grid = pixels;\n        cells = size - 1;\n    }\n\n    let tileLength = (gridSize + 1) * (gridSize + 1),\n        tilesCount = 0;\n\n    for (let k = 0; k <= levels; k++) {\n        tilesCount += 1 << (2 * k);\n    }\n\n    let out = new Float32Array(tilesCount * tileLength);\n\n    for (let k = 0, c = cells, offset = 0; k <= levels; k++, c >>= 1) {\n        let d = 1 << k;\n        for (let i = 0; i < d; i++) {\n            for (let j = 0; j < d; j++) {\n                sampleSubGrid(grid, cells, i * c, j * c, c, gridSize, out, offset, peaks, noDataHeight);\n                offset += tileLength;\n            }\n        }\n    }\n\n    return out;\n}\n","import type { IRgbHeightsParams } from \"../terrain/terrainUtils\";\n\nconst PARAMS_ID = 0,\n    PARAMS_SIZE = 1,\n    PARAMS_GRID_SIZE = 2,\n    PARAMS_LEVELS = 3,\n    PARAMS_ENCODING = 4,\n    PARAMS_MIN_HEIGHT = 5,\n    PARAMS_RESOLUTION = 6,\n    PARAMS_HEIGHT_FACTOR = 7,\n    PARAMS_PARENT_OFFSET_X = 8,\n    PARAMS_PARENT_OFFSET_Y = 9,\n    PARAMS_PARENT_ZOOM_DIFF = 10,\n    PARAMS_SKIP_POSITIVE_HEIGHTS = 11,\n    PARAMS_NO_DATA_HEIGHT = 12,\n    PARAMS_NO_DATA_VALUES = 13;\n\n/**\n * Packs height parameters to the buffer for the worker message.\n * @param {number} id - Worker task id.\n * @param {IRgbHeightsParams} p - Heights parameters, parent data is sent separately.\n * @returns {Float64Array} -\n */\nexport function packRgbHeightsParams(id: number, p: IRgbHeightsParams): Float64Array {\n    let d = p.decode,\n        ndv = d.noDataValues;\n    let params = new Float64Array(PARAMS_NO_DATA_VALUES + ndv.length);\n\n    params[PARAMS_ID] = id;\n    params[PARAMS_SIZE] = p.size;\n    params[PARAMS_GRID_SIZE] = p.gridSize;\n    params[PARAMS_LEVELS] = p.levels;\n    params[PARAMS_ENCODING] = d.encoding;\n    params[PARAMS_MIN_HEIGHT] = d.minHeight;\n    params[PARAMS_RESOLUTION] = d.resolution;\n    params[PARAMS_HEIGHT_FACTOR] = d.heightFactor;\n    params[PARAMS_PARENT_OFFSET_X] = d.parentOffsetX;\n    params[PARAMS_PARENT_OFFSET_Y] = d.parentOffsetY;\n    params[PARAMS_PARENT_ZOOM_DIFF] = d.parentZoomDiff;\n    params[PARAMS_SKIP_POSITIVE_HEIGHTS] = d.skipPositiveHeights ? 1 : 0;\n    params[PARAMS_NO_DATA_HEIGHT] = p.noDataHeight;\n\n    for (let i = 0; i < ndv.length; i++) {\n        params[PARAMS_NO_DATA_VALUES + i] = ndv[i];\n    }\n    return params;\n}\n\n/**\n * Unpacks height parameters from the worker message buffer.\n * @param {Float64Array} params - Packed parameters.\n * @param {Float32Array | null} parentData - Parent segment elevations.\n * @returns {Array} - Task id and parameters (exactly 2 entries).\n */\nexport function unpackRgbHeightsParams(\n    params: Float64Array,\n    parentData: Float32Array | null\n): [number, IRgbHeightsParams] {\n    return [\n        params[PARAMS_ID],\n        {\n            decode: {\n                encoding: params[PARAMS_ENCODING],\n                minHeight: params[PARAMS_MIN_HEIGHT],\n                resolution: params[PARAMS_RESOLUTION],\n                heightFactor: params[PARAMS_HEIGHT_FACTOR],\n                noDataValues: params.subarray(PARAMS_NO_DATA_VALUES),\n                parentData: parentData,\n                parentOffsetX: params[PARAMS_PARENT_OFFSET_X],\n                parentOffsetY: params[PARAMS_PARENT_OFFSET_Y],\n                parentZoomDiff: params[PARAMS_PARENT_ZOOM_DIFF],\n                skipPositiveHeights: params[PARAMS_SKIP_POSITIVE_HEIGHTS] === 1\n            },\n            size: params[PARAMS_SIZE],\n            gridSize: params[PARAMS_GRID_SIZE],\n            levels: params[PARAMS_LEVELS],\n            noDataHeight: params[PARAMS_NO_DATA_HEIGHT]\n        }\n    ];\n}\n","\"use strict\";\n//\n// RGB terrain heights worker\n//\nimport { createHeightsLevels, decodeRgbHeightsRow, getGridCells } from \"../terrain/terrainUtils\";\nimport { unpackRgbHeightsParams } from \"./RgbTerrainWorkerParams\";\n\nlet ctx = null;\n\nfunction getImageData(bitmap, size) {\n    if (!ctx || ctx.canvas.width !== size) {\n        ctx = new OffscreenCanvas(size, size).getContext(\"2d\", {\n            willReadFrequently: true\n        });\n    }\n\n    ctx.clearRect(0, 0, size, size);\n    ctx.drawImage(bitmap, 0, 0);\n\n    return ctx.getImageData(0, 0, size, size).data;\n}\n\nself.onmessage = function (e) {\n    const [id, p] = unpackRgbHeightsParams(e.data.params, e.data.parentData);\n    const bitmap = e.data.bitmap;\n\n    let heights = null;\n\n    try {\n        const rgbaData = getImageData(bitmap, p.size);\n        const parentScale = p.gridSize / getGridCells(p.size);\n\n        heights = createHeightsLevels(\n            p.size,\n            p.gridSize,\n            p.levels,\n            (row, outHeights) => decodeRgbHeightsRow(rgbaData, row, p.size, parentScale, p.decode, outHeights, NaN),\n            p.noDataHeight\n        );\n    } catch (err) {\n        console.error(err);\n    }\n\n    bitmap.close();\n\n    self.postMessage(\n        {\n            id: id,\n            heights: heights\n        },\n        heights ? [heights.buffer] : []\n    );\n};\n"],"mappings":"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"}

package/lib/assets/TerrainWorker.worker-DIGKd23M.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TerrainWorker.worker-DIGKd23M.js","names":["_around","Uint8Array","compareNeighbours","pixels","around","a","b","ha","hb","_deviations","Float32Array","sampleSubGrid","grid","size","row0","col0","cells","gridSize","out","outOffset","peaks","noDataHeight","NaN","gs","outGs","step","i","src","dst","j","half","inner","rowStart","cols","isPeak","offset","scale","pr0","Math","max","ceil","pr1","min","floor","pc0","pc1","length","fill","pr","p","end","hi","m","y","ci","fy","top","bottom","vertexRow","x","cj","fx","k","h00","h01","h10","h11","surface","h","deviation","v","abs","keepPeaks","getMeshHeights","elevations","fileGridSize","last","r","row","Int32Array","count","c","findPeaks","checkNoDataValue","noDataValues","value","arr","start","binarySearchFast","Vec3","z","this","doubleToTwoFloats","high","low","doubleHigh","fround","prototype","sub","add","cross","normalize","sqrt","distance","blerp","fQ11","fQ21","fQ12","fQ22","_tempVec","_rtcTempVec","_tempHigh","_tempLow","_meshHeights","self","onmessage","e","data","this_plainVertices","this_plainNormals","this_normalMapVertices","this_normalMapNormals","heightFactor","id","rtc_x","relativeCenter","rtc_y","rtc_z","xmin","xmax","ymin","ymax","zmin","zmax","r2min","Infinity","r2max","fileGridSize_one","fileGridSize_one_x2","tgs","dg","hf","normalMapNormals","normalMapVertices","vInd","noDataInd","gsgs3","terrainVertices","Float64Array","terrainVerticesHigh","terrainVerticesLow","noDataVertices","nv","nn","meshHeights","hInd0","vInd0","currElv","h0","v0","currVert","nextVert","nextElv","eps","mv","meshElv","mh","r2_v0","rtc_v0","hInd1","vInd1","elv","h1","v1","hInd2","vInd2","h2","v2","hInd3","vInd3","h3","v3","e10","e20","e30","sw","ne","n0","oneSize","gsgs","fgsOne","ii","ij","qii","qij","hlt_ind","hrt_ind","hlb_ind","hrb_ind","h_lt","h_rt","h_lb","h_rb","i3","r2_tmp","set","v0ind","v1ind","v2ind","v3ind","postMessage","bounds","radiusRange","buffer","t","e","n","r","o","a","l","y","u","z","s","f","x","M","c","w","d","m","v","p","A","b","g","F","V","N","q","C","U","h","_","S","k","D","I","i","P","H","j","B","E","G","J","K","O","Q","T","W","X","Y","Z","$","tt","et","rt","at","nt","ot","lt","it","st","ft","ht","yt","ut","zt","xt","Mt","ct","wt","dt","mt","vt","pt","At","bt"],"sources":["../../src/terrain/terrainUtils.ts","../../src/utils/TerrainWorker.worker.js"],"sourcesContent":["import type { TypedArray } from \"../utils/shared\";\nimport type { Extent } from \"../Extent\";\n\nexport const RGB_ENCODING_CUSTOM = -1;\nexport const RGB_ENCODING_RGB = 0;\nexport const RGB_ENCODING_TERRARIUM = 1;\n\n/** Segment grid sizes by zoom of the elevation terrains. */\nexport const TERRAIN_GRID_SIZE_BY_ZOOM = [\n    64, 32, 16, 8, 8, 8, 16, 16, 16, 32, 32, 32, 32, 32, 32, 64, 64, 64, 32, 32, 16, 8\n];\n\n/** Writes a row of pixel heights, NaN for no data pixels. */\nexport type DecodeHeightsRowFunc = (row: number, outHeights: Float32Array) => void;\n\nexport interface IRgbDecodeParams {\n    encoding: number;\n    minHeight: number;\n    resolution: number;\n    heightFactor: number;\n    noDataValues: number[] | TypedArray;\n    parentData: number[] | TypedArray | null;\n    parentOffsetX: number;\n    parentOffsetY: number;\n    parentZoomDiff: number;\n    skipPositiveHeights: boolean;\n}\n\nexport interface IRgbHeightsParams {\n    decode: IRgbDecodeParams;\n    size: number;\n    gridSize: number;\n    levels: number;\n    noDataHeight: number;\n}\n\n/**\n * Returns pixel grid cells for the image size, 2^n and (2^n + 1) sizes only.\n * @param {number} size - Image size.\n * @returns {number} -\n */\nexport function getGridCells(size: number): number {\n    return (size & (size - 1)) === 0 ? size : size - 1;\n}\n\n/**\n * Returns vertex grid cells for the image size. 2^n images have vertices at the pixel centers and corners,\n * (2^n + 1) images are the grid itself.\n * @param {number} size - Image size.\n * @returns {number} -\n */\nexport function getVertexGridCells(size: number): number {\n    let cells = getGridCells(size);\n    return cells === size ? cells * 2 : cells;\n}\n\n/**\n * Returns subdivision levels of the image tile. Native zoom levels are not finer than the image pixels,\n * finer data comes with their own tiles. Levels above the native zooms go down to the vertex grid.\n * @param {number} size - Image size.\n * @param {number} gridSize - Tile grid size.\n * @param {number} tileZoom - Image tile zoom.\n * @param {number} maxZoom - Maximal terrain zoom.\n * @param {number} maxNativeZoom - Maximal zoom of the terrain tiles.\n * @returns {number} -\n */\nexport function getSubdivisionLevels(\n    size: number,\n    gridSize: number,\n    tileZoom: number,\n    maxZoom: number,\n    maxNativeZoom: number\n): number {\n    let pixelCells = getGridCells(size),\n        vertexCells = getVertexGridCells(size),\n        levels = 0;\n\n    for (let k = 1; tileZoom + k <= maxZoom; k++) {\n        if ((tileZoom + k > maxNativeZoom ? vertexCells : pixelCells) >> k < gridSize) {\n            break;\n        }\n        levels = k;\n    }\n\n    return levels;\n}\n\nfunction isNoDataValue(noDataValues: number[] | TypedArray, ndMin: number, ndMax: number, h: number): boolean {\n    if (h > 50000) {\n        return true;\n    }\n    if (h <= ndMin || h >= ndMax) {\n        return false;\n    }\n    let start = 0,\n        end = noDataValues.length - 1;\n    while (start <= end) {\n        let k = (start + end) >> 1;\n        if (Math.abs(noDataValues[k] - h) < 1e-3) {\n            return true;\n        } else if (noDataValues[k] < h) {\n            start = k + 1;\n        } else {\n            end = k - 1;\n        }\n    }\n    return false;\n}\n\nexport function getParentHeight(\n    oneByDz2: number,\n    offsetX: number,\n    offsetY: number,\n    heights: TypedArray | number[],\n    i: number,\n    j: number,\n    skipPositiveHeights?: boolean\n) {\n    let parentGridSize = Math.sqrt(heights.length);\n    let pi = Math.floor(offsetY * oneByDz2 * parentGridSize + i * oneByDz2),\n        pj = Math.floor(offsetX * oneByDz2 * parentGridSize + j * oneByDz2);\n    let h = heights[pi * parentGridSize + pj];\n    return skipPositiveHeights ? (h > 0 ? 0 : h) : h;\n}\n\n/**\n * Decodes \"rgb\" or \"terrarium\" encoded pixel row heights.\n * @param {number[] | TypedArray} rgbaData - Image RGBA data.\n * @param {number} row - Pixel row.\n * @param {number} size - Image size.\n * @param {number} parentScale - Parent grid cells by image grid cells.\n * @param {IRgbDecodeParams} p - Decode parameters.\n * @param {Float32Array} outHeights - Row heights.\n * @param {number} noDataHeight - Height for no data pixels.\n */\nexport function decodeRgbHeightsRow(\n    rgbaData: number[] | TypedArray,\n    row: number,\n    size: number,\n    parentScale: number,\n    p: IRgbDecodeParams,\n    outHeights: Float32Array,\n    noDataHeight: number\n) {\n    let ndv = p.noDataValues,\n        ndMin = ndv.length ? ndv[0] - 1e-3 : 0,\n        ndMax = ndv.length ? ndv[ndv.length - 1] + 1e-3 : 0;\n\n    let isTerrarium = p.encoding === RGB_ENCODING_TERRARIUM,\n        minHeight = p.minHeight,\n        resolution = p.resolution,\n        heightFactor = p.heightFactor,\n        parentData = p.parentData;\n\n    let pi = Math.floor(row * parentScale);\n\n    for (let j = 0, k4 = row * size * 4; j < size; j++, k4 += 4) {\n        let r = rgbaData[k4],\n            g = rgbaData[k4 + 1],\n            b = rgbaData[k4 + 2];\n\n        let height = isTerrarium\n            ? r * 256 + g + b / 256 - 32768\n            : r === 255\n              ? minHeight\n              : minHeight + resolution * (r * 65536 + g * 256 + b);\n\n        height *= heightFactor;\n\n        let isNoData = isNoDataValue(ndv, ndMin, ndMax, height);\n\n        if ((isNoData || height === 0) && parentData) {\n            height = getParentHeight(\n                p.parentZoomDiff,\n                p.parentOffsetX,\n                p.parentOffsetY,\n                parentData,\n                pi,\n                Math.floor(j * parentScale),\n                p.skipPositiveHeights\n            );\n            isNoData = isNoDataValue(ndv, ndMin, ndMax, height);\n        }\n\n        outHeights[j] = isNoData ? noDataHeight : height;\n    }\n}\n\n/**\n * Returns the height at the tile edge, extrapolated from the edge pixel p0 inwards through p1 and p2.\n * The slope is limited (minmod), so peaks, pits and slope breaks at the edge are not overshot.\n * @param {number} p0 - Edge pixel height.\n * @param {number} p1 - Next pixel height.\n * @param {number} p2 - Pixel height after the next.\n * @returns {number} -\n */\nexport function getEdgeHeight(p0: number, p1: number, p2: number): number {\n    let s0 = p0 - p1,\n        s1 = p1 - p2;\n    return p0 + 0.5 * (s0 * s1 <= 0 ? 0 : Math.abs(s0) < Math.abs(s1) ? s0 : s1);\n}\n\n/**\n * Returns the ground height at the point of the tile heights grid, on the grid triangles as they are rendered.\n * @param {number} x - Point x in the tile extent projection.\n * @param {number} y - Point y in the tile extent projection.\n * @param {Extent} extent - Tile extent.\n * @param {number[] | TypedArray} heights - Tile heights grid, rows from north to south.\n * @returns {number} -\n */\nexport function getGroundHeight(x: number, y: number, extent: Extent, heights: number[] | TypedArray): number {\n    let gs = Math.sqrt(heights.length),\n        cells = gs - 1,\n        col = ((x - extent.southWest.lon) / extent.getWidth()) * cells,\n        row = ((extent.northEast.lat - y) / extent.getHeight()) * cells,\n        j = Math.min(Math.max(Math.floor(col), 0), cells - 1),\n        i = Math.min(Math.max(Math.floor(row), 0), cells - 1),\n        fx = col - j,\n        fy = 1 - (row - i);\n\n    /*\n    v2-----------v3\n    |  \\         |\n    |     \\      |\n    |        \\   |\n    v0-----------v1\n    */\n    let k = i * gs + j,\n        h2 = heights[k],\n        h3 = heights[k + 1],\n        h0 = heights[k + gs],\n        h1 = heights[k + gs + 1];\n\n    return fx + fy <= 1 ? h0 + fx * (h1 - h0) + fy * (h2 - h0) : h3 + (1 - fx) * (h2 - h3) + (1 - fy) * (h1 - h3);\n}\n\n/**\n * Writes the pixel row heights at the vertex columns: the edges, the pixel corners and, with half pixel steps,\n * the pixel centers.\n */\nfunction interpolateRow(pixels: Float32Array, offset: number, size: number, halfSteps: number, out: Float32Array) {\n    let last = offset + size - 1;\n\n    out[0] = getEdgeHeight(pixels[offset], pixels[Math.min(offset + 1, last)], pixels[Math.min(offset + 2, last)]);\n\n    out[(size * 2) / halfSteps] = getEdgeHeight(\n        pixels[last],\n        pixels[Math.max(last - 1, offset)],\n        pixels[Math.max(last - 2, offset)]\n    );\n\n    if (halfSteps === 1) {\n        let prev = pixels[offset];\n        out[1] = prev;\n        for (let k = 1; k < size; k++) {\n            let h = pixels[offset + k];\n            out[k * 2] = 0.5 * (prev + h);\n            out[k * 2 + 1] = h;\n            prev = h;\n        }\n    } else {\n        for (let k = 1; k < size; k++) {\n            out[k] = 0.5 * (pixels[offset + k - 1] + pixels[offset + k]);\n        }\n    }\n}\n\n/**\n * Converts size x size pixel heights to the vertex grid in the pixel corners, (size + 1) x (size + 1),\n * or in the pixel centers and corners, (2 * size + 1) x (2 * size + 1). Pixel center vertices keep the pixel heights.\n * @param {Float32Array} pixels - Pixel heights, NaN for no data.\n * @param {number} size - Image size.\n * @param {number} noDataHeight - Height for vertices without data around.\n * @param {boolean} [pixelCenters=true] - Vertices at the pixel centers too.\n * @returns {Float32Array} -\n */\nexport function createVertexGrid(\n    pixels: Float32Array,\n    size: number,\n    noDataHeight: number,\n    pixelCenters: boolean = true\n): Float32Array {\n    let halfSteps = pixelCenters ? 1 : 2,\n        gs = (size * 2) / halfSteps + 1,\n        last = size - 1;\n\n    // Heights at the vertex columns of the last three pixel rows, pixel row r is kept at (r % 3)\n    let columns = new Float32Array(gs * 3),\n        rowColumns = [columns.subarray(0, gs), columns.subarray(gs, gs * 2), columns.subarray(gs * 2)],\n        lastRow = -1;\n\n    let out = new Float32Array(gs * gs);\n\n    for (let vi = 0; vi < gs; vi++) {\n        let u = vi * halfSteps,\n            k = u >> 1,\n            dst = vi * gs;\n\n        let needRow = u === 0 ? Math.min(2, last) : Math.min(k, last);\n\n        while (lastRow < needRow) {\n            lastRow++;\n            interpolateRow(pixels, lastRow * size, size, halfSteps, rowColumns[lastRow % 3]);\n        }\n\n        if (u & 1) {\n            out.set(rowColumns[k % 3], dst);\n        } else if (k === 0 || k === size) {\n            let c0 = rowColumns[(k === 0 ? 0 : last) % 3],\n                c1 = rowColumns[(k === 0 ? Math.min(1, last) : Math.max(last - 1, 0)) % 3],\n                c2 = rowColumns[(k === 0 ? Math.min(2, last) : Math.max(last - 2, 0)) % 3];\n\n            for (let vj = 0; vj < gs; vj++) {\n                out[dst + vj] = getEdgeHeight(c0[vj], c1[vj], c2[vj]);\n            }\n        } else {\n            let c0 = rowColumns[(k - 1) % 3],\n                c1 = rowColumns[k % 3];\n\n            for (let vj = 0; vj < gs; vj++) {\n                out[dst + vj] = 0.5 * (c0[vj] + c1[vj]);\n            }\n        }\n\n        for (let vj = 0; vj < gs; vj++) {\n            if (out[dst + vj] !== out[dst + vj]) {\n                out[dst + vj] = averagePixels(pixels, size, u, vj * halfSteps, noDataHeight);\n            }\n        }\n    }\n\n    return out;\n}\n\nfunction averagePixels(pixels: Float32Array, size: number, ui: number, uj: number, noDataHeight: number): number {\n    let last = size - 1,\n        ki = ui >> 1,\n        kj = uj >> 1,\n        sum = 0,\n        count = 0;\n\n    for (let i = Math.max(ki - 1, 0), i1 = Math.min(ki + (ui & 1), last); i <= i1; i++) {\n        for (let j = Math.max(kj - 1, 0), j1 = Math.min(kj + (uj & 1), last); j <= j1; j++) {\n            let h = pixels[i * size + j];\n            if (h === h) {\n                sum += h;\n                count++;\n            }\n        }\n    }\n\n    return count ? sum / count : noDataHeight;\n}\n\n/** Peak and pit pixels, and their place in the vertex grid. */\nexport interface IGridPeaks {\n    pixels: Float32Array;\n    size: number;\n    /** Peaks by pixel rows, columns of row r are cols[rowStart[r]] ... cols[rowStart[r + 1] - 1]. */\n    rowStart: Int32Array;\n    cols: Int32Array;\n    /** 1 for peaks, 0 for pits. */\n    isPeak: Uint8Array;\n    /** Pixel p is at (p + offset) * scale vertex. */\n    offset: number;\n    scale: number;\n}\n\nconst HIGHER_AROUND = 1,\n    LOWER_AROUND = 2;\n\nlet _around = new Uint8Array(0);\n\n/** Marks pixels a and b with the neighbour higher or lower flags, NaN pixels are not compared. */\nfunction compareNeighbours(pixels: Float32Array, around: Uint8Array, a: number, b: number) {\n    let ha = pixels[a],\n        hb = pixels[b];\n\n    if (hb > ha) {\n        around[a] |= HIGHER_AROUND;\n        around[b] |= LOWER_AROUND;\n    } else if (hb < ha) {\n        around[a] |= LOWER_AROUND;\n        around[b] |= HIGHER_AROUND;\n    }\n}\n\n/**\n * Finds the pixels that are not lower (peaks) or not higher (pits) than the pixels around,\n * and differ from at least one of them.\n * @param {Float32Array} pixels - Pixel heights, NaN for no data.\n * @param {number} size - Image size.\n * @param {number} offset - Pixel p is at (p + offset) * scale vertex of the grid.\n * @param {number} scale - Grid vertices by pixel.\n * @returns {IGridPeaks} -\n */\nexport function findPeaks(pixels: Float32Array, size: number, offset: number, scale: number): IGridPeaks {\n    let last = size - 1,\n        length = size * size;\n\n    if (_around.length < length) {\n        _around = new Uint8Array(length);\n    } else {\n        _around.fill(0, 0, length);\n    }\n\n    let around = _around;\n\n    // Every neighbour pair is compared once, in 2x2 squares a b / c d: a-b, a-c, a-d and b-c\n    for (let r = 0; r < last; r++) {\n        let row = r * size;\n        for (let k = row, end = row + last; k < end; k++) {\n            compareNeighbours(pixels, around, k, k + 1);\n            compareNeighbours(pixels, around, k, k + size);\n            compareNeighbours(pixels, around, k, k + size + 1);\n            compareNeighbours(pixels, around, k + 1, k + size);\n        }\n        compareNeighbours(pixels, around, row + last, row + last + size);\n    }\n    for (let k = last * size, end = k + last; k < end; k++) {\n        compareNeighbours(pixels, around, k, k + 1);\n    }\n\n    let rowStart = new Int32Array(size + 1),\n        count = 0;\n\n    for (let k = 0; k < length; k++) {\n        if (around[k] === HIGHER_AROUND || around[k] === LOWER_AROUND) {\n            count++;\n        }\n    }\n\n    let cols = new Int32Array(count),\n        isPeak = new Uint8Array(count);\n\n    count = 0;\n\n    for (let r = 0; r < size; r++) {\n        rowStart[r] = count;\n        for (let c = 0, k = r * size; c < size; c++, k++) {\n            if (around[k] === HIGHER_AROUND || around[k] === LOWER_AROUND) {\n                cols[count] = c;\n                isPeak[count] = around[k] === LOWER_AROUND ? 1 : 0;\n                count++;\n            }\n        }\n    }\n\n    rowStart[size] = count;\n\n    return { pixels, size, rowStart, cols, isPeak, offset, scale };\n}\n\n// Peak deviations of the sampled grid vertices, reused\nlet _deviations = new Float32Array(0);\n\n/**\n * Takes (gridSize + 1) x (gridSize + 1) vertices of the cells x cells square starting at\n * the row0, col0 vertex of the (size + 1) x (size + 1) grid. Cells must be gridSize multiplied by a power of two.\n *\n * With peaks, peaks and pits are moved to the nearest inner vertices, slopes and edge vertices stay sampled.\n */\nexport function sampleSubGrid(\n    grid: Float32Array,\n    size: number,\n    row0: number,\n    col0: number,\n    cells: number,\n    gridSize: number,\n    out: Float32Array = new Float32Array((gridSize + 1) * (gridSize + 1)),\n    outOffset: number = 0,\n    peaks: IGridPeaks | null = null,\n    noDataHeight: number = NaN\n): Float32Array {\n    let gs = size + 1,\n        outGs = gridSize + 1,\n        step = cells / gridSize;\n\n    for (let i = 0; i < outGs; i++) {\n        let src = (row0 + i * step) * gs + col0,\n            dst = outOffset + i * outGs;\n        for (let j = 0; j < outGs; j++) {\n            out[dst + j] = grid[src + j * step];\n        }\n    }\n\n    if (peaks && step > 1 && gridSize > 1) {\n        keepPeaks(grid, gs, row0, col0, cells, gridSize, out, outOffset, peaks, noDataHeight);\n    }\n\n    return out;\n}\n\nfunction keepPeaks(\n    grid: Float32Array,\n    gs: number,\n    row0: number,\n    col0: number,\n    cells: number,\n    gridSize: number,\n    out: Float32Array,\n    outOffset: number,\n    peaks: IGridPeaks,\n    noDataHeight: number\n) {\n    let outGs = gridSize + 1,\n        step = cells / gridSize,\n        half = step >> 1,\n        inner = gridSize - 1,\n        { pixels, size, rowStart, cols, isPeak, offset, scale } = peaks;\n\n    // Pixels in the square\n    let pr0 = Math.max(Math.ceil(row0 / scale - offset), 0),\n        pr1 = Math.min(Math.floor((row0 + cells) / scale - offset), size - 1),\n        pc0 = Math.max(Math.ceil(col0 / scale - offset), 0),\n        pc1 = Math.min(Math.floor((col0 + cells) / scale - offset), size - 1);\n\n    if (_deviations.length < outGs * outGs) {\n        _deviations = new Float32Array(outGs * outGs);\n    }\n\n    _deviations.fill(0, 0, outGs * outGs);\n\n    for (let pr = pr0; pr <= pr1; pr++) {\n        let p = rowStart[pr],\n            end = rowStart[pr + 1];\n\n        for (let hi = end; p < hi;) {\n            let m = (p + hi) >> 1;\n            if (cols[m] < pc0) {\n                p = m + 1;\n            } else {\n                hi = m;\n            }\n        }\n\n        if (p === end || cols[p] > pc1) {\n            continue;\n        }\n\n        let y = (pr + offset) * scale - row0,\n            ci = Math.min(Math.floor(y / step), inner),\n            fy = y / step - ci,\n            i = Math.min(Math.max(Math.floor((y + half) / step), 1), inner),\n            top = (row0 + ci * step) * gs + col0,\n            bottom = top + step * gs,\n            vertexRow = (row0 + i * step) * gs + col0;\n\n        for (; p < end && cols[p] <= pc1; p++) {\n            let x = (cols[p] + offset) * scale - col0,\n                cj = Math.min(Math.floor(x / step), inner),\n                fx = x / step - cj,\n                k = cj * step;\n\n            let h00 = grid[top + k],\n                h01 = grid[top + k + step],\n                h10 = grid[bottom + k],\n                h11 = grid[bottom + k + step];\n\n            if (h00 === noDataHeight || h01 === noDataHeight || h10 === noDataHeight || h11 === noDataHeight) {\n                continue;\n            }\n\n            let surface = (1 - fy) * ((1 - fx) * h00 + fx * h01) + fy * ((1 - fx) * h10 + fx * h11),\n                h = pixels[pr * size + cols[p]],\n                deviation = isPeak[p] ? h - surface : surface - h;\n\n            if (deviation <= 0 || h === noDataHeight) {\n                continue;\n            }\n\n            let j = Math.min(Math.max(Math.floor((x + half) / step), 1), inner),\n                v = i * outGs + j;\n\n            if (deviation > _deviations[v] && deviation > Math.abs(surface - grid[vertexRow + j * step])) {\n                _deviations[v] = deviation;\n                out[outOffset + v] = h;\n            }\n        }\n    }\n}\n\n/**\n * Returns (gridSize + 1) x (gridSize + 1) mesh heights of (fileGridSize + 1) x (fileGridSize + 1) elevations,\n * their peaks and pits are moved to the nearest mesh vertices.\n * @param {Float32Array} elevations - Elevations grid, rows from north to south.\n * @param {number} fileGridSize - Elevations grid size.\n * @param {number} gridSize - Mesh grid size, fileGridSize divided by a power of two.\n * @param {number} noDataHeight - Height of no data elevations.\n * @param {Float32Array} [out] - Mesh heights.\n * @returns {Float32Array} -\n */\nexport function getMeshHeights(\n    elevations: Float32Array,\n    fileGridSize: number,\n    gridSize: number,\n    noDataHeight: number,\n    out: Float32Array = new Float32Array((gridSize + 1) * (gridSize + 1))\n): Float32Array {\n    return sampleSubGrid(\n        elevations,\n        fileGridSize,\n        0,\n        0,\n        fileGridSize,\n        gridSize,\n        out,\n        0,\n        findPeaks(elevations, fileGridSize + 1, 0, 1),\n        noDataHeight\n    );\n}\n\n/**\n * Creates the tile heights grid and its subdivision levels, each tile is (gridSize + 1) x (gridSize + 1).\n * Output order is the tile itself, then 2x2 tiles of the first level, 4x4 of the second and so on, row by row.\n * Peaks and pits of the pixels stay in all the levels.\n * @param {number} size - Image size, 2^n or (2^n + 1).\n * @param {number} gridSize - Tile grid size.\n * @param {number} levels - Subdivision levels.\n * @param {DecodeHeightsRowFunc} decodeRow - Decodes pixel row heights, NaN for no data.\n * @param {number} noDataHeight - Height for vertices without data.\n * @returns {Float32Array} -\n */\nexport function createHeightsLevels(\n    size: number,\n    gridSize: number,\n    levels: number,\n    decodeRow: DecodeHeightsRowFunc,\n    noDataHeight: number\n): Float32Array {\n    let pixels = new Float32Array(size * size);\n\n    for (let row = 0; row < size; row++) {\n        decodeRow(row, pixels.subarray(row * size, (row + 1) * size));\n    }\n\n    let grid: Float32Array, cells: number, peaks: IGridPeaks;\n\n    if (getGridCells(size) === size) {\n        // Vertices at the pixel centers are needed when the last level is finer than the pixels\n        let pixelCenters = size >> levels < gridSize;\n        grid = createVertexGrid(pixels, size, noDataHeight, pixelCenters);\n        cells = pixelCenters ? size * 2 : size;\n        peaks = findPeaks(pixels, size, 0.5, cells / size);\n    } else {\n        peaks = findPeaks(pixels, size, 0, 1);\n        for (let k = 0; k < pixels.length; k++) {\n            if (pixels[k] !== pixels[k]) {\n                pixels[k] = noDataHeight;\n            }\n        }\n        grid = pixels;\n        cells = size - 1;\n    }\n\n    let tileLength = (gridSize + 1) * (gridSize + 1),\n        tilesCount = 0;\n\n    for (let k = 0; k <= levels; k++) {\n        tilesCount += 1 << (2 * k);\n    }\n\n    let out = new Float32Array(tilesCount * tileLength);\n\n    for (let k = 0, c = cells, offset = 0; k <= levels; k++, c >>= 1) {\n        let d = 1 << k;\n        for (let i = 0; i < d; i++) {\n            for (let j = 0; j < d; j++) {\n                sampleSubGrid(grid, cells, i * c, j * c, c, gridSize, out, offset, peaks, noDataHeight);\n                offset += tileLength;\n            }\n        }\n    }\n\n    return out;\n}\n","\"use strict\";\n//\n//Terrain worker\n//\nimport { getMeshHeights } from \"../terrain/terrainUtils\";\n\nfunction binarySearchFast(arr, x) {\n    let start = 0,\n        end = arr.length - 1;\n    while (start <= end) {\n        let k = Math.floor((start + end) * 0.5);\n        if (Math.abs(arr[k] - x) < 1e-3) return k;\n        else if (arr[k] < x) start = k + 1;\n        else end = k - 1;\n    }\n    return -1;\n}\n\nfunction checkNoDataValue(noDataValues, value) {\n    return binarySearchFast(noDataValues, value) !== -1;\n}\n\nvar Vec3 = function (x, y, z) {\n    this.x = x;\n    this.y = y;\n    this.z = z;\n};\n\nvar doubleToTwoFloats = function (v, high, low) {\n    let x = v.x,\n        y = v.y,\n        z = v.z;\n\n    var doubleHigh;\n\n    if (x >= 0.0) {\n        doubleHigh = Math.floor(x / 65536.0) * 65536.0;\n        high.x = Math.fround(doubleHigh);\n        low.x = Math.fround(x - doubleHigh);\n    } else {\n        doubleHigh = Math.floor(-x / 65536.0) * 65536.0;\n        high.x = Math.fround(-doubleHigh);\n        low.x = Math.fround(x + doubleHigh);\n    }\n\n    if (y >= 0.0) {\n        doubleHigh = Math.floor(y / 65536.0) * 65536.0;\n        high.y = Math.fround(doubleHigh);\n        low.y = Math.fround(y - doubleHigh);\n    } else {\n        doubleHigh = Math.floor(-y / 65536.0) * 65536.0;\n        high.y = Math.fround(-doubleHigh);\n        low.y = Math.fround(y + doubleHigh);\n    }\n\n    if (z >= 0.0) {\n        doubleHigh = Math.floor(z / 65536.0) * 65536.0;\n        high.z = Math.fround(doubleHigh);\n        low.z = Math.fround(z - doubleHigh);\n    } else {\n        doubleHigh = Math.floor(-z / 65536.0) * 65536.0;\n        high.z = Math.fround(-doubleHigh);\n        low.z = Math.fround(z + doubleHigh);\n    }\n};\n\nVec3.prototype.sub = function (v) {\n    return new Vec3(this.x - v.x, this.y - v.y, this.z - v.z);\n};\n\nVec3.prototype.add = function (v) {\n    return new Vec3(this.x + v.x, this.y + v.y, this.z + v.z);\n};\n\nVec3.prototype.cross = function (v) {\n    return new Vec3(this.y * v.z - this.z * v.y, this.z * v.x - this.x * v.z, this.x * v.y - this.y * v.x);\n};\n\nVec3.prototype.normalize = function () {\n    var x = this.x,\n        y = this.y,\n        z = this.z;\n    var length = 1.0 / Math.sqrt(x * x + y * y + z * z);\n    this.x = x * length;\n    this.y = y * length;\n    this.z = z * length;\n    return this;\n};\n\nVec3.prototype.distance = function (v) {\n    return this.sub(v).length();\n};\n\nVec3.prototype.length = function () {\n    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);\n};\n\nvar blerp = function (x, y, fQ11, fQ21, fQ12, fQ22) {\n    return fQ11 * (1.0 - x) * (1.0 - y) + fQ21 * x * (1.0 - y) + fQ12 * (1.0 - x) * y + fQ22 * x * y;\n};\n\nvar _tempVec = new Vec3(0.0, 0.0, 0.0);\nvar _rtcTempVec = new Vec3(0.0, 0.0, 0.0);\n\nvar _tempHigh = new Vec3(0.0, 0.0, 0.0),\n    _tempLow = new Vec3(0.0, 0.0, 0.0);\n\nvar _meshHeights = new Float32Array(0);\n\nself.onmessage = function (e) {\n    var elevations = e.data.elevations,\n        this_plainVertices = e.data.this_plainVertices,\n        this_plainNormals = e.data.this_plainNormals,\n        this_normalMapVertices = e.data.this_normalMapVertices,\n        this_normalMapNormals = e.data.this_normalMapNormals,\n        heightFactor = e.data.heightFactor,\n        gridSize = e.data.gridSize,\n        noDataValues = e.data.noDataValues,\n        id = e.data.id;\n\n    let rtc_x = e.data.relativeCenter[0],\n        rtc_y = e.data.relativeCenter[1],\n        rtc_z = e.data.relativeCenter[2];\n\n    var xmin = 549755748352.0,\n        xmax = -549755748352.0,\n        ymin = 549755748352.0,\n        ymax = -549755748352.0,\n        zmin = 549755748352.0,\n        zmax = -549755748352.0;\n\n    // Squared geocentric distance of the same vertices. The axis aligned bounds above cannot tell\n    // relief from segment size, because the box of a tilted patch is far larger than the patch, so\n    // the radius range is accumulated here instead. Kept squared to avoid a root per vertex.\n    var r2min = Infinity,\n        r2max = -Infinity;\n\n    const fileGridSize = Math.sqrt(elevations.length) - 1;\n\n    const fileGridSize_one = fileGridSize + 1;\n    const fileGridSize_one_x2 = fileGridSize_one * fileGridSize_one;\n    const tgs = gridSize;\n    const dg = fileGridSize / tgs;\n    const gs = tgs + 1;\n    const hf = heightFactor;\n\n    var vInd = 0,\n        noDataInd = 0;\n\n    var gsgs3 = gs * gs * 3;\n\n    var terrainVertices = new Float64Array(gsgs3),\n        terrainVerticesHigh = new Float32Array(gsgs3),\n        terrainVerticesLow = new Float32Array(gsgs3),\n        noDataVertices = new Uint8Array(gs * gs);\n\n    var normalMapNormals, normalMapVertices;\n\n    var nv = this_normalMapVertices,\n        nn = this_normalMapNormals;\n\n    if (fileGridSize >= tgs) {\n        normalMapNormals = new Float32Array(fileGridSize_one_x2 * 3);\n        normalMapVertices = new Float64Array(fileGridSize_one_x2 * 3);\n\n        // Mesh heights keep the elevations peaks and pits, moved to the nearest mesh vertices\n        let meshHeights = null;\n        if (dg > 1) {\n            if (_meshHeights.length !== gs * gs) {\n                _meshHeights = new Float32Array(gs * gs);\n            }\n            meshHeights = getMeshHeights(\n                elevations,\n                fileGridSize,\n                tgs,\n                noDataValues.length ? noDataValues[0] : NaN,\n                _meshHeights\n            );\n        }\n\n        for (let k = 0; k < fileGridSize_one_x2; k++) {\n            var j = k % fileGridSize_one,\n                i = ~~(k / fileGridSize_one);\n\n            //\n            // V0\n            //\n            var hInd0 = k;\n            var vInd0 = hInd0 * 3;\n            var currElv = elevations[hInd0];\n            if (checkNoDataValue(noDataValues, currElv)) {\n                currElv = 0.0;\n            }\n            var h0 = hf * currElv;\n            var v0 = new Vec3(\n                rtc_x + nv[vInd0] + h0 * nn[vInd0],\n                rtc_y + nv[vInd0 + 1] + h0 * nn[vInd0 + 1],\n                rtc_z + nv[vInd0 + 2] + h0 * nn[vInd0 + 2]\n            );\n\n            normalMapVertices[vInd0] = v0.x - rtc_x;\n            normalMapVertices[vInd0 + 1] = v0.y - rtc_y;\n            normalMapVertices[vInd0 + 2] = v0.z - rtc_z;\n\n            //\n            // The vertex goes into screen buffer\n            if (i % dg === 0 && j % dg === 0) {\n                let currVert = new Vec3(rtc_x + nv[vInd0], rtc_y + nv[vInd0 + 1], rtc_z + nv[vInd0 + 2]);\n                let nextVert = new Vec3(rtc_x + nv[vInd0 + 3], rtc_y + nv[vInd0 + 4], rtc_z + nv[vInd0 + 5]);\n\n                let nextElv = elevations[hInd0 + 1];\n                if (checkNoDataValue(noDataValues, nextElv)) {\n                    nextElv = 0.0;\n                }\n\n                let eps = false;\n                if (noDataValues.length === 0) {\n                    let step = currVert.distance(nextVert);\n                    let deltaElv = Math.abs(currElv - nextElv);\n                    eps = deltaElv / step > 10.0 || currElv < -5000;\n                }\n\n                let mv = v0;\n                if (meshHeights) {\n                    let meshElv = meshHeights[(i / dg) * gs + j / dg];\n                    // Only the vertices a peak or pit is moved to\n                    if (meshElv !== elevations[hInd0] && !checkNoDataValue(noDataValues, meshElv)) {\n                        let mh = hf * meshElv;\n                        mv = new Vec3(\n                            rtc_x + nv[vInd0] + mh * nn[vInd0],\n                            rtc_y + nv[vInd0 + 1] + mh * nn[vInd0 + 1],\n                            rtc_z + nv[vInd0 + 2] + mh * nn[vInd0 + 2]\n                        );\n                    }\n                }\n\n                if (eps) {\n                    noDataVertices[noDataInd] = 1;\n                } else {\n                    noDataVertices[noDataInd] = 0;\n                    if (mv.x < xmin) xmin = mv.x;\n                    if (mv.x > xmax) xmax = mv.x;\n                    if (mv.y < ymin) ymin = mv.y;\n                    if (mv.y > ymax) ymax = mv.y;\n                    if (mv.z < zmin) zmin = mv.z;\n                    if (mv.z > zmax) zmax = mv.z;\n\n                    let r2_v0 = mv.x * mv.x + mv.y * mv.y + mv.z * mv.z;\n                    if (r2_v0 < r2min) r2min = r2_v0;\n                    if (r2_v0 > r2max) r2max = r2_v0;\n                }\n\n                let rtc_v0 = new Vec3(mv.x - rtc_x, mv.y - rtc_y, mv.z - rtc_z);\n                doubleToTwoFloats(rtc_v0, _tempHigh, _tempLow);\n\n                terrainVerticesHigh[vInd] = _tempHigh.x;\n                terrainVerticesLow[vInd] = _tempLow.x;\n                terrainVertices[vInd++] = rtc_v0.x;\n\n                terrainVerticesHigh[vInd] = _tempHigh.y;\n                terrainVerticesLow[vInd] = _tempLow.y;\n                terrainVertices[vInd++] = rtc_v0.y;\n\n                terrainVerticesHigh[vInd] = _tempHigh.z;\n                terrainVerticesLow[vInd] = _tempLow.z;\n                terrainVertices[vInd++] = rtc_v0.z;\n\n                noDataInd++;\n            }\n\n            if (i !== fileGridSize && j !== fileGridSize) {\n                //\n                //  V1\n                //\n                var hInd1 = k + 1;\n                var vInd1 = hInd1 * 3;\n                var elv = elevations[hInd1];\n                if (checkNoDataValue(noDataValues, elv)) {\n                    elv = 0.0;\n                }\n                var h1 = hf * elv;\n                var v1 = new Vec3(\n                    rtc_x + nv[vInd1] + h1 * nn[vInd1],\n                    rtc_y + nv[vInd1 + 1] + h1 * nn[vInd1 + 1],\n                    rtc_z + nv[vInd1 + 2] + h1 * nn[vInd1 + 2]\n                );\n\n                normalMapVertices[vInd1] = v1.x - rtc_x;\n                normalMapVertices[vInd1 + 1] = v1.y - rtc_y;\n                normalMapVertices[vInd1 + 2] = v1.z - rtc_z;\n\n                //\n                //  V2\n                //\n                var hInd2 = k + fileGridSize_one;\n                var vInd2 = hInd2 * 3;\n                elv = elevations[hInd2];\n                if (checkNoDataValue(noDataValues, elv)) {\n                    elv = 0.0;\n                }\n                var h2 = hf * elv;\n                var v2 = new Vec3(\n                    rtc_x + nv[vInd2] + h2 * nn[vInd2],\n                    rtc_y + nv[vInd2 + 1] + h2 * nn[vInd2 + 1],\n                    rtc_z + nv[vInd2 + 2] + h2 * nn[vInd2 + 2]\n                );\n\n                normalMapVertices[vInd2] = v2.x - rtc_x;\n                normalMapVertices[vInd2 + 1] = v2.y - rtc_y;\n                normalMapVertices[vInd2 + 2] = v2.z - rtc_z;\n\n                //\n                //  V3\n                //\n                var hInd3 = k + fileGridSize_one + 1;\n                var vInd3 = hInd3 * 3;\n                elv = elevations[hInd3];\n                if (checkNoDataValue(noDataValues, elv)) {\n                    elv = 0.0;\n                }\n                var h3 = hf * elv;\n                var v3 = new Vec3(\n                    rtc_x + nv[vInd3] + h3 * nn[vInd3],\n                    rtc_y + nv[vInd3 + 1] + h3 * nn[vInd3 + 1],\n                    rtc_z + nv[vInd3 + 2] + h3 * nn[vInd3 + 2]\n                );\n\n                normalMapVertices[vInd3] = v3.x - rtc_x;\n                normalMapVertices[vInd3 + 1] = v3.y - rtc_y;\n                normalMapVertices[vInd3 + 2] = v3.z - rtc_z;\n\n                //\n                // Normal\n                //\n                var e10 = v1.sub(v0),\n                    e20 = v2.sub(v0),\n                    e30 = v3.sub(v0);\n\n                var sw = e20.cross(e30).normalize();\n                var ne = e30.cross(e10).normalize();\n                var n0 = ne.add(sw).normalize();\n\n                normalMapNormals[vInd0] += n0.x;\n                normalMapNormals[vInd0 + 1] += n0.y;\n                normalMapNormals[vInd0 + 2] += n0.z;\n\n                normalMapNormals[vInd1] += ne.x;\n                normalMapNormals[vInd1 + 1] += ne.y;\n                normalMapNormals[vInd1 + 2] += ne.z;\n\n                normalMapNormals[vInd2] += sw.x;\n                normalMapNormals[vInd2 + 1] += sw.y;\n                normalMapNormals[vInd2 + 2] += sw.z;\n\n                normalMapNormals[vInd3] += n0.x;\n                normalMapNormals[vInd3 + 1] += n0.y;\n                normalMapNormals[vInd3 + 2] += n0.z;\n            }\n        }\n    } else {\n        normalMapNormals = new Float32Array(gsgs3);\n        normalMapVertices = new Float64Array(gsgs3);\n\n        var oneSize = tgs / fileGridSize;\n        var gsgs = gsgs3 / 3;\n        var fgsOne = fileGridSize + 1;\n\n        for (let i = 0; i < gsgs; i++) {\n            let ii = Math.floor(i / gs),\n                ij = i % gs;\n\n            let qii = ii % oneSize,\n                qij = ij % oneSize;\n\n            let hlt_ind = Math.floor(ii / oneSize) * fgsOne + Math.floor(ij / oneSize);\n\n            if (ij === tgs) {\n                hlt_ind -= 1;\n                qij = oneSize;\n            }\n\n            if (ii === tgs) {\n                hlt_ind -= fgsOne;\n                qii = oneSize;\n            }\n\n            let hrt_ind = hlt_ind + 1,\n                hlb_ind = hlt_ind + fgsOne,\n                hrb_ind = hlb_ind + 1;\n\n            let h_lt = elevations[hlt_ind],\n                h_rt = elevations[hrt_ind],\n                h_lb = elevations[hlb_ind],\n                h_rb = elevations[hrb_ind];\n\n            if (checkNoDataValue(noDataValues, h_lt)) {\n                h_lt = 0.0;\n            }\n\n            if (checkNoDataValue(noDataValues, h_rt)) {\n                h_rt = 0.0;\n            }\n\n            if (checkNoDataValue(noDataValues, h_lb)) {\n                h_lb = 0.0;\n            }\n\n            if (checkNoDataValue(noDataValues, h_rb)) {\n                h_rb = 0.0;\n            }\n\n            let hi = blerp(qij / oneSize, qii / oneSize, h_lt, h_rt, h_lb, h_rb);\n\n            let i3 = i * 3;\n\n            _rtcTempVec.x = this_plainVertices[i3] + hi * this_plainNormals[i3];\n            _rtcTempVec.y = this_plainVertices[i3 + 1] + hi * this_plainNormals[i3 + 1];\n            _rtcTempVec.z = this_plainVertices[i3 + 2] + hi * this_plainNormals[i3 + 2];\n\n            doubleToTwoFloats(_rtcTempVec, _tempHigh, _tempLow);\n\n            terrainVertices[i3] = _rtcTempVec.x;\n            terrainVertices[i3 + 1] = _rtcTempVec.y;\n            terrainVertices[i3 + 2] = _rtcTempVec.z;\n\n            terrainVerticesHigh[i3] = _tempHigh.x;\n            terrainVerticesHigh[i3 + 1] = _tempHigh.y;\n            terrainVerticesHigh[i3 + 2] = _tempHigh.z;\n\n            terrainVerticesLow[i3] = _tempLow.x;\n            terrainVerticesLow[i3 + 1] = _tempLow.y;\n            terrainVerticesLow[i3 + 2] = _tempLow.z;\n\n            _tempVec.x = _rtcTempVec.x + rtc_x;\n            _tempVec.y = _rtcTempVec.y + rtc_y;\n            _tempVec.z = _rtcTempVec.z + rtc_z;\n\n            if (_tempVec.x < xmin) xmin = _tempVec.x;\n            if (_tempVec.x > xmax) xmax = _tempVec.x;\n            if (_tempVec.y < ymin) ymin = _tempVec.y;\n            if (_tempVec.y > ymax) ymax = _tempVec.y;\n            if (_tempVec.z < zmin) zmin = _tempVec.z;\n            if (_tempVec.z > zmax) zmax = _tempVec.z;\n\n            let r2_tmp = _tempVec.x * _tempVec.x + _tempVec.y * _tempVec.y + _tempVec.z * _tempVec.z;\n            if (r2_tmp < r2min) r2min = r2_tmp;\n            if (r2_tmp > r2max) r2max = r2_tmp;\n        }\n\n        normalMapVertices.set(terrainVertices);\n\n        for (let k = 0; k < gsgs; k++) {\n            let j = k % gs,\n                i = ~~(k / gs);\n\n            if (i !== tgs && j !== tgs) {\n                let v0ind = k * 3,\n                    v1ind = v0ind + 3,\n                    v2ind = v0ind + gs * 3,\n                    v3ind = v2ind + 3;\n\n                let v0 = new Vec3(\n                        terrainVertices[v0ind] + rtc_x,\n                        terrainVertices[v0ind + 1] + rtc_y,\n                        terrainVertices[v0ind + 2] + rtc_z\n                    ),\n                    v1 = new Vec3(\n                        terrainVertices[v1ind] + rtc_x,\n                        terrainVertices[v1ind + 1] + rtc_y,\n                        terrainVertices[v1ind + 2] + rtc_z\n                    ),\n                    v2 = new Vec3(\n                        terrainVertices[v2ind] + rtc_x,\n                        terrainVertices[v2ind + 1] + rtc_y,\n                        terrainVertices[v2ind + 2] + rtc_z\n                    ),\n                    v3 = new Vec3(\n                        terrainVertices[v3ind] + rtc_x,\n                        terrainVertices[v3ind + 1] + rtc_y,\n                        terrainVertices[v3ind + 2] + rtc_z\n                    );\n\n                let e10 = v1.sub(v0).normalize(),\n                    e20 = v2.sub(v0).normalize(),\n                    e30 = v3.sub(v0).normalize();\n\n                let sw = e20.cross(e30).normalize();\n                let ne = e30.cross(e10).normalize();\n                let n0 = ne.add(sw).normalize();\n\n                normalMapNormals[v0ind] += n0.x;\n                normalMapNormals[v0ind + 1] += n0.y;\n                normalMapNormals[v0ind + 2] += n0.z;\n\n                normalMapNormals[v1ind] += ne.x;\n                normalMapNormals[v1ind + 1] += ne.y;\n                normalMapNormals[v1ind + 2] += ne.z;\n\n                normalMapNormals[v2ind] += sw.x;\n                normalMapNormals[v2ind + 1] += sw.y;\n                normalMapNormals[v2ind + 2] += sw.z;\n\n                normalMapNormals[v3ind] += n0.x;\n                normalMapNormals[v3ind + 1] += n0.y;\n                normalMapNormals[v3ind + 2] += n0.z;\n            }\n        }\n    }\n\n    self.postMessage(\n        {\n            id: id,\n            normalMapNormals: normalMapNormals,\n            normalMapVertices: normalMapVertices,\n            terrainVertices: terrainVertices,\n            terrainVerticesHigh: terrainVerticesHigh,\n            terrainVerticesLow: terrainVerticesLow,\n            noDataVertices: noDataVertices,\n            bounds: [xmin, ymin, zmin, xmax, ymax, zmax],\n            radiusRange: r2max >= r2min ? [Math.sqrt(r2min), Math.sqrt(r2max)] : null,\n            relativeCenter: e.data.relativeCenter\n        },\n        [\n            normalMapNormals.buffer,\n            normalMapVertices.buffer,\n            terrainVertices.buffer,\n            terrainVerticesHigh.buffer,\n            terrainVerticesLow.buffer,\n            noDataVertices.buffer\n        ]\n    );\n};\n"],"mappings":"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"}

package/lib/control/DragAndDrop.d.ts

@@ -33,5 +33,6 @@ export declare class DragAndDrop extends Control {
     protected _addObj(file: File, lonLat: LonLat, mtlFile?: File | null): Promise<void>;
     protected _selectEntity(entity: Entity): void;
     protected _addBillboard(file: File, lonLat: LonLat): Promise<void>;
+    protected _createTiffLayer(file: File): GeoTIFFLayer;
     protected _addTiff(file: File): Promise<void>;
 }

package/lib/control/entityGizmo/EntityGizmo.d.ts

@@ -20,12 +20,13 @@ type EntityGizmoEventsList = [
  * @class
  * @extends {Control}
  * @param {IEntityGizmoParams} [options] - Gizmo options:
- * @param {GizmoTools} [options.tools] - Gizmo tool set, i.e. which handles are shown. `translate`
+ * @param {GizmoTools} [options.tools] - Gizmo tool set, i.e., which handles are shown. `translate`
  * shows move axes and planes only, `full` adds rotation rings. Orthogonal to `editMode`.
  * @param {EditModeName} [options.editMode] - Rotation mode. `native` rotates in the entity's own
  * frame, `yaw` rotates in the local horizon frame. Affects the rotation rings only, so it does
  * nothing with `tools: "translate"`.
- * @param {boolean} [options.autoSelect] - When `false`, a left click on a map entity does not
+ * @param {boolean} [options.autoSelect] - When `true`, a left click on a map entity selects it and
+ * a left click anywhere else drops the selection. When `false`, clicks do not
  * change the gizmo selection, so the host application stays the only source of the selection.
  * Default is `true`.
  */
@@ -50,7 +51,7 @@ export declare class EntityGizmo extends Control {
     get editMode(): EditModeName;
     set editMode(editMode: EditModeName);
     /**
-     * When `false`, a left click on a map entity does not change the gizmo selection.
+     * When `false`, a left click neither selects a map entity nor drops the current selection.
      * @public
      */
     get autoSelect(): boolean;

package/lib/control/entityGizmo/EntityGizmoScene.d.ts

@@ -133,7 +133,9 @@ declare class EntityGizmoScene extends Scene {
     /** Gizmo tool set: which handles are shown. */
     get tools(): GizmoTools;
     set tools(tools: GizmoTools);
-    /** When `false`, a left click on a map entity does not change the gizmo selection. */
+    /**
+     * When `false`, a left click neither selects a map entity nor drops the current selection.
+     */
     get autoSelect(): boolean;
     set autoSelect(autoSelect: boolean);
     protected get _rotateEnabled(): boolean;
@@ -170,6 +172,16 @@ declare class EntityGizmoScene extends Scene {
     readyToEdit(entity: Entity): boolean;
     select(entity: Entity): void;
     unselect(): void;
+    /**
+     * Returns `true` when the entity is one of the gizmo handles.
+     * @protected
+     */
+    protected _isGizmoEntity(entity: Entity): boolean;
+    /**
+     * `lclick` fires on the left button release without dragging, so dropping the selection
+     * here does not interfere with the map navigation.
+     * @protected
+     */
     protected _onLclick: (e: IMouseState) => void;
     clear(): void;
     protected _onForwardpass: () => void;

package/lib/index.d.ts

@@ -14,6 +14,7 @@ export * from "./control/Control";
 export * from "./entity/index";
 export * from "./layer/index";
 export * from "./Globe";
+export { proj4 } from "./proj/proj4";
 export type { IControlParams } from "./control/Control";
 export type { IMouseState, ITouchState } from "./renderer/RendererEvents";
 export type { IDeferredShadingPass } from "./renderer/IDeferredShadingPass";
@@ -63,9 +64,9 @@ import { Loader, type IResponse } from "./utils/Loader";
 import { EarthQuadTreeStrategy, EquiQuadTreeStrategy, QuadTreeStrategy, quadTreeStrategyType, Wgs84QuadTreeStrategy } from "./quadTree/index";
 import { Object3d } from "./Object3d";
 import { Handler, ShaderProgram, Framebuffer, Multisample } from "./webgl/index";
-import { EmptyTerrain, GlobusTerrain, RgbTerrain, BilTerrain, GlobusRgbTerrain, MapterhornTerrain, rgbToHeightByEncoding, rgbToHeightRgb, rgbToHeightTerrarium, resolveRgbToHeightFunc } from "./terrain/index";
+import { EmptyTerrain, GlobusTerrain, RgbTerrain, BilTerrain, GlobusRgbTerrain, MapterhornTerrain, ProceduralTerrain, rgbToHeightByEncoding, rgbToHeightRgb, rgbToHeightTerrarium, resolveRgbToHeightFunc } from "./terrain/index";
 import { MoveAxisEntity } from "./control/entityGizmo/MoveAxisEntity";
 import { Gltf } from "./utils/gltf/gltfParser";
 import { Easing } from "./utils/easing";
 import type { EasingFunction } from "./utils/easing";
-export { bv, jd, math, mercator, utils, input, control, scene, quadTreeStrategyType, wgs84, moon, mars, terrain, layer, ui, webgl, Easing, EasingFunction, Framebuffer, EmptyTerrain, GlobusTerrain, RgbTerrain, GlobusRgbTerrain, MapterhornTerrain, rgbToHeightByEncoding, rgbToHeightRgb, rgbToHeightTerrarium, resolveRgbToHeightFunc, BilTerrain, Camera, Ellipsoid, Planet, PlanetCamera, ShaderProgram, Handler, Multisample, Renderer, Clock, TimelineModel, Events, EventsHandler, createEvents, Extent, LonLat, Scene, Line2, Line3, Mat3, Mat4, Plane, Quat, Ray, Vec2, Vec3, Vec4, Geoid, Popup, QuadTreeStrategy, EquiQuadTreeStrategy, EarthQuadTreeStrategy, Wgs84QuadTreeStrategy, Object3d, Gltf, MoveAxisEntity, Loader, IResponse };
+export { bv, jd, math, mercator, utils, input, control, scene, quadTreeStrategyType, wgs84, moon, mars, terrain, layer, ui, webgl, Easing, EasingFunction, Framebuffer, EmptyTerrain, GlobusTerrain, RgbTerrain, GlobusRgbTerrain, MapterhornTerrain, ProceduralTerrain, rgbToHeightByEncoding, rgbToHeightRgb, rgbToHeightTerrarium, resolveRgbToHeightFunc, BilTerrain, Camera, Ellipsoid, Planet, PlanetCamera, ShaderProgram, Handler, Multisample, Renderer, Clock, TimelineModel, Events, EventsHandler, createEvents, Extent, LonLat, Scene, Line2, Line3, Mat3, Mat4, Plane, Quat, Ray, Vec2, Vec3, Vec4, Geoid, Popup, QuadTreeStrategy, EquiQuadTreeStrategy, EarthQuadTreeStrategy, Wgs84QuadTreeStrategy, Object3d, Gltf, MoveAxisEntity, Loader, IResponse };

package/lib/layer/BaseTileMaterialLayer.d.ts

@@ -20,6 +20,7 @@ export declare abstract class BaseTileMaterialLayer extends Layer {
     events: BaseTileMaterialLayerEventsType;
     minNativeZoom: number;
     maxNativeZoom: number;
+    protected _loadendFrame: number;
     constructor(name?: string | null, options?: IBaseTileMaterialLayerParams);
     addTo(planet: Planet): void;
     remove(): this;

package/lib/layer/GeoTIFFLayer.d.ts

@@ -66,6 +66,14 @@ export declare class GeoTIFFLayer extends BaseTileMaterialLayer {
     clear(): void;
     redraw(): void;
     private _reapplyRenderOptions;
+    /**
+     * Opens the source. If its CRS is unresolved, fetches the projection
+     * from the EPSG registry and reopens the source with it.
+     *
+     * Projections provided via `projFunc` or registered in {@link proj4}
+     * are already resolved and require no lookup.
+     */
+    private _readSource;
     private _initSource;
     private _initSources;
     private _normalizeRenderOptions;

package/lib/layer/geotiff/GeoTIFFReader.d.ts

@@ -14,6 +14,8 @@ export declare class GeoTIFFReader implements IGeoTIFFReader {
     extentWgs84: Extent;
     nativeBBox: [number, number, number, number];
     crsCode: number;
+    /** Whether `crsCode` could be georeferenced, see {@link IGeoTIFFMetadata.crsResolved} */
+    crsResolved: boolean;
     projFunc?: ProjFunc;
     reverseY: boolean;
     requestLevels: number[];

package/lib/layer/geotiff/MultiGeoTIFFReader.d.ts

@@ -16,6 +16,8 @@ export declare class MultiGeoTIFFReader implements IGeoTIFFReader {
     extentWgs84: Extent;
     isReady: boolean;
     crsCode: number;
+    /** Whether every source could be georeferenced, see {@link IGeoTIFFMetadata.crsResolved} */
+    crsResolved: boolean;
     workerPool: Pool | null;
     private _poolHandle;
     private _bandMappings;

package/lib/layer/geotiff/types.d.ts

@@ -63,9 +63,9 @@ export interface IGeoTIFFRequestOptions {
     credentials?: boolean;
     maxRanges?: number;
     allowFullFile?: boolean;
-    /** Size of a cached byte range, 64 KB by default. Fetched ranges are cached only when it is set. */
+    /** Size of a cached byte range, 256 KB by default. */
     blockSize?: number;
-    /** Number of cached byte ranges, 512 by default. */
+    /** Number of cached byte ranges, by default as many as fit in 32 MB. */
     cacheSize?: number;
     [key: string]: any;
 }
@@ -79,8 +79,6 @@ export type ProjFunc = (code: number) => {
 export interface IGeoTIFFSourceCommon {
     /** Remote URL or local Blob/File/ArrayBuffer */
     src?: GeoTIFFSource;
-    /** Alias for src when passing a URL */
-    url?: string;
     /** Custom NoData value. Set to null or NaN to disable nodata masking. */
     nodata?: NoDataValue;
     /** Alias for nodata */
@@ -141,6 +139,7 @@ export interface IGeoTIFFReader {
 export interface IGeoTIFFMetadata {
     bbox: [number, number, number, number];
     crsCode: number;
+    crsResolved: boolean;
     width: number;
     height: number;
     samplesPerPixel: number;

package/lib/layer/geotiff/utm.d.ts

@@ -17,6 +17,6 @@ export interface IProjectionHelper {
 }
 /**
  * Returns a projection helper { project, unproject } if the given code is a supported UTM EPSG code
- * (EPSG:32601-32660 or EPSG:32701-32760), or if proj4 is globally registered.
+ * (EPSG:32601-32660 or EPSG:32701-32760), or if its definition is registered in proj4.
  */
 export declare function getProjectionHelper(crsCode: number, customProjFunc?: (code: number) => IProjectionHelper | undefined): IProjectionHelper | null;