@openglobus/og 0.22.2 → 0.24.0

package/lib/js/entity/InstanceData.d.ts

@@ -0,0 +1,76 @@
+import { GeoObject } from "./GeoObject";
+import { WebGLBufferExt, WebGLTextureExt } from "../webgl/Handler";
+import { TypedArray } from "../utils/shared";
+import { Program } from "../webgl/Program";
+import { GeoObjectHandler } from "./GeoObjectHandler";
+export declare class InstanceData {
+    isFree: boolean;
+    _geoObjectHandler: GeoObjectHandler;
+    geoObjects: GeoObject[];
+    numInstances: number;
+    _colorTexture: WebGLTextureExt | null;
+    _normalTexture: WebGLTextureExt | null;
+    _metallicRoughnessTexture: WebGLTextureExt | null;
+    _colorTextureSrc: string | null;
+    _normalTextureSrc: string | null;
+    _metallicRoughnessTextureSrc: string | null;
+    _objectSrc?: string;
+    _sizeArr: number[] | TypedArray;
+    _translateArr: number[] | TypedArray;
+    _vertexArr: number[] | TypedArray;
+    _rtcPositionHighArr: number[] | TypedArray;
+    _rtcPositionLowArr: number[] | TypedArray;
+    _qRotArr: number[] | TypedArray;
+    _rgbaArr: number[] | TypedArray;
+    _normalsArr: number[] | TypedArray;
+    _indicesArr: number[] | TypedArray;
+    _pickingColorArr: number[] | TypedArray;
+    _visibleArr: number[] | TypedArray;
+    _texCoordArr: number[] | TypedArray;
+    _localPositionArr: number[] | TypedArray;
+    _sizeBuffer: WebGLBufferExt | null;
+    _translateBuffer: WebGLBufferExt | null;
+    _vertexBuffer: WebGLBufferExt | null;
+    _rtcPositionHighBuffer: WebGLBufferExt | null;
+    _rtcPositionLowBuffer: WebGLBufferExt | null;
+    _qRotBuffer: WebGLBufferExt | null;
+    _rgbaBuffer: WebGLBufferExt | null;
+    _normalsBuffer: WebGLBufferExt | null;
+    _indicesBuffer: WebGLBufferExt | null;
+    _pickingColorBuffer: WebGLBufferExt | null;
+    _visibleBuffer: WebGLBufferExt | null;
+    _texCoordBuffer: WebGLBufferExt | null;
+    _localPositionBuffer: WebGLBufferExt | null;
+    _buffersUpdateCallbacks: Function[];
+    _changedBuffers: boolean[];
+    _materialParams: Float32Array;
+    _materialShininess: number;
+    constructor(geoObjectHandler: GeoObjectHandler);
+    setMaterialAmbient(r: number, g: number, b: number): void;
+    setMaterialDiffuse(r: number, g: number, b: number): void;
+    setMaterialSpecular(r: number, g: number, b: number): void;
+    setMaterialShininess(shininess: number): void;
+    setMaterialParams(ambient: Float32Array, diffuse: Float32Array, specular: Float32Array, shininess: number): void;
+    drawOpaque(p: Program): void;
+    drawTransparent(p: Program): void;
+    protected _drawElementsInstanced(p: Program): void;
+    createColorTexture(image: HTMLCanvasElement | ImageBitmap | ImageData | HTMLImageElement): void;
+    createNormalTexture(image: HTMLCanvasElement | ImageBitmap | ImageData | HTMLImageElement): void;
+    createMetallicRoughnessTexture(image: HTMLCanvasElement | ImageBitmap | ImageData | HTMLImageElement): void;
+    clear(): void;
+    _deleteBuffers(): void;
+    createVertexBuffer(): void;
+    createVisibleBuffer(): void;
+    createSizeBuffer(): void;
+    createTranslateBuffer(): void;
+    createLocalPositionBuffer(): void;
+    createTexCoordBuffer(): void;
+    createRTCPositionBuffer(): void;
+    createRgbaBuffer(): void;
+    createQRotBuffer(): void;
+    createNormalsBuffer(): void;
+    createIndicesBuffer(): void;
+    createPickingColorBuffer(): void;
+    refresh(): void;
+    update(): void;
+}

package/lib/js/entity/InstanceData.js

@@ -0,0 +1,347 @@
+import { makeArrayTyped } from "../utils/shared";
+import { VERTEX_BUFFER, RTC_POSITION_BUFFER, RGBA_BUFFER, NORMALS_BUFFER, INDEX_BUFFER, QROT_BUFFER, SIZE_BUFFER, PICKINGCOLOR_BUFFER, VISIBLE_BUFFER, TEXCOORD_BUFFER, TRANSLATE_BUFFER, LOCALPOSITION_BUFFER } from "./GeoObjectHandler";
+const AMBIENT_R = 0;
+const AMBIENT_G = 1;
+const AMBIENT_B = 2;
+const DIFFUSE_R = 3;
+const DIFFUSE_G = 4;
+const DIFFUSE_B = 5;
+const SPECULAR_R = 6;
+const SPECULAR_G = 7;
+const SPECULAR_B = 8;
+export class InstanceData {
+    constructor(geoObjectHandler) {
+        this.isFree = true;
+        this._geoObjectHandler = geoObjectHandler;
+        this.geoObjects = [];
+        this.numInstances = 0;
+        this._colorTexture = null;
+        this._colorTextureSrc = null;
+        this._normalTexture = null;
+        this._normalTextureSrc = null;
+        this._metallicRoughnessTexture = null;
+        this._metallicRoughnessTextureSrc = null;
+        this._sizeArr = [];
+        this._translateArr = [];
+        this._vertexArr = [];
+        this._rtcPositionHighArr = [];
+        this._rtcPositionLowArr = [];
+        this._qRotArr = [];
+        this._rgbaArr = [];
+        this._normalsArr = [];
+        this._indicesArr = [];
+        this._pickingColorArr = [];
+        this._visibleArr = [];
+        this._texCoordArr = [];
+        this._localPositionArr = [];
+        this._sizeBuffer = null;
+        this._translateBuffer = null;
+        this._vertexBuffer = null;
+        this._rtcPositionHighBuffer = null;
+        this._rtcPositionLowBuffer = null;
+        this._qRotBuffer = null;
+        this._rgbaBuffer = null;
+        this._normalsBuffer = null;
+        this._indicesBuffer = null;
+        this._pickingColorBuffer = null;
+        this._visibleBuffer = null;
+        this._texCoordBuffer = null;
+        this._localPositionBuffer = null;
+        this._materialParams = new Float32Array(9);
+        this._materialShininess = 0;
+        this._buffersUpdateCallbacks = [];
+        this._buffersUpdateCallbacks[PICKINGCOLOR_BUFFER] = this.createPickingColorBuffer;
+        this._buffersUpdateCallbacks[NORMALS_BUFFER] = this.createNormalsBuffer;
+        this._buffersUpdateCallbacks[RGBA_BUFFER] = this.createRgbaBuffer;
+        this._buffersUpdateCallbacks[INDEX_BUFFER] = this.createIndicesBuffer;
+        this._buffersUpdateCallbacks[VERTEX_BUFFER] = this.createVertexBuffer;
+        this._buffersUpdateCallbacks[SIZE_BUFFER] = this.createSizeBuffer;
+        this._buffersUpdateCallbacks[VISIBLE_BUFFER] = this.createVisibleBuffer;
+        this._buffersUpdateCallbacks[TEXCOORD_BUFFER] = this.createTexCoordBuffer;
+        this._buffersUpdateCallbacks[QROT_BUFFER] = this.createQRotBuffer;
+        this._buffersUpdateCallbacks[TRANSLATE_BUFFER] = this.createTranslateBuffer;
+        this._buffersUpdateCallbacks[RTC_POSITION_BUFFER] = this.createRTCPositionBuffer;
+        this._buffersUpdateCallbacks[LOCALPOSITION_BUFFER] = this.createLocalPositionBuffer;
+        this._changedBuffers = new Array(this._buffersUpdateCallbacks.length);
+    }
+    setMaterialAmbient(r, g, b) {
+        this._materialParams[AMBIENT_R] = r;
+        this._materialParams[AMBIENT_G] = g;
+        this._materialParams[AMBIENT_B] = b;
+    }
+    setMaterialDiffuse(r, g, b) {
+        this._materialParams[DIFFUSE_R] = r;
+        this._materialParams[DIFFUSE_G] = g;
+        this._materialParams[DIFFUSE_B] = b;
+    }
+    setMaterialSpecular(r, g, b) {
+        this._materialParams[SPECULAR_R] = r;
+        this._materialParams[SPECULAR_G] = g;
+        this._materialParams[SPECULAR_B] = b;
+    }
+    setMaterialShininess(shininess) {
+        this._materialShininess = shininess;
+    }
+    setMaterialParams(ambient, diffuse, specular, shininess) {
+        this.setMaterialAmbient(ambient[0], ambient[1], ambient[2]);
+        this.setMaterialDiffuse(diffuse[0], diffuse[1], diffuse[2]);
+        this.setMaterialSpecular(specular[0], specular[1], specular[2]);
+        this.setMaterialShininess(shininess);
+    }
+    //
+    //  Instance individual data
+    //
+    drawOpaque(p) {
+        let gl = p.gl, u = p.uniforms, a = p.attributes;
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._qRotBuffer);
+        gl.vertexAttribPointer(a.qRot, this._qRotBuffer.itemSize, gl.FLOAT, false, 0, 0);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._sizeBuffer);
+        gl.vertexAttribPointer(a.aScale, this._sizeBuffer.itemSize, gl.FLOAT, false, 0, 0);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._translateBuffer);
+        gl.vertexAttribPointer(a.aTranslate, this._translateBuffer.itemSize, gl.FLOAT, false, 0, 0);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._localPositionBuffer);
+        gl.vertexAttribPointer(a.aLocalPosition, this._localPositionBuffer.itemSize, gl.FLOAT, false, 0, 0);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._visibleBuffer);
+        gl.vertexAttribPointer(a.aDispose, this._visibleBuffer.itemSize, gl.FLOAT, false, 0, 0);
+        gl.uniform1f(u.uUseTexture, this._colorTexture ? 1 : 0);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._rgbaBuffer);
+        gl.vertexAttribPointer(a.aColor, this._rgbaBuffer.itemSize, gl.FLOAT, false, 0, 0);
+        gl.uniform3fv(u.materialParams, this._materialParams);
+        gl.uniform1f(u.materialShininess, this._materialShininess);
+        this._drawElementsInstanced(p);
+    }
+    //
+    //  Instance individual data
+    //
+    drawTransparent(p) {
+        let gl = p.gl, u = p.uniforms, a = p.attributes;
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._qRotBuffer);
+        gl.vertexAttribPointer(a.qRot, this._qRotBuffer.itemSize, gl.FLOAT, false, 0, 0);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._sizeBuffer);
+        gl.vertexAttribPointer(a.aScale, this._sizeBuffer.itemSize, gl.FLOAT, false, 0, 0);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._translateBuffer);
+        gl.vertexAttribPointer(a.aTranslate, this._translateBuffer.itemSize, gl.FLOAT, false, 0, 0);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._localPositionBuffer);
+        gl.vertexAttribPointer(a.aLocalPosition, this._localPositionBuffer.itemSize, gl.FLOAT, false, 0, 0);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._visibleBuffer);
+        gl.vertexAttribPointer(a.aDispose, this._visibleBuffer.itemSize, gl.FLOAT, false, 0, 0);
+        gl.uniform1f(u.uUseTexture, this._colorTexture ? 1 : 0);
+        gl.uniform3fv(u.materialParams, this._materialParams);
+        gl.uniform1f(u.materialShininess, this._materialShininess);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._rgbaBuffer);
+        gl.vertexAttribPointer(a.aColor, this._rgbaBuffer.itemSize, gl.FLOAT, false, 0, 0);
+        this._drawElementsInstanced(p);
+    }
+    //
+    // Instance common data(could be in VAO)
+    //
+    _drawElementsInstanced(p) {
+        let gl = p.gl, u = p.uniforms, a = p.attributes;
+        let r = this._geoObjectHandler._renderer;
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._rtcPositionHighBuffer);
+        gl.vertexAttribPointer(a.aRTCPositionHigh, this._rtcPositionHighBuffer.itemSize, gl.FLOAT, false, 0, 0);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._rtcPositionLowBuffer);
+        gl.vertexAttribPointer(a.aRTCPositionLow, this._rtcPositionLowBuffer.itemSize, gl.FLOAT, false, 0, 0);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._normalsBuffer);
+        gl.vertexAttribPointer(a.aVertexNormal, this._normalsBuffer.itemSize, gl.FLOAT, false, 0, 0);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._vertexBuffer);
+        gl.vertexAttribPointer(a.aVertexPosition, this._vertexBuffer.itemSize, gl.FLOAT, false, 0, 0);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, this._colorTexture || r.handler.defaultTexture);
+        gl.uniform1i(u.uTexture, 0);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._texCoordBuffer);
+        gl.vertexAttribPointer(a.aTexCoord, this._texCoordBuffer.itemSize, gl.FLOAT, false, 0, 0);
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._indicesBuffer);
+        p.drawElementsInstanced(gl.TRIANGLES, this._indicesBuffer.numItems, gl.UNSIGNED_INT, 0, this.numInstances);
+    }
+    createColorTexture(image) {
+        if (this._geoObjectHandler && this._geoObjectHandler._renderer) {
+            let h = this._geoObjectHandler._renderer.handler;
+            this._colorTexture = h.createTextureDefault(image, null, h.gl.REPEAT);
+        }
+    }
+    createNormalTexture(image) {
+        if (this._geoObjectHandler && this._geoObjectHandler._renderer) {
+            let h = this._geoObjectHandler._renderer.handler;
+            this._normalTexture = h.createTextureDefault(image, null, h.gl.REPEAT);
+        }
+    }
+    createMetallicRoughnessTexture(image) {
+        if (this._geoObjectHandler && this._geoObjectHandler._renderer) {
+            let h = this._geoObjectHandler._renderer.handler;
+            this._metallicRoughnessTexture = h.createTextureDefault(image, null, h.gl.REPEAT);
+        }
+    }
+    clear() {
+        this.numInstances = 0;
+        this.geoObjects = [];
+        this._sizeArr = [];
+        this._translateArr = [];
+        this._vertexArr = [];
+        this._rtcPositionHighArr = [];
+        this._rtcPositionLowArr = [];
+        this._qRotArr = [];
+        this._rgbaArr = [];
+        this._normalsArr = [];
+        this._indicesArr = [];
+        this._pickingColorArr = [];
+        this._visibleArr = [];
+        this._texCoordArr = [];
+        this._localPositionArr = [];
+        this._deleteBuffers();
+        this.isFree = false;
+        //this._geoObjectHandler = null;
+    }
+    _deleteBuffers() {
+        if (this._geoObjectHandler && this._geoObjectHandler._renderer) {
+            let h = this._geoObjectHandler._renderer.handler, gl = h.gl;
+            h.deleteTexture(this._colorTexture);
+            h.deleteTexture(this._normalTexture);
+            h.deleteTexture(this._metallicRoughnessTexture);
+            this._colorTexture = null;
+            this._normalTexture = null;
+            this._metallicRoughnessTexture = null;
+            gl.deleteBuffer(this._sizeBuffer);
+            gl.deleteBuffer(this._translateBuffer);
+            gl.deleteBuffer(this._vertexBuffer);
+            gl.deleteBuffer(this._rtcPositionHighBuffer);
+            gl.deleteBuffer(this._rtcPositionLowBuffer);
+            gl.deleteBuffer(this._qRotBuffer);
+            gl.deleteBuffer(this._rgbaBuffer);
+            gl.deleteBuffer(this._normalsBuffer);
+            gl.deleteBuffer(this._indicesBuffer);
+            gl.deleteBuffer(this._pickingColorBuffer);
+            gl.deleteBuffer(this._visibleBuffer);
+            gl.deleteBuffer(this._texCoordBuffer);
+            gl.deleteBuffer(this._localPositionBuffer);
+        }
+        this._sizeBuffer = null;
+        this._translateBuffer = null;
+        this._vertexBuffer = null;
+        this._rtcPositionHighBuffer = null;
+        this._rtcPositionLowBuffer = null;
+        this._qRotBuffer = null;
+        this._rgbaBuffer = null;
+        this._normalsBuffer = null;
+        this._indicesBuffer = null;
+        this._pickingColorBuffer = null;
+        this._visibleBuffer = null;
+        this._texCoordBuffer = null;
+        this._localPositionBuffer = null;
+    }
+    createVertexBuffer() {
+        const h = this._geoObjectHandler._renderer.handler;
+        h.gl.deleteBuffer(this._vertexBuffer);
+        this._vertexArr = makeArrayTyped(this._vertexArr);
+        this._vertexBuffer = h.createArrayBuffer(this._vertexArr, 3, this._vertexArr.length / 3);
+    }
+    createVisibleBuffer() {
+        const h = this._geoObjectHandler._renderer.handler, numItems = this._visibleArr.length;
+        if (!this._visibleBuffer || this._visibleBuffer.numItems !== numItems) {
+            h.gl.deleteBuffer(this._visibleBuffer);
+            this._visibleBuffer = h.createStreamArrayBuffer(1, numItems);
+        }
+        this._visibleArr = makeArrayTyped(this._visibleArr);
+        h.setStreamArrayBuffer(this._visibleBuffer, this._visibleArr);
+    }
+    createSizeBuffer() {
+        let h = this._geoObjectHandler._renderer.handler, numItems = this._sizeArr.length / 3;
+        if (!this._sizeBuffer || this._sizeBuffer.numItems !== numItems) {
+            h.gl.deleteBuffer(this._sizeBuffer);
+            this._sizeBuffer = h.createStreamArrayBuffer(3, numItems);
+        }
+        this._sizeArr = makeArrayTyped(this._sizeArr);
+        h.setStreamArrayBuffer(this._sizeBuffer, this._sizeArr);
+    }
+    createTranslateBuffer() {
+        let h = this._geoObjectHandler._renderer.handler, numItems = this._translateArr.length / 3;
+        if (!this._translateBuffer || this._translateBuffer.numItems !== numItems) {
+            h.gl.deleteBuffer(this._translateBuffer);
+            this._translateBuffer = h.createStreamArrayBuffer(3, numItems);
+        }
+        this._translateArr = makeArrayTyped(this._translateArr);
+        h.setStreamArrayBuffer(this._translateBuffer, this._translateArr);
+    }
+    createLocalPositionBuffer() {
+        let h = this._geoObjectHandler._renderer.handler, numItems = this._localPositionArr.length / 3;
+        if (!this._localPositionBuffer || this._localPositionBuffer.numItems !== numItems) {
+            h.gl.deleteBuffer(this._localPositionBuffer);
+            this._localPositionBuffer = h.createStreamArrayBuffer(3, numItems);
+        }
+        this._localPositionArr = makeArrayTyped(this._localPositionArr);
+        h.setStreamArrayBuffer(this._localPositionBuffer, this._localPositionArr);
+    }
+    createTexCoordBuffer() {
+        const h = this._geoObjectHandler._renderer.handler;
+        h.gl.deleteBuffer(this._texCoordBuffer);
+        this._texCoordArr = makeArrayTyped(this._texCoordArr);
+        this._texCoordBuffer = h.createArrayBuffer(this._texCoordArr, 2, this._texCoordArr.length / 2);
+    }
+    createRTCPositionBuffer() {
+        let h = this._geoObjectHandler._renderer.handler, numItems = this._rtcPositionHighArr.length / 3;
+        if (!this._rtcPositionHighBuffer || this._rtcPositionHighBuffer.numItems !== numItems) {
+            h.gl.deleteBuffer(this._rtcPositionHighBuffer);
+            h.gl.deleteBuffer(this._rtcPositionLowBuffer);
+            this._rtcPositionHighBuffer = h.createStreamArrayBuffer(3, numItems);
+            this._rtcPositionLowBuffer = h.createStreamArrayBuffer(3, numItems);
+        }
+        this._rtcPositionHighArr = makeArrayTyped(this._rtcPositionHighArr);
+        this._rtcPositionLowArr = makeArrayTyped(this._rtcPositionLowArr);
+        h.setStreamArrayBuffer(this._rtcPositionHighBuffer, this._rtcPositionHighArr);
+        h.setStreamArrayBuffer(this._rtcPositionLowBuffer, this._rtcPositionLowArr);
+    }
+    createRgbaBuffer() {
+        let h = this._geoObjectHandler._renderer.handler, numItems = this._rgbaArr.length / 4;
+        if (!this._rgbaBuffer || this._rgbaBuffer.numItems !== numItems) {
+            h.gl.deleteBuffer(this._rgbaBuffer);
+            this._rgbaBuffer = h.createStreamArrayBuffer(4, numItems);
+        }
+        this._rgbaArr = makeArrayTyped(this._rgbaArr);
+        h.setStreamArrayBuffer(this._rgbaBuffer, this._rgbaArr);
+    }
+    createQRotBuffer() {
+        let h = this._geoObjectHandler._renderer.handler, numItems = this._qRotArr.length / 4;
+        if (!this._qRotBuffer || this._qRotBuffer.numItems !== numItems) {
+            h.gl.deleteBuffer(this._qRotBuffer);
+            this._qRotBuffer = h.createStreamArrayBuffer(4, numItems);
+        }
+        this._qRotArr = makeArrayTyped(this._qRotArr);
+        h.setStreamArrayBuffer(this._qRotBuffer, this._qRotArr);
+    }
+    createNormalsBuffer() {
+        const h = this._geoObjectHandler._renderer.handler;
+        h.gl.deleteBuffer(this._normalsBuffer);
+        this._normalsArr = makeArrayTyped(this._normalsArr);
+        this._normalsBuffer = h.createArrayBuffer(this._normalsArr, 3, this._normalsArr.length / 3);
+    }
+    createIndicesBuffer() {
+        const h = this._geoObjectHandler._renderer.handler;
+        h.gl.deleteBuffer(this._indicesBuffer);
+        this._indicesArr = makeArrayTyped(this._indicesArr, Uint32Array);
+        this._indicesBuffer = h.createElementArrayBuffer(this._indicesArr, 1, this._indicesArr.length);
+    }
+    createPickingColorBuffer() {
+        const h = this._geoObjectHandler._renderer.handler;
+        h.gl.deleteBuffer(this._pickingColorBuffer);
+        this._pickingColorArr = makeArrayTyped(this._pickingColorArr);
+        this._pickingColorBuffer = h.createArrayBuffer(this._pickingColorArr, 3, this._pickingColorArr.length / 3);
+    }
+    refresh() {
+        let i = this._changedBuffers.length;
+        while (i--) {
+            this._changedBuffers[i] = true;
+        }
+    }
+    update() {
+        if (this._geoObjectHandler._renderer) {
+            let i = this._changedBuffers.length;
+            while (i--) {
+                if (this._changedBuffers[i]) {
+                    this._buffersUpdateCallbacks[i].call(this);
+                    this._changedBuffers[i] = false;
+                }
+            }
+            this.isFree = true;
+        }
+    }
+}

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

@@ -26,6 +26,8 @@ export interface IPolylineParams {
     pathColors?: SegmentPathColor[];
     path3v?: SegmentPath3vExt[];
     pathLonLat?: SegmentPathLonLatExt[];
+    visibleSpherePosition?: Cartesian;
+    visibleSphereRadius?: number;
 }
 /**
  * Polyline object.
@@ -128,23 +130,23 @@ declare class Polyline {
     _handlerIndex: number;
     protected _buffersUpdateCallbacks: Function[];
     protected _changedBuffers: boolean[];
+    protected _visibleSphere: Float32Array;
+    __doubleToTwoFloats: (pos: Vec3, highPos: Vec3, lowPos: Vec3) => void;
     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;
+    protected __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;
+    protected __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;
+    protected __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
@@ -226,6 +228,12 @@ declare class Polyline {
      * @param {number} opacity - Opacity.
      */
     setOpacity(opacity: number): void;
+    /**
+     * Gets polyline opacity.
+     * @public
+     * @param {number} opacity - Opacity.
+     */
+    getOpacity(): number;
     /**
      * Sets Polyline thickness in screen pixels.
      * @public
@@ -298,13 +306,16 @@ declare class Polyline {
      * @param {string} htmlColor- HTML color
      */
     setColorHTML(htmlColor: string): void;
+    setPathLonLatFast(pathLonLat: SegmentPathLonLatExt[], pathColors?: SegmentPathColor[]): void;
+    setPath3vFast(path3v: SegmentPath3vExt[], pathColors?: SegmentPathColor[]): 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;
+    setPathLonLat(pathLonLat: SegmentPathLonLatExt[], pathColors?: SegmentPathColor[], forceEqual?: boolean): void;
+    getSize(index?: number): number;
     /**
      * Sets Polyline cartesian coordinates.
      * @public
@@ -341,5 +352,7 @@ declare class Polyline {
      */
     protected _createIndexBuffer(): void;
     protected _createColorsBuffer(): void;
+    setVisibleSphere(p: Vec3, r: number): void;
+    updateRTCPosition(): void;
 }
 export { Polyline };