@openglobus/og 0.19.3 → 0.20.0

package/lib/js/entity/GeoObject.js

@@ -1,5 +1,6 @@
 import * as utils from "../utils/shared";
 import { Quat, Vec3 } from "../math/index";
+import { Object3d } from "../Object3d";
 /**
  * @class
  * @param {Object} options -  Geo object parameters:
@@ -21,15 +22,26 @@ class GeoObject {
         this._pitch = options.pitch || 0.0;
         this._yaw = options.yaw || 0.0;
         this._roll = options.roll || 0.0;
-        this._scale = options.scale || 1.0;
+        this._scale = utils.createVector3(options.scale, new Vec3(1, 1, 1));
         this._color = utils.createColorRGBA(options.color);
         this._direction = new Vec3(0, 1, 0);
         this._handler = null;
         this._handlerIndex = -1;
         this._tagData = null;
         this._tagDataIndex = -1;
-        this._object3d = options.object3d;
-        this._visibility = true;
+        let object3d = options.object3d;
+        if ((!options.object3d || options.object3d?.vertices.length === 0)) {
+            object3d = new Object3d();
+        }
+        if (options.objSrc) {
+            this.setObjectSrc(options.objSrc);
+            this._objectSrc = options.objSrc;
+        }
+        this._object3d = object3d;
+        if (options.textureSrc) {
+            this.setTextureSrc(options.textureSrc);
+        }
+        this._visibility = (options.visibility != undefined ? options.visibility : true);
         this._qNorthFrame = new Quat();
     }
     get tag() {
@@ -151,6 +163,25 @@ class GeoObject {
         this._yaw = yaw;
         this.updateDirection();
     }
+    setObject(object) {
+        this._object3d = object;
+    }
+    setObjectSrc(src) {
+        this._objectSrc = src;
+        this._handler && this._handler.setObjectSrc(src, this.tag);
+    }
+    setTextureSrc(src) {
+        this._textureSrc = src;
+        this._object3d && (this._object3d.src = src);
+        this._handler && this._handler.setTextureTag(src, this.tag);
+    }
+    setColorHTML(color) {
+        this.setColor4v(utils.htmlColorToRgba(color));
+    }
+    /**
+     *
+     * @param {number} pitch - Pitch in radians
+     */
     setPitch(pitch) {
         this._pitch = pitch;
         this._handler && this._handler.setPitchRollArr(this._tagData, this._tagDataIndex, pitch, this._roll);
@@ -159,8 +190,17 @@ class GeoObject {
         this._roll = roll;
         this._handler && this._handler.setPitchRollArr(this._tagData, this._tagDataIndex, this._pitch, roll);
     }
+    setPitchYawRoll(pitch, yaw, roll) {
+        this.setPitch(pitch);
+        this.setYaw(yaw);
+        this.setRoll(roll);
+    }
     setScale(scale) {
-        this._scale = scale;
+        this._scale.x = this._scale.y = this._scale.z = scale;
+        this._handler && this._handler.setScaleArr(this._tagData, this._tagDataIndex, this._scale);
+    }
+    setScale3v(scale) {
+        this._scale.copy(scale);
         this._handler && this._handler.setScaleArr(this._tagData, this._tagDataIndex, scale);
     }
     getScale() {

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

@@ -5,6 +5,7 @@ import { Planet } from "../scene/Planet";
 import { Vec3 } from "../math/Vec3";
 import { Vec4 } from "../math/Vec4";
 import { WebGLBufferExt, WebGLTextureExt } from "../webgl/Handler";
+import { Object3d } from "../Object3d";
 declare class InstanceData {
     isFree: boolean;
     _geoObjectHandler: GeoObjectHandler;
@@ -12,6 +13,7 @@ declare class InstanceData {
     numInstances: number;
     _texture: WebGLTextureExt | null;
     _textureSrc: string | null;
+    _objectSrc?: string;
     _pitchRollArr: number[] | TypedArray;
     _sizeArr: number[] | TypedArray;
     _vertexArr: number[] | TypedArray;
@@ -74,6 +76,9 @@ declare class GeoObjectHandler {
     constructor(entityCollection: EntityCollection);
     initProgram(): void;
     setRenderNode(renderNode: Planet): void;
+    setTextureTag(src: string, tag: string): void;
+    setObjectSrc(src: string, tag: string): void;
+    _updateInstanceData(object: Object3d, tag: string): void;
     protected _addGeoObjectToArray(geoObject: GeoObject): void;
     _displayPASS(): void;
     drawPicking(): void;
@@ -85,7 +90,7 @@ declare class GeoObjectHandler {
     setRgbaArr(tagData: InstanceData, tagDataIndex: number, rgba: Vec4): void;
     setPickingColorArr(tagData: InstanceData, tagDataIndex: number, color: Vec3): void;
     setPitchRollArr(tagData: InstanceData, tagDataIndex: number, pitch: number, roll: number): void;
-    setScaleArr(tagData: InstanceData, tagDataIndex: number, scale: number): void;
+    setScaleArr(tagData: InstanceData, tagDataIndex: number, scale: Vec3): void;
     protected _updateTag(dataTag: InstanceData): void;
     update(): void;
     _removeAll(): void;

package/lib/js/entity/GeoObjectHandler.js

@@ -1,5 +1,6 @@
 import * as shaders from "../shaders/geoObject";
 import { concatArrays, loadImage, makeArrayTyped, spliceArray } from "../utils/shared";
+import { Object3d } from "../Object3d";
 const VERTEX_BUFFER = 0;
 const POSITION_BUFFER = 1;
 const RGBA_BUFFER = 2;
@@ -151,10 +152,10 @@ class InstanceData {
         h.setStreamArrayBuffer(this._visibleBuffer, this._visibleArr);
     }
     createSizeBuffer() {
-        let h = this._geoObjectHandler._planet.renderer.handler, numItems = this._sizeArr.length;
+        let h = this._geoObjectHandler._planet.renderer.handler, numItems = this._sizeArr.length / 3;
         if (!this._sizeBuffer || this._sizeBuffer.numItems !== numItems) {
             h.gl.deleteBuffer(this._sizeBuffer);
-            this._sizeBuffer = h.createStreamArrayBuffer(1, numItems);
+            this._sizeBuffer = h.createStreamArrayBuffer(3, numItems);
         }
         this._sizeArr = makeArrayTyped(this._sizeArr);
         h.setStreamArrayBuffer(this._sizeBuffer, this._sizeArr);
@@ -267,6 +268,51 @@ class GeoObjectHandler {
         }
         this.update();
     }
+    setTextureTag(src, tag) {
+        const tagData = this._instanceDataMap.get(tag);
+        if (tagData) {
+            tagData._textureSrc = src;
+            this._instanceDataMap.set(tag, tagData);
+            this._loadDataTagTexture(tagData);
+        }
+    }
+    setObjectSrc(src, tag) {
+        const tagData = this._instanceDataMap.get(tag);
+        if (src) {
+            if (tagData && tagData._objectSrc !== src) {
+                tagData._objectSrc = src;
+                Object3d.loadObj(src).then((object3d) => {
+                    this._updateInstanceData(object3d[0], tag);
+                });
+            }
+        }
+    }
+    _updateInstanceData(object, tag) {
+        const tagData = this._instanceDataMap.get(tag);
+        if (tagData) {
+            if (object.vertices.length !== tagData._vertexArr.length) {
+                tagData._vertexArr = object.vertices;
+                tagData._changedBuffers[VERTEX_BUFFER] = true;
+                tagData._changedBuffers[DIRECTION_BUFFER] = true;
+            }
+            if (object.normals.length !== tagData._normalsArr.length) {
+                tagData._normalsArr = object.normals;
+                tagData._changedBuffers[NORMALS_BUFFER] = true;
+            }
+            if (object.indices.length !== tagData._indicesArr.length) {
+                tagData._indicesArr = object.indices;
+                tagData._changedBuffers[INDEX_BUFFER] = true;
+            }
+            if (object.texCoords.length !== tagData._texCoordArr.length) {
+                tagData._texCoordArr = object.texCoords;
+                tagData._changedBuffers[TEXCOORD_BUFFER] = true;
+            }
+            tagData._textureSrc = object.src;
+            this._loadDataTagTexture(tagData);
+            this._updateTag(tagData);
+            this._instanceDataMapValues = Array.from(this._instanceDataMap.values());
+        }
+    }
     _addGeoObjectToArray(geoObject) {
         const tag = geoObject.tag;
         let tagData = this._instanceDataMap.get(tag);
@@ -312,12 +358,17 @@ class GeoObjectHandler {
         x = geoObject.getPitch();
         y = geoObject.getRoll();
         tagData._pitchRollArr = concatArrays(tagData._pitchRollArr, setParametersToArray([], 0, itemSize, itemSize, x, y));
-        itemSize = 1;
-        tagData._sizeArr = concatArrays(tagData._sizeArr, setParametersToArray([], 0, itemSize, itemSize, geoObject.getScale()));
+        itemSize = 3;
+        let scale = geoObject.getScale();
+        x = scale.x;
+        y = scale.y;
+        z = scale.z;
+        tagData._sizeArr = concatArrays(tagData._sizeArr, setParametersToArray([], 0, itemSize, itemSize, x, y, z));
     }
     _displayPASS() {
         let r = this._planet.renderer, sh = r.handler.programs.geo_object, p = sh._program, u = p.uniforms, a = p.attributes, gl = r.handler.gl, ec = this._entityCollection;
         sh.activate();
+        //gl.disable(gl.CULL_FACE);
         //
         // Could be in VAO
         //
@@ -451,7 +502,7 @@ class GeoObjectHandler {
         this._updateTag(tagData);
     }
     setScaleArr(tagData, tagDataIndex, scale) {
-        setParametersToArray(tagData._sizeArr, tagDataIndex, 1, 1, scale);
+        setParametersToArray(tagData._sizeArr, tagDataIndex, 3, 3, scale.x, scale.y, scale.z);
         tagData._changedBuffers[SIZE_BUFFER] = true;
         this._updateTag(tagData);
     }
@@ -502,6 +553,7 @@ class GeoObjectHandler {
             geoObject.updateDirection();
             geoObject._tagData.refresh();
             this._updateTag(geoObject._tagData);
+            geoObject.setObjectSrc(geoObject._objectSrc);
         }
     }
     remove(geoObject) {
@@ -541,8 +593,8 @@ class GeoObjectHandler {
         tagData._positionLowArr = spliceArray(tagData._positionLowArr, tdi * 3, 3);
         tagData._directionArr = spliceArray(tagData._directionArr, tdi * 3, 3);
         tagData._pickingColorArr = spliceArray(tagData._pickingColorArr, tdi * 3, 3);
+        tagData._sizeArr = spliceArray(tagData._sizeArr, tdi * 3, 3);
         tagData._pitchRollArr = spliceArray(tagData._pitchRollArr, tdi * 2, 2);
-        tagData._sizeArr = spliceArray(tagData._sizeArr, tdi, 1);
         tagData._visibleArr = spliceArray(tagData._visibleArr, tdi, 1);
         geoObject._handlerIndex = -1;
         geoObject._handler = null;

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

@@ -4,7 +4,13 @@ import { GeometryHandler } from "./GeometryHandler";
 import { NumberArray4, Vec4 } from "../math/Vec4";
 import { NumberArray2 } from "../math/Vec2";
 import { NumberArray3 } from "../math/Vec3";
-declare const GeometryType: Record<string, number>;
+export declare enum GeometryTypeEnum {
+    POINT = 1,
+    LINESTRING = 2,
+    POLYGON = 3,
+    MULTIPOLYGON = 4,
+    MULTILINESTRING = 5
+}
 export type CoordinatesType = NumberArray2 | NumberArray3;
 export type IPointCoordinates = CoordinatesType;
 export type ILineStringCoordinates = CoordinatesType[];
@@ -12,11 +18,18 @@ export type IPolygonCoordinates = CoordinatesType[][];
 export type IMultiLineStringCoordinates = ILineStringCoordinates[];
 export type IMultiPolygonCoordinates = IPolygonCoordinates[];
 export type IGeometryCoordinates = IPointCoordinates | IPolygonCoordinates | IMultiPolygonCoordinates | ILineStringCoordinates | IMultiLineStringCoordinates;
-interface IGeometry {
-    type: string;
-    coordinates: IGeometryCoordinates;
+export type GeometryTypeToCoordinates = {
+    POINT: IPointCoordinates;
+    LINESTRING: ILineStringCoordinates;
+    POLYGON: IPolygonCoordinates;
+    MULTIPOLYGON: IMultiPolygonCoordinates;
+    MULTILINESTRING: IMultiLineStringCoordinates;
+};
+interface IGeometry<T extends keyof typeof GeometryTypeEnum = keyof typeof GeometryTypeEnum> {
+    type: T;
+    coordinates: GeometryTypeToCoordinates[T];
 }
-interface IGeometryStyle {
+export interface IGeometryStyle {
     fillColor?: string | NumberArray4 | Vec4;
     lineColor?: string | NumberArray4 | Vec4;
     strokeColor?: string | NumberArray4 | Vec4;
@@ -30,9 +43,9 @@ interface IGeometryStyleInternal {
     lineWidth: number;
     strokeWidth: number;
 }
-export interface IGeometryParams {
-    type?: string;
-    coordinates?: IGeometryCoordinates;
+export interface IGeometryParams<T extends keyof typeof GeometryTypeEnum = keyof typeof GeometryTypeEnum> {
+    type?: T;
+    coordinates?: GeometryTypeToCoordinates[T];
     style?: IGeometryStyle;
     visibility?: boolean;
 }
@@ -65,7 +78,7 @@ declare class Geometry {
     _lineIndexesHandlerIndex: number;
     _lineThicknessHandlerIndex: number;
     _lineColorsHandlerIndex: number;
-    protected _type: number;
+    protected _type: GeometryTypeEnum;
     _coordinates: IGeometryCoordinates;
     protected _extent: Extent;
     _style: IGeometryStyleInternal;
@@ -74,7 +87,7 @@ declare class Geometry {
     constructor(options?: IGeometryParams);
     get id(): number;
     get type(): number;
-    static getType(typeStr: string): number;
+    static getType(typeStr: keyof typeof GeometryTypeEnum): GeometryTypeEnum;
     /**
      * Returns geometry extent.
      @static
@@ -108,4 +121,4 @@ declare class Geometry {
     getExtent(): Extent;
     getType(): number;
 }
-export { Geometry, GeometryType };
+export { Geometry };

package/lib/js/entity/Geometry.js

@@ -2,6 +2,14 @@ import * as utils from "../utils/shared";
 import { Extent } from "../Extent";
 import { LonLat } from "../LonLat";
 import { Vec4 } from "../math/Vec4";
+export var GeometryTypeEnum;
+(function (GeometryTypeEnum) {
+    GeometryTypeEnum[GeometryTypeEnum["POINT"] = 1] = "POINT";
+    GeometryTypeEnum[GeometryTypeEnum["LINESTRING"] = 2] = "LINESTRING";
+    GeometryTypeEnum[GeometryTypeEnum["POLYGON"] = 3] = "POLYGON";
+    GeometryTypeEnum[GeometryTypeEnum["MULTIPOLYGON"] = 4] = "MULTIPOLYGON";
+    GeometryTypeEnum[GeometryTypeEnum["MULTILINESTRING"] = 5] = "MULTILINESTRING";
+})(GeometryTypeEnum || (GeometryTypeEnum = {}));
 const GeometryType = {
     POINT: 1,
     LINESTRING: 2,
@@ -33,10 +41,10 @@ class Geometry {
         this._lineIndexesHandlerIndex = -1;
         this._lineThicknessHandlerIndex = -1;
         this._lineColorsHandlerIndex = -1;
-        this._type = (options.type && Geometry.getType(options.type)) || GeometryType.POINT;
-        this._coordinates = [];
+        this._type = (options.type && Geometry.getType(options.type)) || GeometryTypeEnum.POINT;
+        this._coordinates = options.coordinates || [];
         this._extent = Geometry.getExtent({
-            type: options.type || "Point",
+            type: options.type || "POINT",
             coordinates: options.coordinates || []
         }, this._coordinates);
         options.style = options.style || {};
@@ -70,7 +78,7 @@ class Geometry {
     static getExtent(geometryObj, outCoordinates) {
         let res = new Extent(new LonLat(180.0, 90.0), new LonLat(-180.0, -90.0));
         let t = Geometry.getType(geometryObj.type);
-        if (t === GeometryType.POINT) {
+        if (t === GeometryTypeEnum.POINT) {
             let lon = geometryObj.coordinates[0], lat = geometryObj.coordinates[1];
             res.southWest.lon = lon;
             res.southWest.lat = lat;
@@ -78,7 +86,7 @@ class Geometry {
             res.northEast.lat = lat;
             outCoordinates && (outCoordinates[0] = lon) && (outCoordinates[1] = lat);
         }
-        else if (t === GeometryType.LINESTRING) {
+        else if (t === GeometryTypeEnum.LINESTRING) {
             let c = geometryObj.coordinates;
             for (let i = 0; i < c.length; i++) {
                 let lon = c[i][0], lat = c[i][1];
@@ -93,7 +101,7 @@ class Geometry {
                 outCoordinates && (outCoordinates[i] = [lon, lat]);
             }
         }
-        else if (t === GeometryType.POLYGON) {
+        else if (t === GeometryTypeEnum.POLYGON) {
             let c = geometryObj.coordinates;
             for (let i = 0; i < c.length; i++) {
                 let ci = c[i];
@@ -113,7 +121,7 @@ class Geometry {
                 }
             }
         }
-        else if (t === GeometryType.MULTIPOLYGON) {
+        else if (t === GeometryTypeEnum.MULTIPOLYGON) {
             let p = geometryObj.coordinates;
             for (let i = 0; i < p.length; i++) {
                 let pi = p[i];
@@ -137,7 +145,7 @@ class Geometry {
                 }
             }
         }
-        else if (t === GeometryType.MULTILINESTRING) {
+        else if (t === GeometryTypeEnum.MULTILINESTRING) {
             let c = geometryObj.coordinates;
             for (let i = 0; i < c.length; i++) {
                 let ci = c[i];
@@ -280,4 +288,4 @@ class Geometry {
     }
 }
 Geometry.__counter__ = 0;
-export { Geometry, GeometryType };
+export { Geometry };

package/lib/js/entity/GeometryHandler.js

@@ -2,7 +2,7 @@ import * as mercator from "../mercator";
 import * as quadTree from "../quadTree/quadTree";
 import { doubleToTwoFloatsV2 } from "../math/coder";
 import { Vec2 } from "../math/Vec2";
-import { GeometryType } from "./Geometry";
+import { GeometryTypeEnum } from "./Geometry";
 import { earcut, flatten } from "../utils/earcut";
 const POLYVERTICES_BUFFER = 0;
 const POLYINDEXES_BUFFER = 1;
@@ -203,7 +203,7 @@ class GeometryHandler {
             geometry._lineVerticesHighMerc = [];
             geometry._lineVerticesLowMerc = [];
             if (geometry._coordinates[0].length) {
-                if (geometry.type === GeometryType.POLYGON) {
+                if (geometry.type === GeometryTypeEnum.POLYGON) {
                     let coordinates = geometry._coordinates;
                     let ci = [];
                     for (let j = 0; j < coordinates.length; j++) {
@@ -249,7 +249,7 @@ class GeometryHandler {
                     geometry._lineColorsLength = this._lineColors.length - geometry._lineColorsHandlerIndex;
                     geometry._lineThicknessLength = this._lineThickness.length - geometry._lineThicknessHandlerIndex;
                 }
-                else if (geometry.type === GeometryType.MULTIPOLYGON) {
+                else if (geometry.type === GeometryTypeEnum.MULTIPOLYGON) {
                     let coordinates = geometry._coordinates;
                     let vertices = [], indexes = [];
                     // Creates polygon stroke data
@@ -303,7 +303,7 @@ class GeometryHandler {
                     geometry._lineColorsLength = this._lineColors.length - geometry._lineColorsHandlerIndex;
                     geometry._lineThicknessLength = this._lineThickness.length - geometry._lineThicknessHandlerIndex;
                 }
-                else if (geometry.type === GeometryType.LINESTRING) {
+                else if (geometry.type === GeometryTypeEnum.LINESTRING) {
                     let coordinates = geometry._coordinates;
                     let ci = new Array(coordinates.length);
                     for (let j = 0; j < coordinates.length; j++) {
@@ -322,7 +322,7 @@ class GeometryHandler {
                     geometry._lineColorsLength = this._lineColors.length - geometry._lineColorsHandlerIndex;
                     geometry._lineThicknessLength = this._lineThickness.length - geometry._lineThicknessHandlerIndex;
                 }
-                else if (geometry.type === GeometryType.MULTILINESTRING) {
+                else if (geometry.type === GeometryTypeEnum.MULTILINESTRING) {
                     let coordinates = geometry._coordinates;
                     let ci = [];
                     for (let j = 0; j < coordinates.length; j++) {

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

@@ -6,6 +6,7 @@ export interface ILabelParams extends IBaseBillboardParams {
     text?: string;
     face?: string;
     size?: number;
+    opacity?: number;
     outline?: number;
     outlineColor?: string | NumberArray4 | Vec4;
     align?: string;
@@ -91,6 +92,12 @@ declare class Label extends BaseBillboard {
      * It can't be bigger than maximum labelHandler _maxLetters value.
      */
     setText(text: string): void;
+    /**
+     * Change text direction.
+     * @public
+     * @param {boolean} isRTL - Text string.
+     */
+    setRtl(isRTL: boolean): void;
     /**
      * Gets current text string.
      * @public

package/lib/js/entity/Label.js

@@ -63,6 +63,17 @@ class Label extends BaseBillboard {
             this._handler.setText(this._handlerIndex, text, this._fontIndex, this._align, this._isRTL);
         }
     }
+    /**
+     * Change text direction.
+     * @public
+     * @param {boolean} isRTL - Text string.
+     */
+    setRtl(isRTL) {
+        this._isRTL = isRTL;
+        if (this._isReady && this._handler) {
+            this._handler.setText(this._handlerIndex, this._text, this._fontIndex, this._align, this._isRTL);
+        }
+    }
     /**
      * Gets current text string.
      * @public

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

@@ -9,12 +9,13 @@ import { RenderNode } from "../scene/RenderNode";
 import { WebGLBufferExt } from "../webgl/Handler";
 import { TypedArray } from "../utils/shared";
 import { Ellipsoid } from "../ellipsoid/Ellipsoid";
-type Geodetic = LonLat | NumberArray2 | NumberArray3;
-type Cartesian = Vec3 | NumberArray3;
-type SegmentPath3vExt = Cartesian[];
-type SegmentPathLonLatExt = Geodetic[];
-type SegmentPathColor = NumberArray4[];
-type SegmentPathLonLat = LonLat[];
+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;
@@ -138,6 +139,7 @@ declare class Polyline {
      * @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
@@ -224,6 +226,12 @@ declare class Polyline {
      * @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
@@ -284,7 +292,7 @@ declare class Polyline {
      * @todo
      * @param {NumberArray4[][]} pathColors
      */
-    setPathColors(pathColors: NumberArray4[][]): void;
+    setPathColors(pathColors: SegmentPathColor[]): void;
     /**
      * Sets polyline color
      * @param {string} htmlColor- HTML color

package/lib/js/entity/Polyline.js

@@ -376,6 +376,44 @@ class Polyline {
         outColors.push(r, g, b, a, r, g, b, a, r, g, b, a, r, g, b, a);
         outOrders.push(1, -1, 2, -2);
     }
+    static setPathColors(pathLonLat, pathColors, defaultColor, outColors) {
+        for (let j = 0, len = pathLonLat.length; j < len; j++) {
+            var path = pathLonLat[j], pathColors_j = pathColors[j];
+            if (path.length === 0) {
+                continue;
+            }
+            let color = defaultColor;
+            if (pathColors_j && pathColors_j[0]) {
+                color = pathColors_j[0];
+            }
+            let r = color[R], g = color[G], b = color[B], a = color[A] != undefined ? color[A] : 1.0;
+            if (j > 0) {
+                outColors.push(r, g, b, a, r, g, b, a, r, g, b, a, r, g, b, a);
+            }
+            for (let i = 0, len = path.length; i < len; i++) {
+                var cur = path[i];
+                if (cur instanceof Array) {
+                    cur = new LonLat(cur[0], cur[1], cur[2]);
+                }
+                if (pathColors_j && pathColors_j[i]) {
+                    color = pathColors_j[i];
+                }
+                r = color[R];
+                g = color[G];
+                b = color[B];
+                a = color[A] != undefined ? color[A] : 1.0;
+                outColors.push(r, g, b, a, r, g, b, a, r, g, b, a, r, g, b, a);
+            }
+            if (pathColors_j && pathColors_j[path.length - 1]) {
+                color = pathColors_j[path.length - 1];
+            }
+            r = color[R];
+            g = color[G];
+            b = color[B];
+            a = color[A] != undefined ? color[A] : 1.0;
+            outColors.push(r, g, b, a, r, g, b, a, r, g, b, a, r, g, b, a);
+        }
+    }
     /**
      * Appends to the line array new geodetic coordinates line data.
      * @static
@@ -389,10 +427,10 @@ class Polyline {
         }
         if (outIndexes.length > 0) {
             index = outIndexes[outIndexes.length - 5] + 9;
-            outIndexes.push(index, index);
+            outIndexes.push(index);
         }
         else {
-            outIndexes.push(0, 0);
+            outIndexes.push(0);
         }
         for (let j = 0, len = pathLonLat.length; j < len; j++) {
             var path = pathLonLat[j], pathColors_j = pathColors[j];
@@ -1150,6 +1188,14 @@ class Polyline {
     setOpacity(opacity) {
         this._opacity = opacity;
     }
+    /**
+     * Sets Polyline thickness in screen pixels.
+     * @public
+     * @param {number} thickness - Thickness.
+     */
+    setAltitude(altitude) {
+        this.altitude = altitude;
+    }
     /**
      * Sets Polyline thickness in screen pixels.
      * @public
@@ -1296,10 +1342,12 @@ class Polyline {
      * @param {NumberArray4[][]} pathColors
      */
     setPathColors(pathColors) {
-        if (this._renderNode) {
-            //
-            // ...
-            //
+        if (pathColors) {
+            this._colors = [];
+            this._pathColors = [].concat(pathColors);
+            Polyline.setPathColors(this._pathLonLat, pathColors, this._defaultColor, this._colors);
+            // Mark the colors buffer as changed
+            this._changedBuffers[COLORS_BUFFER] = true;
         }
     }
     /**

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

@@ -80,6 +80,18 @@ declare class Strip {
      * @public
      */
     clear(): void;
+    /**
+     * Sets RGBA color. Each channel from 0.0 to 1.0.
+     * @public
+     * @param {Vec4} color - RGBA vector.
+     */
+    setColor4v(color: Vec4): void;
+    /**
+     * Sets strip color.
+     * @public
+     * @param {string} color - HTML style color.
+     */
+    setColorHTML(color: string): void;
     setColor(r: number, g: number, b: number, a?: number): void;
     /**
      * Set strip opacity.

package/lib/js/entity/Strip.js

@@ -88,6 +88,22 @@ class Strip {
         this._indexes = [];
         this._deleteBuffers();
     }
+    /**
+     * Sets RGBA color. Each channel from 0.0 to 1.0.
+     * @public
+     * @param {Vec4} color - RGBA vector.
+     */
+    setColor4v(color) {
+        this.setColor(color.x, color.y, color.z, color.w);
+    }
+    /**
+     * Sets strip color.
+     * @public
+     * @param {string} color - HTML style color.
+     */
+    setColorHTML(color) {
+        this.setColor4v(utils.htmlColorToRgba(color));
+    }
     setColor(r, g, b, a) {
         a = a || this.color[3];
         this.color[0] = r;

package/lib/js/entity/StripHandler.js

@@ -37,7 +37,7 @@ class StripHandler {
                             mat4 viewMatrixRTE = viewMatrix;
                             viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
 
-                            gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+                            gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff * step(1.0, length(highDiff)) + lowDiff, 1.0);
                         }`,
                     fragmentShader: `precision highp float;
                         uniform vec4 uColor;