@openglobus/og 1.0.0-rc32 → 1.0.0-rc33

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/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/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;