@openglobus/og 0.19.4 → 0.20.0

package/lib/@openglobus/js/entity/LabelHandler.d.ts

@@ -0,0 +1,65 @@
+import { Label } from "./Label";
+import { BaseBillboardHandler } from "./BaseBillboardHandler";
+import { EntityCollection } from "./EntityCollection";
+import { WebGLBufferExt } from "../webgl/Handler";
+import { Vec3 } from "../math/Vec3";
+import { Vec4 } from "../math/Vec4";
+type LabelWorkerCallbackData = {
+    vertexArr: Float32Array;
+    texCoordArr: Float32Array;
+    gliphParamArr: Float32Array;
+    positionHighArr: Float32Array;
+    positionLowArr: Float32Array;
+    sizeArr: Float32Array;
+    offsetArr: Float32Array;
+    rgbaArr: Float32Array;
+    rotationArr: Float32Array;
+    fontIndexArr: Float32Array;
+    outlineArr: Float32Array;
+    outlineColorArr: Float32Array;
+    pickingColorArr: Float32Array;
+};
+declare class LabelHandler extends BaseBillboardHandler {
+    protected _billboards: Label[];
+    protected _gliphParamBuffer: WebGLBufferExt | null;
+    protected _fontIndexBuffer: WebGLBufferExt | null;
+    protected _outlineBuffer: WebGLBufferExt | null;
+    protected _outlineColorBuffer: WebGLBufferExt | null;
+    protected _gliphParamArr: Float32Array;
+    protected _fontIndexArr: Float32Array;
+    protected _outlineArr: Float32Array;
+    protected _outlineColorArr: Float32Array;
+    _maxLetters: number;
+    constructor(entityCollection: EntityCollection, maxLetters?: number);
+    initProgram(): void;
+    get labels(): Label[];
+    add(label: Label): void;
+    updateFonts(): void;
+    protected _addLabelToArrays(label: Label): void;
+    assignFontAtlas(label: Label): void;
+    workerCallback(data: LabelWorkerCallbackData, label: Label): void;
+    clear(): void;
+    protected _deleteBuffers(): void;
+    _displayPASS(): void;
+    protected _pickingPASS(): void;
+    protected _removeBillboard(label: Label): void;
+    setText(index: number, text: string, fontIndex: number, align: number, isRTL?: boolean): void;
+    setPositionArr(index: number, positionHigh: Vec3, positionLow: Vec3): void;
+    setPickingColorArr(index: number, color: Vec3): void;
+    setSizeArr(index: number, size: number): void;
+    setOffsetArr(index: number, offset: Vec3): void;
+    setRgbaArr(index: number, rgba: Vec4): void;
+    setOutlineColorArr(index: number, rgba: Vec4): void;
+    setOutlineArr(index: number, outline: number): void;
+    setRotationArr(index: number, rotation: number): void;
+    setVisibility(index: number, visibility: boolean): void;
+    setVertexArr(index: number, vertexArr: number[] | Float32Array): void;
+    setFontIndexArr(index: number, fontIndex: number): void;
+    createSizeBuffer(): void;
+    createFontIndexBuffer(): void;
+    createTexCoordBuffer(): void;
+    createOutlineBuffer(): void;
+    createOutlineColorBuffer(): void;
+    setMaxLetters(c: number): void;
+}
+export { LabelHandler };

package/lib/@openglobus/js/entity/LabelWorker.d.ts

@@ -0,0 +1,15 @@
+import { BaseWorker } from "../utils/BaseWorker";
+import { Label } from "../entity/Label";
+import { LabelHandler } from "../entity/LabelHandler";
+export declare const LOCK_UPDATE = -2;
+export declare const LOCK_FREE = -1;
+interface LabelInfo {
+    label: Label;
+    handler: LabelHandler;
+}
+declare class LabelWorker extends BaseWorker<LabelInfo> {
+    constructor(numWorkers?: number);
+    protected _onMessage(e: MessageEvent): void;
+    make(data: LabelInfo): void;
+}
+export { LabelWorker };

package/lib/@openglobus/js/entity/PointCloud.d.ts

@@ -0,0 +1,179 @@
+import { Entity } from "./Entity";
+import { PointCloudHandler } from "./PointCloudHandler";
+import { RenderNode } from "../scene/RenderNode";
+import { Vec3 } from "../math/Vec3";
+import { Vec4 } from "../math/Vec4";
+import { WebGLBufferExt } from "../webgl/Handler";
+import { EntityCollection } from "./EntityCollection";
+export interface IPointCloudParams {
+    visibility?: boolean;
+    pointSize?: number;
+    pickingScale?: number;
+    points?: Poi[];
+}
+type Poi = [number, number, number, number, number, number, number, any | undefined];
+interface IPoint {
+    _entity: Entity | null;
+    _pickingColor: Vec3;
+    _entityCollection: EntityCollection | null;
+    index: number;
+    position: Vec3;
+    color: Vec4;
+    pointCloud: PointCloud;
+    properties: any;
+}
+/**
+ * PointCloud object.
+ * @class
+ * @param {*} [options] - Point cloud options:
+ * @param {Array.<Array.<number>>} [options.points] - Points cartesian coordinates array,
+ * where first three is cartesian coordinates, next fourth is an RGBA color, and last is a point properties.
+ * @param {number} [options.pointSize] - Point screen size in pixels.
+ * @param {number} [options.pickingScale] - Point border picking size in screen pixels.
+ * @param {boolean} [options.visibility] - Point cloud visibility.
+ * @example <caption>Creates point cloud with two ten pixel size points</caption>
+ * new og.Entity({
+ *     pointCloud: {
+ *         pointSize: 10,
+ *         points: [
+ *             [0, 0, 0, 255, 255, 255, 255, { 'name': 'White point' }],
+ *             [100, 100, 0, 255, 0, 0, 255, { 'name': 'Red point' }]
+ *         ]
+ *     }
+ * });
+ */
+declare class PointCloud {
+    static __counter__: number;
+    protected __id: number;
+    /**
+     * Cloud visibility.
+     * @public
+     * @type {boolean}
+     */
+    visibility: boolean;
+    /**
+     * Point screen size in pixels.
+     * @public
+     * @type {number}
+     */
+    pointSize: number;
+    /**
+     * Point picking border size in pixels.
+     * @public
+     * @type {number}
+     */
+    pickingScale: number;
+    /**
+     * Parent collection render node.
+     * @protected
+     * @type {RenderNode | null}
+     */
+    protected _renderNode: RenderNode | null;
+    /**
+     * Entity instance that holds this point cloud.
+     * @public
+     * @type {Entity | null}
+     */
+    _entity: Entity | null;
+    /**
+     * Points properties.
+     * @protected
+     * @type {IPoint[]}
+     */
+    protected _points: IPoint[];
+    /**
+     * Coordinates array.
+     * @protected
+     * @type {number[]}
+     */
+    protected _coordinatesData: number[];
+    /**
+     * Color array.
+     * @protected
+     * @type {number[]}
+     */
+    protected _colorData: number[];
+    /**
+     * Picking color array.
+     * @protected
+     * @type {number[]}
+     */
+    protected _pickingColorData: number[];
+    protected _coordinatesBuffer: WebGLBufferExt | null;
+    protected _colorBuffer: WebGLBufferExt | null;
+    protected _pickingColorBuffer: WebGLBufferExt | null;
+    /**
+     * Handler that stores and renders this object.
+     * @public
+     * @type {PointCloudHandler}
+     */
+    _handler: PointCloudHandler | null;
+    _handlerIndex: number;
+    protected _buffersUpdateCallbacks: Function[];
+    protected _changedBuffers: boolean[];
+    constructor(options?: IPointCloudParams);
+    /**
+     * Clears point cloud data
+     * @public
+     */
+    clear(): void;
+    /**
+     * Sets cloud visibility.
+     * @public
+     * @param {boolean} visibility - Visibility flag.
+     */
+    setVisibility(visibility: boolean): void;
+    /**
+     * @return {boolean} Point cloud visibility.
+     */
+    getVisibility(): boolean;
+    /**
+     * Assign rendering scene node.
+     * @public
+     * @param {RenderNode}  renderNode - Assigned render node.
+     */
+    setRenderNode(renderNode: RenderNode): void;
+    /**
+     * Removes from entity.
+     * @public
+     */
+    remove(): void;
+    /**
+     * Adds points to render.
+     * @public
+     * @param { Poi[]} points - Point cloud array.
+     * @example
+     * var points = [[0, 0, 0, 255, 255, 255, 255, { 'name': 'White point' }], [100, 100, 0, 255, 0, 0, 255, { 'name': 'Red point' }]];
+     */
+    setPoints(points: Poi[]): void;
+    setPointPosition(index: number, x: number, y: number, z: number): void;
+    setPointColor(index: number, r: number, g: number, b: number, a: number): void;
+    addPoints(points: Poi[]): void;
+    addPoint(index: number, point: Poi): void;
+    /**
+     * Returns specific point by index.
+     * @public
+     * @param {number} index - Point index.
+     * @return {Poi} Specific point
+     */
+    getPoint(index: number): IPoint;
+    removePoint(index: number): void;
+    insertPoint(index: number, point: Poi): void;
+    draw(): void;
+    drawPicking(): void;
+    /**
+     * Update gl buffers.
+     * @protected
+     */
+    protected _update(): void;
+    /**
+     * Delete buffers
+     * @public
+     */
+    _deleteBuffers(): void;
+    protected _createCoordinatesBuffer(): void;
+    protected _createColorBuffer(): void;
+    protected _createPickingColorBuffer(): void;
+    protected _setPickingColors(): void;
+}
+export { PointCloud };

package/lib/@openglobus/js/entity/PointCloudHandler.d.ts

@@ -0,0 +1,42 @@
+import { EntityCollection } from "./EntityCollection";
+import { PointCloud } from "./PointCloud";
+import { Renderer } from "../renderer/Renderer";
+import { RenderNode } from "../scene/RenderNode";
+declare class PointCloudHandler {
+    static __counter__: number;
+    protected __id: number;
+    /**
+     * Picking rendering option.
+     * @public
+     * @type {boolean}
+     */
+    pickingEnabled: boolean;
+    /**
+     * Parent collection
+     * @public
+     * @type {EntityCollection}
+     */
+    _entityCollection: EntityCollection;
+    /**
+     * Renderer
+     * @protected
+     * @type {Renderer|null}
+     */
+    protected _renderer: Renderer | null;
+    /**
+     * Point cloud array
+     * @protected
+     * @type {Array.<PointCloud>}
+     */
+    protected _pointClouds: PointCloud[];
+    constructor(entityCollection: EntityCollection);
+    protected _initProgram(): void;
+    setRenderNode(renderNode: RenderNode): void;
+    add(pointCloud: PointCloud): void;
+    remove(pointCloud: PointCloud): void;
+    protected _reindexPointCloudArray(startIndex: number): void;
+    draw(): void;
+    drawPicking(): void;
+    clear(): void;
+}
+export { PointCloudHandler };

package/lib/@openglobus/js/entity/Polyline.d.ts

@@ -0,0 +1,345 @@
+import { Entity } from "./Entity";
+import { Extent } from "../Extent";
+import { LonLat } from "../LonLat";
+import { NumberArray3, Vec3 } from "../math/Vec3";
+import { NumberArray2 } from "../math/Vec2";
+import { NumberArray4 } from "../math/Vec4";
+import { PolylineHandler } from "./PolylineHandler";
+import { RenderNode } from "../scene/RenderNode";
+import { WebGLBufferExt } from "../webgl/Handler";
+import { TypedArray } from "../utils/shared";
+import { Ellipsoid } from "../ellipsoid/Ellipsoid";
+export type Geodetic = LonLat | NumberArray2 | NumberArray3;
+export type Cartesian = Vec3 | NumberArray3;
+export type SegmentPath3vExt = Cartesian[];
+export type SegmentPathLonLatExt = Geodetic[];
+export type SegmentPathColor = NumberArray4[];
+export type SegmentPath3v = Vec3[];
+export type SegmentPathLonLat = LonLat[];
+export interface IPolylineParams {
+    altitude?: number;
+    thickness?: number;
+    opacity?: number;
+    color?: string;
+    visibility?: boolean;
+    isClosed?: boolean;
+    pathColors?: SegmentPathColor[];
+    path3v?: SegmentPath3vExt[];
+    pathLonLat?: SegmentPathLonLatExt[];
+}
+/**
+ * Polyline object.
+ * @class
+ * @param {Object} [options] - Polyline options:
+ * @param {number} [options.thickness] - Thickness in screen pixels 1.5 is default.
+ * @param {Number} [options.altitude] - Relative to ground layers altitude value.
+ * @param {Vec4} [options.color] - RGBA color.
+ * @param {Boolean} [options.opacity] - Line opacity.
+ * @param {Boolean} [options.visibility] - Polyline visibility. True default.
+ * @param {Boolean} [options.isClosed] - Closed geometry type identification.
+ * @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.
+ */
+declare class Polyline {
+    static __counter__: number;
+    /**
+     * Object uniq identifier.
+     * @protected
+     * @type {number}
+     */
+    protected __id: number;
+    altitude: number;
+    /**
+     * Polyline thickness in screen pixels.
+     * @public
+     * @type {number}
+     */
+    thickness: number;
+    protected _opacity: number;
+    /**
+     * Polyline RGBA color.
+     * @protected
+     * @type {Float32Array} - (exactly 4 entries)
+     */
+    protected _defaultColor: Float32Array | NumberArray4;
+    /**
+     * Polyline visibility.
+     * @public
+     * @type {boolean}
+     */
+    visibility: boolean;
+    /**
+     * Polyline geometry ring type identification.
+     * @protected
+     * @type {Boolean}
+     */
+    protected _closedLine: boolean;
+    /**
+     * Polyline cartesian coordinates.
+     * @public
+     * @type {Array.<Vec3>}
+     */
+    _path3v: SegmentPath3vExt[];
+    protected _pathLengths: number[];
+    /**
+     * Polyline geodetic degrees coordinates.
+     * @private
+     * @type {Array.<LonLat>}
+     */
+    protected _pathLonLat: SegmentPathLonLatExt[];
+    /**
+     * Polyline geodetic mercator coordinates.
+     * @public
+     * @type {Array.<LonLat>}
+     */
+    _pathLonLatMerc: LonLat[][];
+    protected _pathColors: SegmentPathColor[];
+    /**
+     * Polyline geodetic extent.
+     * @protected
+     * @type {Extent}
+     */
+    _extent: Extent;
+    protected _verticesHigh: TypedArray | number[];
+    protected _verticesLow: TypedArray | number[];
+    protected _orders: TypedArray | number[];
+    protected _indexes: TypedArray | number[];
+    protected _colors: TypedArray | number[];
+    protected _verticesHighBuffer: WebGLBufferExt | null;
+    protected _verticesLowBuffer: WebGLBufferExt | null;
+    protected _ordersBuffer: WebGLBufferExt | null;
+    protected _indexesBuffer: WebGLBufferExt | null;
+    protected _colorsBuffer: WebGLBufferExt | null;
+    protected _pickingColor: NumberArray3;
+    protected _renderNode: RenderNode | null;
+    /**
+     * Entity instance that holds this Polyline.
+     * @public
+     * @type {Entity}
+     */
+    _entity: Entity | null;
+    /**
+     * Handler that stores and renders this Polyline object.
+     * @public
+     * @type {PolylineHandler | null}
+     */
+    _handler: PolylineHandler | null;
+    _handlerIndex: number;
+    protected _buffersUpdateCallbacks: Function[];
+    protected _changedBuffers: boolean[];
+    constructor(options?: IPolylineParams);
+    /**
+     * Appends to the line array new cartesian coordinates line data.
+     * @static
+     */
+    static appendLineData3v(path3v: SegmentPath3vExt[], pathColors: SegmentPathColor[], defaultColor: NumberArray4, isClosed: boolean, outVerticesHigh: number[], outVerticesLow: number[], outOrders: number[], outIndexes: number[], ellipsoid: Ellipsoid, outTransformedPathLonLat: SegmentPathLonLatExt[], outPath3v: SegmentPath3vExt[], outTransformedPathMerc: LonLat[][], outExtent: Extent, outColors: number[]): void;
+    /**
+     * Appends to the line new cartesian coordinates point data.
+     * @static
+     */
+    static appendPoint3v(path3v: SegmentPath3vExt[], point3v: Vec3, pathColors: SegmentPathColor[], color: NumberArray4, isClosed: boolean, outVerticesHigh: number[], outVerticesLow: number[], outColors: number[], outOrders: number[], outIndexes: number[], ellipsoid: Ellipsoid | null, outTransformedPathLonLat: SegmentPathLonLatExt[], outTransformedPathMerc: LonLat[][], outExtent: Extent): void;
+    static setPathColors(pathLonLat: SegmentPathLonLatExt[], pathColors: SegmentPathColor[], defaultColor: NumberArray4, outColors: number[]): void;
+    /**
+     * Appends to the line array new geodetic coordinates line data.
+     * @static
+     */
+    static appendLineDataLonLat(pathLonLat: SegmentPathLonLatExt[], pathColors: SegmentPathColor[], defaultColor: NumberArray4, isClosed: boolean, outVerticesHigh: number[], outVerticesLow: number[], outOrders: number[], outIndexes: number[], ellipsoid: Ellipsoid, outTransformedPathCartesian: SegmentPath3vExt[], outPathLonLat: SegmentPathLonLatExt[], outTransformedPathMerc: LonLat[][], outExtent: Extent, outColors: number[]): void;
+    /**
+     * Sets polyline path with cartesian coordinates.
+     * @protected
+     * @param {SegmentPath3vExt[]} path3v - Cartesian coordinates.
+     */
+    protected _setEqualPath3v(path3v: SegmentPath3vExt[]): void;
+    /**
+     * Sets polyline with geodetic coordinates.
+     * @protected
+     * @param {SegmentPathLonLat[]} pathLonLat - Geodetic polyline path coordinates.
+     */
+    protected _setEqualPathLonLat(pathLonLat: SegmentPathLonLat[]): void;
+    setPointLonLat(lonlat: LonLat, index: number, segmentIndex: number): void;
+    /**
+     * Changes cartesian point coordinates of the path
+     * @param {Vec3} coordinates - New coordinates
+     * @param {number} [index=0] - Path segment index
+     * @param {number} [segmentIndex=0] - Index of the point in the path segment
+     * @param {boolean} [skipLonLat=false] - Do not update geodetic coordinates
+     */
+    setPoint3v(coordinates: Vec3, index?: number, segmentIndex?: number, skipLonLat?: boolean): void;
+    protected _resizePathLengths(index?: number): void;
+    /**
+     * Remove path segment
+     * @param {number} index - Path segment index
+     */
+    removeSegment(index: number): void;
+    /**
+     * Remove point from the path
+     * @param {number} index - Point index in a path segment
+     * @param {number} [multiLineIndex=0] - Segment path index
+     */
+    removePoint(index: number, multiLineIndex?: number): void;
+    /**
+     * Insert point coordinates in a path segment
+     * @param {Vec3} point3v - Point coordinates
+     * @param {number} [index=0] - Index in the path
+     * @param {NumberArray4} [color] - Point color
+     * @param {number} [multilineIndex=0] - Path segment index
+     */
+    insertPoint3v(point3v: Vec3, index?: number, color?: NumberArray4, multilineIndex?: number): void;
+    /**
+     * Adds a new cartesian point in the end of the path in a last line segment.
+     * @public
+     * @param {Vec3} point3v - New coordinates.
+     * @param {NumberArray4} [color] -
+     * @param {boolean} [skipEllipsoid] -
+     */
+    appendPoint3v(point3v: Vec3, color?: NumberArray4, skipEllipsoid?: boolean): void;
+    /**
+     * Append new point in the end of the path.
+     * @public
+     * @param {Vec3} point3v - New point coordinates.
+     * @param {number} [multiLineIndex=0] - Path segment index, first by default.
+     */
+    addPoint3v(point3v: Vec3, multiLineIndex?: number): void;
+    /**
+     * Append new geodetic point in the end of the path.
+     * @public
+     * @param {LonLat} lonLat - New coordinate.
+     * @param {number} [multiLineIndex=0] - Path segment index, first by default.
+     */
+    addPointLonLat(lonLat: LonLat, multiLineIndex?: number): void;
+    /**
+     * Clear polyline data.
+     * @public
+     */
+    clear(): void;
+    /**
+     * Change path point color
+     * @param {NumberArray4} color - New color
+     * @param {number} [index=0] - Point index
+     * @param {number} [segmentIndex=0] - Path segment index
+     */
+    setPointColor(color: NumberArray4, index?: number, segmentIndex?: number): void;
+    /**
+     * Sets polyline opacity.
+     * @public
+     * @param {number} opacity - Opacity.
+     */
+    setOpacity(opacity: number): void;
+    /**
+     * Sets Polyline thickness in screen pixels.
+     * @public
+     * @param {number} thickness - Thickness.
+     */
+    setAltitude(altitude: number): void;
+    /**
+     * Sets Polyline thickness in screen pixels.
+     * @public
+     * @param {number} thickness - Thickness.
+     */
+    setThickness(thickness: number): void;
+    /**
+     * Returns thickness.
+     * @public
+     * @return {number} Thickness in screen pixels.
+     */
+    getThickness(): number;
+    /**
+     * Sets visibility.
+     * @public
+     * @param {boolean} visibility - Polyline visibility.
+     */
+    setVisibility(visibility: boolean): void;
+    /**
+     * Gets Polyline visibility.
+     * @public
+     * @return {boolean} Polyline visibility.
+     */
+    getVisibility(): boolean;
+    /**
+     * Assign with render node.
+     * @public
+     * @param {RenderNode} renderNode -
+     */
+    setRenderNode(renderNode: RenderNode): void;
+    protected _clearData(): void;
+    protected _createData3v(path3v: SegmentPath3vExt[]): void;
+    protected _createDataLonLat(pathLonlat: SegmentPathLonLatExt[]): void;
+    /**
+     * Removes from an entity.
+     * @public
+     */
+    remove(): void;
+    setPickingColor3v(color: Vec3): void;
+    /**
+     * Returns polyline geodetic extent.
+     * @public
+     * @returns {Extent} - Geodetic extent
+     */
+    getExtent(): Extent;
+    /**
+     * Returns path cartesian coordinates.
+     * @return {SegmentPath3vExt[]} Polyline path.
+     */
+    getPath3v(): SegmentPath3vExt[];
+    /**
+     * Returns geodetic path coordinates.
+     * @return {SegmentPathLonLatExt[]} Polyline path.
+     */
+    getPathLonLat(): SegmentPathLonLatExt[];
+    getPathColors(): NumberArray4[][];
+    /**
+     * @todo
+     * @param {NumberArray4[][]} pathColors
+     */
+    setPathColors(pathColors: SegmentPathColor[]): void;
+    /**
+     * Sets polyline color
+     * @param {string} htmlColor- HTML color
+     */
+    setColorHTML(htmlColor: string): void;
+    /**
+     * Sets polyline geodetic coordinates.
+     * @public
+     * @param {SegmentPathLonLat[]} pathLonLat - Polyline path cartesian coordinates.
+     * @param {Boolean} [forceEqual=false] - OPTIMIZATION FLAG: Makes assigning faster for size equal coordinates array.
+     */
+    setPathLonLat(pathLonLat: SegmentPathLonLatExt[], forceEqual?: boolean): void;
+    /**
+     * Sets Polyline cartesian coordinates.
+     * @public
+     * @param {SegmentPath3vExt[]} path3v - Polyline path cartesian coordinates. (exactly 3 entries)
+     * @param {SegmentPathColor[]} [pathColors] - Polyline path cartesian coordinates. (exactly 3 entries)
+     * @param {Boolean} [forceEqual=false] - Makes assigning faster for size equal coordinates array.
+     */
+    setPath3v(path3v: SegmentPath3vExt[], pathColors?: SegmentPathColor[], forceEqual?: boolean): void;
+    draw(): void;
+    drawPicking(): void;
+    /**
+     * Refresh buffers.
+     * @protected
+     */
+    protected _refresh(): void;
+    /**
+     * Updates render buffers.
+     * @protected
+     */
+    protected _update(): void;
+    /**
+     * Clear GL buffers.
+     * @public
+     */
+    _deleteBuffers(): void;
+    /**
+     * Creates vertices buffers.
+     * @protected
+     */
+    protected _createVerticesBuffer(): void;
+    /**
+     * Creates gl index and order buffer.
+     * @protected
+     */
+    protected _createIndexBuffer(): void;
+    protected _createColorsBuffer(): void;
+}
+export { Polyline };

package/lib/@openglobus/js/entity/PolylineHandler.d.ts

@@ -0,0 +1,22 @@
+import { EntityCollection } from "./EntityCollection";
+import { Polyline } from "./Polyline";
+import { Renderer } from "../renderer/Renderer";
+import { RenderNode } from "../scene/RenderNode";
+declare class PolylineHandler {
+    static __counter__: number;
+    protected __id: number;
+    _entityCollection: EntityCollection;
+    pickingEnabled: boolean;
+    protected _renderer: Renderer | null;
+    protected _polylines: Polyline[];
+    constructor(entityCollection: EntityCollection);
+    protected _initProgram(): void;
+    setRenderNode(renderNode: RenderNode): void;
+    add(polyline: Polyline): void;
+    remove(polyline: Polyline): void;
+    reindexPolylineArray(startIndex: number): void;
+    draw(): void;
+    drawPicking(): void;
+    clear(): void;
+}
+export { PolylineHandler };