@openglobus/og 1.0.0-rc32 → 1.0.0-rc34

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/RgbTerrainWorker.worker-CEntGFYu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RgbTerrainWorker.worker-CEntGFYu.js","names":[],"sources":["../../src/terrain/rgbTerrainGrid.ts","../../src/utils/RgbTerrainWorker.worker.js"],"sourcesContent":["import type { TypedArray } from \"../utils/shared\";\n\nexport const RGB_ENCODING_CUSTOM = -1;\nexport const RGB_ENCODING_RGB = 0;\nexport const RGB_ENCODING_TERRARIUM = 1;\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\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 heights 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 heights 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\n/**\n * Returns vertex 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\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 * Converts size x size pixel heights to (size + 1) x (size + 1) vertex grid in pixel corners.\n * @param {number} size - Image size.\n * @param {DecodeHeightsRowFunc} decodeRow - Decodes pixel row heights, NaN for no data.\n * @param {number} noDataHeight - Height for vertices without data around.\n * @returns {Float32Array} -\n */\nexport function createVertexGrid(size: number, decodeRow: DecodeHeightsRowFunc, noDataHeight: number): Float32Array {\n    let gs = size + 1;\n\n    // Per-axis taps for vertex v: two pixel indices with interpolation weights, and the nearest pixels.\n    let i0 = new Int32Array(gs),\n        i1 = new Int32Array(gs),\n        w0 = new Float32Array(gs),\n        w1 = new Float32Array(gs),\n        n0 = new Int32Array(gs),\n        n1 = new Int32Array(gs);\n\n    for (let v = 0; v < gs; v++) {\n        if (v === 0) {\n            i0[v] = 0;\n            i1[v] = 1;\n            w0[v] = 1.5;\n            w1[v] = -0.5;\n            n0[v] = n1[v] = 0;\n        } else if (v === size) {\n            i0[v] = size - 1;\n            i1[v] = size - 2;\n            w0[v] = 1.5;\n            w1[v] = -0.5;\n            n0[v] = n1[v] = size - 1;\n        } else {\n            i0[v] = n0[v] = v - 1;\n            i1[v] = n1[v] = v;\n            w0[v] = w1[v] = 0.5;\n        }\n    }\n\n    // Pixel row r is kept at (r & 1) * size\n    let heights = new Float32Array(size * 2),\n        rowHeights = [heights.subarray(0, size), heights.subarray(size)],\n        lastRow = -1;\n\n    let out = new Float32Array(gs * gs);\n\n    for (let vi = 0; vi < gs; vi++) {\n        let needRow = vi === 0 ? 1 : Math.min(vi, size - 1);\n        while (lastRow < needRow) {\n            lastRow++;\n            decodeRow(lastRow, rowHeights[lastRow & 1]);\n        }\n\n        let r0 = (i0[vi] & 1) * size,\n            r1 = (i1[vi] & 1) * size,\n            wr0 = w0[vi],\n            wr1 = w1[vi],\n            nr0 = (n0[vi] & 1) * size,\n            nr1 = (n1[vi] & 1) * size;\n\n        for (let vj = 0; vj < gs; vj++) {\n            let c0 = i0[vj],\n                c1 = i1[vj];\n\n            let h =\n                wr0 * (w0[vj] * heights[r0 + c0] + w1[vj] * heights[r0 + c1]) +\n                wr1 * (w0[vj] * heights[r1 + c0] + w1[vj] * heights[r1 + c1]);\n\n            // NaN means at least one tap has no data\n            if (h === h) {\n                out[vi * gs + vj] = h;\n            } else {\n                let h00 = heights[nr0 + n0[vj]],\n                    h01 = heights[nr0 + n1[vj]],\n                    h10 = heights[nr1 + n0[vj]],\n                    h11 = heights[nr1 + n1[vj]];\n\n                let sum = 0,\n                    count = 0;\n\n                if (h00 === h00) {\n                    sum += h00;\n                    count++;\n                }\n                if (h01 === h01) {\n                    sum += h01;\n                    count++;\n                }\n                if (h10 === h10) {\n                    sum += h10;\n                    count++;\n                }\n                if (h11 === h11) {\n                    sum += h11;\n                    count++;\n                }\n\n                out[vi * gs + vj] = count ? sum / count : noDataHeight;\n            }\n        }\n    }\n\n    return out;\n}\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 */\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): 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    return out;\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 * @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 cells = getGridCells(size);\n\n    let grid: Float32Array;\n\n    if (cells === size) {\n        grid = createVertexGrid(size, decodeRow, noDataHeight);\n    } else {\n        grid = new Float32Array(size * size);\n        for (let row = 0; row < size; row++) {\n            let rowHeights = grid.subarray(row * size, (row + 1) * size);\n            decodeRow(row, rowHeights);\n            for (let j = 0; j < size; j++) {\n                if (rowHeights[j] !== rowHeights[j]) {\n                    rowHeights[j] = noDataHeight;\n                }\n            }\n        }\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);\n                offset += tileLength;\n            }\n        }\n    }\n\n    return out;\n}\n","\"use strict\";\n//\n// RGB terrain heights worker\n//\nimport {\n    createHeightsLevels,\n    decodeRgbHeightsRow,\n    getGridCells,\n    unpackRgbHeightsParams\n} from \"../terrain/rgbTerrainGrid\";\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/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/depthCamera/DepthCamera.d.ts

@@ -7,6 +7,7 @@ import { Vec4, type NumberArray4 } from "../../math/Vec4";
 import { QuadTreeStrategy } from "../../quadTree";
 import type { Renderer } from "../../renderer/Renderer";
 import type { Planet } from "../../scene/Planet";
+import type { EmptyTerrain } from "../../terrain/EmptyTerrain";
 import { Framebuffer } from "../../webgl";
 import { Vector } from "../../layer/Vector";
 import type { ShadowMap } from "../../renderer/shadows/ShadowMap";
@@ -65,6 +66,7 @@ export declare class DepthCamera {
     protected _isOrthographic: boolean;
     protected _focusDistance: number;
     protected _lastPlanetHeightFactor: number;
+    protected _lastPlanetTerrain: EmptyTerrain | null;
     protected _orthoTexelSizeX: number;
     protected _orthoTexelSizeY: number;
     protected _frustumLength: number;

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/entity/EntityCollection.d.ts

@@ -252,6 +252,19 @@ declare class EntityCollection {
      * @public
      */
     requestRedraw(): void;
+    /**
+     * Sets the current time of polylines and strips with path times.
+     * @public
+     * @param {number} time - Time in the same units as the path times.
+     */
+    setTime(time: number): void;
+    /**
+     * Sets opacity multipliers of the path parts passed and ahead of the current time.
+     * @public
+     * @param {number} past - Multiplier up to the current time.
+     * @param {number} future - Multiplier after the current time.
+     */
+    setTimeOpacity(past: number, future: number): void;
     /**
      * Returns collection visibility.
      * @public

package/lib/entity/pathTime.d.ts

@@ -0,0 +1,2 @@
+export declare const PATH_TIME_SPLIT = 1048576;
+export declare function splitPathTime(time: number): [number, number];

package/lib/entity/polyline/Polyline.d.ts

@@ -30,6 +30,7 @@ export interface IPolylineParams {
     visibility?: boolean;
     isClosed?: boolean;
     pathColors?: SegmentPathColor[];
+    pathTimes?: number[][];
     path3v?: SegmentPath3vExt[];
     pathLonLat?: SegmentPathLonLatExt[];
     src?: StrokeSource;
@@ -48,6 +49,8 @@ export interface IPolylineParams {
  * @param {SegmentPathLonLatExt[]} [options.pathLonLat] - Polyline geodetic coordinates array. [[[0,0,0], [1,1,1],...]]
  * @param {SegmentPath3vExt[]} [options.path3v] - LinesString cartesian coordinates array. [[[0,0,0], [1,1,1],...]]
  * @param {SegmentPathColor[]} [options.pathColors] - Coordinates color. [[[1,0,0,1], [0,1,0,1],...]] for right and green colors.
+ * @param {number[][]} [options.pathTimes] - Time of every point, per segment. Makes the line follow the
+ * entity collection time, see {@link EntityCollection#setTime} and {@link EntityCollection#setTimeOpacity}.
  * @param {TexParam} [options.texParams] - Texture params for all segments: texOffset, strokeSize and texOffsetSpeed.
  */
 declare class Polyline {
@@ -62,6 +65,7 @@ declare class Polyline {
     _path3v: SegmentPath3vExt[];
     protected _pathLonLat: SegmentPathLonLatExt[];
     protected _pathColors: SegmentPathColor[];
+    protected _pathTimes: number[][] | null;
     protected _color: string[];
     protected _segmentTexParams: Partial<TexParam> | null;
     protected _src: StrokeSource;
@@ -79,6 +83,10 @@ declare class Polyline {
     get altitude(): number;
     _addToBatchRenderer(): void;
     _removeFromBatchRenderer(): void;
+    protected _batchIndex(segmentIndex: number): number;
+    protected _forEachBatchPath(callback: (batchIndex: number, segmentIndex: number) => void): void;
+    protected _removeBatchPath(segmentIndex: number): void;
+    protected _hasSameBatchPaths(paths: SegmentPath3vExt[] | SegmentPathLonLatExt[]): boolean;
     protected _getDefaultHtmlColor(segmentIndex?: number): string | undefined;
     protected _getDefaultPathColor(segmentIndex?: number): NumberArray4 | undefined;
     protected _applySegmentProps(batchIndex: number, segmentIndex?: number): void;
@@ -125,24 +133,27 @@ declare class Polyline {
      * @param {number} [index=0] - Index in the path
      * @param {NumberArray4} [color] - Point color
      * @param {number} [segmentIndex=0] - Path segment index
+     * @param {number} [time] - Point time
      */
-    insertPoint3v(point3v: Vec3, index?: number, color?: NumberArray4, segmentIndex?: number): void;
+    insertPoint3v(point3v: Vec3, index?: number, color?: NumberArray4, segmentIndex?: number, time?: number): void;
     /**
      * Append new point in the end of the path.
      * @public
      * @param {Vec3} point3v - New point coordinates.
      * @param {number} [segmentIndex=0] - Path segment index, first by default.
      * @param {NumberArray4} [color] - Point color
+     * @param {number} [time] - Point time
      */
-    addPoint3v(point3v: Vec3, segmentIndex?: number, color?: NumberArray4): void;
+    addPoint3v(point3v: Vec3, segmentIndex?: number, color?: NumberArray4, time?: number): void;
     /**
      * Append new geodetic point in the end of the path.
      * @public
      * @param {LonLat} lonLat - New coordinate.
      * @param {number} [segmentIndex=0] - Path segment index, first by default.
      * @param {NumberArray4} [color] - Point color.
+     * @param {number} [time] - Point time.
      */
-    addPointLonLat(lonLat: LonLat, segmentIndex?: number, color?: NumberArray4): void;
+    addPointLonLat(lonLat: LonLat, segmentIndex?: number, color?: NumberArray4, time?: number): void;
     /**
      * Change path point color
      * @param {NumberArray4} color - New color
@@ -155,8 +166,8 @@ declare class Polyline {
      * @param {number} index - Segment index in multiline
      */
     removePath(index: number): void;
-    appendPath3v(path3v: SegmentPath3vExt, pathColors?: NumberArray4[]): void;
-    appendPathLonLat(pathLonLat: SegmentPathLonLatExt): void;
+    appendPath3v(path3v: SegmentPath3vExt, pathColors?: NumberArray4[], pathTimes?: number[]): void;
+    appendPathLonLat(pathLonLat: SegmentPathLonLatExt, pathColors?: NumberArray4[], pathTimes?: number[]): void;
     setPathLonLatFast(pathLonLat: SegmentPathLonLatExt[], pathColors?: (SegmentPathColor | NumberArray4)[] | SegmentPathColor | NumberArray4): void;
     setPath3vFast(path3v: SegmentPath3vExt[], pathColors?: (SegmentPathColor | NumberArray4)[] | SegmentPathColor | NumberArray4): void;
     /**
@@ -177,6 +188,22 @@ declare class Polyline {
      */
     setPathLonLat(pathLonLat: SegmentPathLonLatExt[], pathColors?: (SegmentPathColor | NumberArray4)[], forceEqual?: boolean): void;
     setPathLonLat(pathLonLat: SegmentPathLonLatExt, pathColors?: SegmentPathColor | NumberArray4, forceEqual?: boolean, segmentIndex?: number): void;
+    protected _pushPointTime(segmentIndex: number, index: number, time?: number): void;
+    /**
+     * Returns true when the polyline has point times and follows the entity collection time.
+     * @public
+     * @returns {boolean}
+     */
+    isTimed(): boolean;
+    getPathTimes(): number[][] | null;
+    /**
+     * Sets point times. Null removes them and the line stops following the entity collection time.
+     * @public
+     * @param {number[][] | number[] | null} times - Times per segment, or times of one segment.
+     * @param {number} [segmentIndex] - Segment index when times of one segment are given.
+     */
+    setPathTimes(pathTimes: number[][] | null): void;
+    setPathTimes(times: number[], segmentIndex: number): void;
     /**
      * Sets polyline opacity.
      * @public

package/lib/entity/polyline/PolylineBatchRenderer.d.ts

@@ -29,6 +29,7 @@ export interface IPolylineBatchRendererParams {
     color?: string[];
     visibility?: boolean;
     isTextured?: boolean;
+    isTimed?: boolean;
     isClosed?: boolean[];
     pathColors?: SegmentPathColor[];
     path3v?: SegmentPath3vExt[];
@@ -126,6 +127,10 @@ declare class PolylineBatchRenderer {
     protected _pathPhaseBuffer: WebGLBufferExt | null;
     protected _boundingSphereBuffer: WebGLBufferExt | null;
     protected _pickingColorsBuffer: WebGLBufferExt | null;
+    isTimed: boolean;
+    protected _pathTimes: (number[] | undefined)[];
+    protected _timesArr: TypedArray | number[];
+    protected _timesBuffer: WebGLBufferExt | null;
     protected _scene: Scene | null;
     /**
      * Entity instance that holds this Polyline.
@@ -203,6 +208,17 @@ declare class PolylineBatchRenderer {
     protected _updateTextureMetrics(segmentIndex: number): void;
     protected _updateAllTextureMetrics(): void;
     protected _updateTextureMetricsAfterPointChange(segmentIndex: number): void;
+    protected _pushPointTime(segmentIndex: number, index: number, time?: number): void;
+    protected _resolveTimeAt(segmentIndex: number, index: number): number;
+    protected _resolveSegmentTimes(segmentIndex: number, count: number): number[];
+    /**
+     * Sets point times of a path segment, used by the time opacity of timed renderers.
+     * @public
+     * @param {number[]} times - Time per point, missing values repeat the previous one.
+     * @param {number} segmentIndex - Path segment index.
+     */
+    setPathTimes(times: number[] | undefined, segmentIndex: number): void;
+    getPathTimes(): (number[] | undefined)[];
     protected _markGeometryBuffersChanged(includeTexCoords: boolean): void;
     protected _applyForceEqualSegmentUpdate<TSegment extends any[]>(segmentPath: TSegment, segmentIndex: number, pathColors: SegmentPathColor | NumberArray4 | undefined, currentPaths: TSegment[], equalUpdate: (segmentPath: TSegment, segmentIndex: number, pathColors?: SegmentPathColor | NumberArray4) => void, recreateData: (nextPaths: TSegment[]) => void, includeTexCoords: boolean): boolean;
     protected __appendLineDataCore(pathInput: SegmentPath3vExt[] | SegmentPathLonLatExt[], pathColors: SegmentPathColor[], pathPickingColors: NumberArray3[][], defaultColor: NumberArray4, opacity: number[], pathClosed: boolean[], outVerticesHigh: number[], outVerticesLow: number[], outOrders: number[], outIndexes: number[], outTexCoords: number[], ellipsoid: Ellipsoid | null, outPath3v: SegmentPath3vExt[], outPathLonLat: SegmentPathLonLatExt[], outPathMerc: LonLat[][], outExtent: Extent, outColors: number[], outThickness: number[], outTexParams: number[], outBoundingSpheres: number[], outPickingColors: number[], sourceType: LineSourceMode, segmentOffset?: number, indexFormat?: IndexFormatMode, skipTexCoords?: boolean, resetExtent?: boolean): void;
@@ -256,8 +272,8 @@ declare class PolylineBatchRenderer {
      * @param {number} index - Segment index in multiline
      */
     removePath(index: number): void;
-    appendPath3v(path3v: SegmentPath3vExt, pathColors?: NumberArray4[], opacity?: number): void;
-    appendPathLonLat(pathLonLat: SegmentPathLonLatExt, pathColors?: NumberArray4[], opacity?: number): void;
+    appendPath3v(path3v: SegmentPath3vExt, pathColors?: NumberArray4[], opacity?: number, pathTimes?: number[]): void;
+    appendPathLonLat(pathLonLat: SegmentPathLonLatExt, pathColors?: NumberArray4[], opacity?: number, pathTimes?: number[]): void;
     /**
      * Remove point from the path
      * @param {number} index - Point index in a path segment
@@ -270,8 +286,9 @@ declare class PolylineBatchRenderer {
      * @param {number} [index=0] - Index in the path
      * @param {NumberArray4} [color] - Point color
      * @param {number} [segmentIndex=0] - Path segment index
+     * @param {number} [time] - Point time
      */
-    insertPoint3v(point3v: Vec3, index?: number, color?: NumberArray4, segmentIndex?: number): void;
+    insertPoint3v(point3v: Vec3, index?: number, color?: NumberArray4, segmentIndex?: number, time?: number): void;
     /**
      * Append new point in the end of the path.
      * @public
@@ -279,17 +296,18 @@ declare class PolylineBatchRenderer {
      * @param {number} [segmentIndex=0] - Path segment index, first by default.
      * @param {NumberArray4} [color] - Point color.
      * @param {number} [opacity=1] - Point opacity.
+     * @param {number} [time] - Point time.
      */
-    addPoint3v(point3v: Vec3, segmentIndex?: number, color?: NumberArray4, opacity?: number): void;
+    addPoint3v(point3v: Vec3, segmentIndex?: number, color?: NumberArray4, opacity?: number, time?: number): void;
     /**
-     * Append new geodetic point in the end of the path.
+     * Append a new geodetic point at the end of the path.
      * @public
      * @param {LonLat} lonLat - New coordinate.
      * @param {number} [segmentIndex=0] - Path segment index, first by default.
      * @param {NumberArray4} [color] - Point color.
      * @param {number} [opacity=1]
      */
-    addPointLonLat(lonLat: LonLat, segmentIndex?: number, color?: NumberArray4, opacity?: number): void;
+    addPointLonLat(lonLat: LonLat, segmentIndex?: number, color?: NumberArray4, opacity?: number, time?: number): void;
     /**
      * Clear polyline data.
      * @public
@@ -403,6 +421,11 @@ declare class PolylineBatchRenderer {
     setPathLonLat(pathLonLat: SegmentPathLonLatExt, pathColors?: SegmentPathColor | NumberArray4, forceEqual?: boolean, segmentIndex?: number): void;
     drawOpaque(): void;
     drawTransparent(): void;
+    protected _bindTime(gl: WebGL2RenderingContext, sha: {
+        [id: string]: number;
+    }, shu: {
+        [id: string]: WebGLUniformLocation;
+    }): void;
     drawPicking(): void;
     /**
      * Refresh buffers.
@@ -431,6 +454,7 @@ declare class PolylineBatchRenderer {
      */
     protected _createIndexBuffer(): void;
     protected _createColorsBuffer(): void;
+    protected _createTimesBuffer(): void;
     protected _createPickingColorsBuffer(): void;
     protected _createThicknessBuffer(): void;
     protected _createTexParamsBuffer(): void;

package/lib/entity/polyline/PolylineHandler.d.ts

@@ -10,6 +10,7 @@ declare class PolylineHandler {
     _entityCollection: EntityCollection;
     pickingEnabled: boolean;
     protected _renderer: Renderer | null;
+    protected _scene: Scene | null;
     _relativeCenter: Vec3;
     _rtcEyePositionHigh: Float32Array;
     _rtcEyePositionLow: Float32Array;
@@ -17,7 +18,25 @@ declare class PolylineHandler {
     _transparentRenderer: PolylineBatchRenderer;
     _opaqueTexRenderer: PolylineBatchRenderer;
     _transparentTexRenderer: PolylineBatchRenderer;
+    _timedRenderer: PolylineBatchRenderer | null;
+    _timedTexRenderer: PolylineBatchRenderer | null;
     protected _polylines: Polyline[];
+    protected _visibleSpherePosition: Vec3 | null;
+    protected _visibleSphereRadius: number;
+    /**
+     * Current time of the lines with path times, in the same units as their times.
+     * @public
+     * @type {number}
+     */
+    time: number;
+    /**
+     * Opacity multipliers of the path parts already passed and still ahead of the current time.
+     * @public
+     * @type {Float32Array}
+     */
+    timeOpacity: Float32Array;
+    setTime(time: number): void;
+    setTimeOpacity(past: number, future: number): void;
     constructor(entityCollection: EntityCollection);
     setVisibleSphere(p: Vec3, r: number): void;
     /**
@@ -26,10 +45,12 @@ declare class PolylineHandler {
      */
     requestRedraw(): void;
     protected _initProgram(): void;
+    protected _initTimedPrograms(): void;
+    protected _createTimedRenderer(textured: boolean): PolylineBatchRenderer;
     bindScene(scene: Scene): void;
     add(polyline: Polyline): void;
     remove(polyline: Polyline): void;
-    getRenderer(opacity: number, textured: boolean): PolylineBatchRenderer;
+    getRenderer(opacity: number, textured: boolean, timed?: boolean): PolylineBatchRenderer;
     reindexAfterRemoval(removedBatchIndex: number, renderer: PolylineBatchRenderer): void;
     reindexPolylineArray(startIndex: number): void;
     drawForward(): void;

package/lib/entity/ray/Ray.d.ts

@@ -99,6 +99,13 @@ declare class Ray {
      * @param {number} z - Z coordinate.
      */
     setStartPosition(x: number, y: number, z: number): void;
+    protected _splitPosition(position: Vec3, high: Vec3, low: Vec3): void;
+    _splitPositions(): void;
+    /**
+     * Recomputes the start and end positions relative to the handler relative center.
+     * @public
+     */
+    updateRTCPosition(): void;
     getLength(): number;
     /**
      * Sets image template url source.

package/lib/entity/ray/RayHandler.d.ts

@@ -19,6 +19,9 @@ declare class RayHandler {
     protected _renderer: Renderer | null;
     protected _rays: Ray[];
     protected _opaqueCounterIndex: number;
+    _relativeCenter: Vec3;
+    protected _rtcEyePositionHigh: Float32Array;
+    protected _rtcEyePositionLow: Float32Array;
     protected _vertexBuffer: WebGLBufferExt | null;
     protected _startPositionHighBuffer: WebGLBufferExt | null;
     protected _startPositionLowBuffer: WebGLBufferExt | null;
@@ -71,6 +74,7 @@ declare class RayHandler {
     drawPicking(): void;
     reindexRaysArray(startIndex: number): void;
     protected _removeRay(ray: Ray): void;
+    setRelativeCenter(c: Vec3): void;
     remove(ray: Ray): void;
     setStartPositionArr(index: number, positionHigh: Vec3, positionLow: Vec3): void;
     setEndPositionArr(index: number, positionHigh: Vec3, positionLow: Vec3): void;

package/lib/entity/strip/Strip.d.ts

@@ -16,12 +16,15 @@ export interface IStripParams {
     color?: string | NumberArray4 | Vec4;
     opacity?: number;
     path?: TStrip[];
+    pathTimes?: number[];
 }
 /**
  * Strip object.
  * @class
  * @param {*} [options] - Strip options:
  * @param {boolean} [options.visibility] - Strip visibility.
+ * @param {number[]} [options.pathTimes] - Time of every path edge. Makes the strip follow the
+ * entity collection time, see {@link EntityCollection#setTime} and {@link EntityCollection#setTimeOpacity}.
  * @example <caption>Stripe example</caption>
  * new og.Entity({
  *     strip: {
@@ -62,6 +65,11 @@ declare class Strip {
     protected _verticesLow: number[];
     protected _indexes: number[];
     protected _path: TStrip[];
+    protected _times: number[] | null;
+    protected _timesArr: Int32Array;
+    protected _timesBuffer: WebGLBufferExt | null;
+    protected _suspendBuffers: boolean;
+    protected _rtcCenter: Vec3;
     protected _pickingColor: Float32Array;
     protected _gridSize: number;
     /**
@@ -103,6 +111,21 @@ declare class Strip {
      */
     setOpacity(opacity: number): void;
     isOpaque(): boolean;
+    /**
+     * Returns true when the strip has edge times and follows the entity collection time.
+     * @public
+     * @returns {boolean}
+     */
+    isTimed(): boolean;
+    getPathTimes(): number[] | null;
+    /**
+     * Sets edge times. Null removes them and the strip stops following the entity collection time.
+     * @public
+     * @param {number[] | null} times - Time of every path edge, missing values repeat the previous one.
+     */
+    setPathTimes(times: number[] | null): void;
+    protected _resolveTimes(): number[];
+    protected _rebuildTimes(): void;
     /**
      * Sets strip visibility.
      * @public
@@ -119,6 +142,13 @@ declare class Strip {
      * @param {Scene}  scene - Assigned render node.
      */
     bindScene(scene: Scene): void;
+    protected _toTwoFloats(p: Vec3): void;
+    /**
+     * Rebuilds vertices relative to the handler relative center when it has moved.
+     * @public
+     * @returns {boolean} True when the strip was rebuilt.
+     */
+    updateRTCPosition(): boolean;
     /**
      * Removes from entity.
      * @public
@@ -134,12 +164,12 @@ declare class Strip {
      */
     _deleteBuffers(): void;
     protected _createBuffers(): void;
-    addEdge3v(p2: Vec3, p3: Vec3): void;
-    setEdge3v(p2: Vec3, p3: Vec3, index: number): void;
+    addEdge3v(p2: Vec3, p3: Vec3, time?: number): void;
+    setEdge3v(p2: Vec3, p3: Vec3, index: number, time?: number): void;
     removeEdge(index: number): void;
     setGridSize(gridSize: number): void;
     getPath(): TStrip[];
-    setPath(path: TStripExt[] | TStrip[]): void;
-    insertEdge3v(p0: Vec3, p1: Vec3, index: number): void;
+    setPath(path: TStripExt[] | TStrip[], pathTimes?: number[]): void;
+    insertEdge3v(p0: Vec3, p1: Vec3, index: number, time?: number): void;
 }
 export { Strip };

package/lib/entity/strip/StripHandler.d.ts

@@ -2,6 +2,7 @@ import { EntityCollection } from "../EntityCollection";
 import { Renderer } from "../../renderer/Renderer";
 import { Scene } from "../../scene/Scene";
 import { Strip } from "./Strip";
+import { Vec3 } from "../../math/Vec3";
 declare class StripHandler {
     static __counter__: number;
     protected __id: number;
@@ -30,8 +31,28 @@ declare class StripHandler {
      */
     protected _strips: Strip[];
     protected _opaqueCount: number;
+    _relativeCenter: Vec3;
+    _rtcEyePositionHigh: Float32Array;
+    _rtcEyePositionLow: Float32Array;
+    /**
+     * Current time of the lines with path times, in the same units as their times.
+     * @public
+     * @type {number}
+     */
+    time: number;
+    /**
+     * Opacity multipliers of the path parts already passed and still ahead of the current time.
+     * @public
+     * @type {Float32Array}
+     */
+    timeOpacity: Float32Array;
+    setTime(time: number): void;
+    setTimeOpacity(past: number, future: number): void;
     constructor(entityCollection: EntityCollection);
+    setRelativeCenter(c: Vec3): void;
+    protected _updateRTCEyePosition(): void;
     protected _initProgram(): void;
+    initTimedPrograms(): void;
     bindScene(scene: Scene): void;
     protected _swap(i: number, j: number): void;
     add(strip: Strip): 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";

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/Vector.d.ts

@@ -279,6 +279,19 @@ declare class Vector extends BaseTileMaterialLayer {
      * @param entityCollection
      */
     _bindEventsDefault(entityCollection: EntityCollection): void;
+    /**
+     * Sets the current time of polylines and strips with path times.
+     * @public
+     * @param {number} time - Time in the same units as the path times.
+     */
+    setTime(time: number): void;
+    /**
+     * Sets opacity multipliers of the path parts passed and ahead of the current time.
+     * @public
+     * @param {number} past - Multiplier up to the current time.
+     * @param {number} future - Multiplier after the current time.
+     */
+    setTimeOpacity(past: number, future: number): void;
     protected _collectStripCollectionPASS(outArr: EntityCollection[]): void;
     protected _collectPolylineCollectionPASS(outArr: EntityCollection[]): void;
     protected _collectGeoObjectCollectionPASS(outArr: EntityCollection[]): void;

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;