@openglobus/og 0.22.2 → 0.23.0

package/lib/js/entity/Entity.js

@@ -11,24 +11,35 @@ import { PointCloud } from "./PointCloud";
 import { Polyline } from "./Polyline";
 import { Ray } from "./Ray";
 import { Strip } from "./Strip";
+import { Quat } from "../math/Quat";
+import { RADIANS, clamp, DEGREES } from "../math";
 /**
  * Entity instances aggregate multiple forms of visualization into a single high-level object.
  * They can be created manually and added to entity collection.
  *
  * @class
- * @param {Object} [options] - Entity options:
- * @param {string} [options.name] - A human-readable name to display to users. It does not have to be unique.
- * @param {Vec3|Array.<number>} [options.cartesian] - Spatial entities like billboard, label etc. cartesian position.
- * @param {LonLat} [options.lonlat] - Geodetic coordinates for an entities like billboard, label etc.
- * @param {boolean} [options.aground] - True for entities that have to be placed on the relief.
- * @param {boolean} [options.visibility] - Entity visibility.
- * @param {*} [options.billboard] - Billboard options(see {@link Billboard}).
- * @param {*} [options.label] - Label options(see {@link Label}).
- * @param {*} [options.polyline] - Polyline options(see {@link Polyline}).
- * @param {*} [options.ray] - Ray options(see {@link Ray}).
- * @param {*} [options.pointCloud] - Point cloud options(see {@link PointCloud}).
- * @param {*} [options.geometry] - Geometry options (see {@link Geometry}), available for vector layer only.
- * @param {*} [options.properties] - Entity custom properties.
+ * @param {IEntityParams} [options] - Entity options:
+ * @param {string} [options.name] - Name of the entity.
+ * @param {any} [options.properties] - Additional properties of the entity.
+ * @param {Vec3 | NumberArray3} [options.cartesian] - Cartesian position.
+ * @param {LonLat | NumberArray3 | NumberArray2} [options.lonlat] - Geographic coordinates.
+ * @param {number} [options.altitude] - Altitude.
+ * @param {boolean} [options.visibility] - Visibility flag.
+ * @param {Billboard | IBillboardParams} [options.billboard] - Billboard object or parameters.
+ * @param {Label | ILabelParams} [options.label] - Label object or parameters.
+ * @param {Polyline | IPolylineParams} [options.polyline] - Polyline object or parameters.
+ * @param {Ray | IRayParams} [options.ray] - Ray object or parameters.
+ * @param {PointCloud | IPointCloudParams} [options.pointCloud] - Point cloud object or parameters.
+ * @param {Geometry | IGeometryParams} [options.geometry] - Geometry object or parameters.
+ * @param {GeoObject | IGeoObjectParams} [options.geoObject] - Geo object or parameters.
+ * @param {Strip | IStripParams} [options.strip] - Strip object or parameters.
+ * @param {boolean} [options.independentPicking] - Independent picking flag.
+ * @param {boolean} [options.relativePosition] - Parent relative position flag, otherwise position is absolute.
+ * @param {number} [options.pitch] - Rotation around local X-axis.
+ * @param {number} [options.yaw] - Rotation around local Y-axis.
+ * @param {number} [options.roll] - Rotation around local Z-axis.
+ * @param {number | Vec3 | NumberArray3} [options.scale] - Scaling factor.
+ * @param {boolean} [options.forceGlobalPosition] - Forces global position for children entities make them the same position as the parent.
  */
 class Entity {
     constructor(options = {}) {
@@ -36,9 +47,13 @@ class Entity {
         this.__id = Entity.__counter__++;
         this.properties = options.properties || {};
         this.properties.name = this.properties.name != undefined ? this.properties.name : "";
-        this.childrenNodes = [];
+        this.childEntities = [];
         this.parent = null;
+        this.forceGlobalPosition = options.forceGlobalPosition || false;
         this._cartesian = utils.createVector3(options.cartesian);
+        this._rootCartesian = new Vec3();
+        this._localPosition = utils.createVector3(options.localPosition);
+        this._absoluteLocalPosition = new Vec3();
         this._lonLat = utils.createLonLat(options.lonlat);
         this._lonLatMerc = new LonLat();
         this._altitude = options.altitude || 0.0;
@@ -49,6 +64,17 @@ class Entity {
         this._layerIndex = -1;
         this._pickingColor = new Vec3(0, 0, 0);
         this._independentPicking = options.independentPicking || false;
+        this._relativePosition = options.relativePosition || false;
+        this._pitch = options.pitch || 0;
+        this._yaw = options.yaw || 0;
+        this._roll = options.roll || 0;
+        this._pitchRad = this._pitch * RADIANS;
+        this._yawRad = this._yaw * RADIANS;
+        this._rollRad = this._roll * RADIANS;
+        this._scale = utils.createVector3(options.scale, new Vec3(1, 1, 1));
+        this._qFrame = Quat.IDENTITY;
+        this._qRot = Quat.IDENTITY;
+        this._absoluteQRot = Quat.IDENTITY;
         this._featureConstructorArray = {
             billboard: [Billboard, this.setBillboard],
             label: [Label, this.setLabel],
@@ -68,15 +94,90 @@ class Entity {
         this.geoObject = this._createOptionFeature("geoObject", options.geoObject);
         this.strip = this._createOptionFeature("strip", options.strip);
     }
+    /**
+     * Returns root entity object.
+     * @public
+     * @return {Entity}
+     */
+    get rootEntity() {
+        let pn = this;
+        while (pn) {
+            if (!pn.parent) {
+                return pn;
+            }
+            pn = pn.parent;
+        }
+        return this;
+    }
+    /**
+     * Sets relative position property
+     * @param isRelative
+     */
+    set relativePosition(isRelative) {
+        if (isRelative !== this._relativePosition) {
+            let cart = this.getAbsoluteCartesian(), pitch = this.getAbsolutePitch(), yaw = this.getAbsoluteYaw(), roll = this.getAbsoluteRoll();
+            this._relativePosition = isRelative;
+            // probably need to take root this.rootEntity
+            if (this.parent) {
+                this._rootCartesian.copy(this.parent._rootCartesian);
+            }
+            if (!isRelative) {
+                this.setCartesian3v(cart);
+                this.setPitch(pitch);
+                this.setYaw(yaw);
+                this.setRoll(roll);
+            }
+            else if (this.parent) {
+                this.setAbsoluteCartesian3v(cart);
+                this.setAbsolutePitch(pitch);
+                this.setAbsoluteYaw(yaw);
+                this.setAbsoluteRoll(roll);
+            }
+        }
+    }
+    /**
+     * Gets relative position property
+     * @public
+     * @returns{boolean}
+     */
+    get relativePosition() {
+        return this._relativePosition;
+    }
+    /**
+     * Gets current entity collection container.
+     * @public
+     * @returns {EntityCollection | null}
+     */
+    get entityCollection() {
+        return this._entityCollection;
+    }
+    /**
+     * Gets entity uniq id
+     * @public
+     * @returns {number}
+     */
     get id() {
         return this.__id;
     }
+    /**
+     * Checks if the given entity is equal to the current entity.
+     * @param {Entity} entity - The entity to compare.
+     * @returns {boolean} True if entities are equal, otherwise false.
+     */
     isEqual(entity) {
         return this.__id === entity.__id;
     }
+    /**
+     * Gets the layer index of the entity.
+     * @returns {number} The layer index.
+     */
     get layerIndex() {
         return this._layerIndex;
     }
+    /**
+     * Gets the instance class name of the entity.
+     * @returns {string} The instance name "Entity".
+     */
     get instanceName() {
         return "Entity";
     }
@@ -87,6 +188,10 @@ class Entity {
         }
         return null;
     }
+    /**
+     * Gets the collection index of the entity.
+     * @returns {number} The entity collection index.
+     */
     getCollectionIndex() {
         return this._entityCollectionIndex;
     }
@@ -94,7 +199,7 @@ class Entity {
      * Adds current entity into the specified entity collection.
      * @public
      * @param {EntityCollection | Vector} collection - Specified entity collection or vector layer.
-     * @param {Boolean} [rightNow=false] - Entity insertion option for vector layer.
+     * @param {boolean} [rightNow=false] - Entity insertion option for vector layer.
      * @returns {Entity} - This object.
      */
     addTo(collection, rightNow = false) {
@@ -102,7 +207,7 @@ class Entity {
         return this;
     }
     /**
-     * Removes current entity from collection and layer.
+     * Removes current entity from its collection or layer.
      * @public
      */
     remove() {
@@ -128,8 +233,8 @@ class Entity {
         this.ray && this.ray.setVisibility(visibility);
         // geometry
         this.geometry && this.geometry.setVisibility(visibility);
-        for (let i = 0; i < this.childrenNodes.length; i++) {
-            this.childrenNodes[i].setVisibility(visibility);
+        for (let i = 0; i < this.childEntities.length; i++) {
+            this.childEntities[i].setVisibility(visibility);
         }
     }
     /**
@@ -148,6 +253,278 @@ class Entity {
     setCartesian3v(cartesian) {
         this.setCartesian(cartesian.x, cartesian.y, cartesian.z);
     }
+    /**
+     * Gets scale factor
+     * @public
+     * @returns {Vec3}
+     */
+    getScale() {
+        return this._scale;
+    }
+    /**
+     * Sets XYZ axis scale for the inner object such as GeoObject
+     * @public
+     * @param {Vec3} scale - Scale factor
+     */
+    setScale3v(scale) {
+        this._scale.copy(scale);
+        this.geoObject && this.geoObject.setScale3v(this._scale);
+        for (let i = 0; i < this.childEntities.length; i++) {
+            this.childEntities[i].setScale3v(this.childEntities[i].getScale());
+        }
+    }
+    /**
+     * Sets scale for the inner object such as GeoObject
+     * @public
+     * @param {number} val - Scale factor
+     */
+    setScale(val) {
+        this._scale.set(val, val, val);
+        this.geoObject && this.geoObject.setScale(val);
+        for (let i = 0; i < this.childEntities.length; i++) {
+            this.childEntities[i].setScale3v(this.childEntities[i].getScale());
+        }
+    }
+    /**
+     * Gets the absolute rotation direction of the entity.
+     * @public
+     * @returns {Quat} The absolute rotation quaternion.
+     */
+    getAbsoluteRotation() {
+        return this._absoluteQRot.clone();
+    }
+    /**
+     * Gets the local rotation of the entity. For the root entity it is equal to the absolute rotation.
+     * @public
+     * @returns {Quat} The rotation quaternion.
+     */
+    getRotation() {
+        return this._qRot;
+    }
+    /**
+     * Rotates the entity to look at a given point in world coordinates.
+     * @public
+     * @param {Vec3} cart - The target position to look at.
+     */
+    setLook3v(cart) {
+        let lq = new Quat();
+        let p0 = this.getAbsoluteCartesian();
+        let rot;
+        if (this._entityCollection) {
+            let up = this._entityCollection.renderNode.ellipsoid.getSurfaceNormal3v(p0);
+            rot = lq.setLookRotation(cart.sub(p0), up).conjugate();
+        }
+        else {
+            rot = lq.setLookRotation(cart.sub(p0), Vec3.UP).conjugate();
+        }
+        this.setAbsoluteRotation(rot);
+    }
+    /**
+     * Rotates the entity to look at a given geographic coordinate.
+     * @public
+     * @param {LonLat} lonLat - The longitude and latitude to look at.
+     */
+    setLookLonLat(lonLat) {
+        if (this._entityCollection) {
+            let cart = this._entityCollection.renderNode.ellipsoid.lonLatToCartesian(lonLat);
+            this.setLook3v(cart);
+        }
+    }
+    /**
+     * Sets the absolute rotation of the entity.
+     * @public
+     * @param {Quat} rot - The new absolute rotation quaternion.
+     */
+    setAbsoluteRotation(rot) {
+        this._absoluteQRot.copy(rot);
+        this._updatePitchYawRoll();
+    }
+    /**
+     * Sets the local rotation of the entity.
+     * @param {Quat} rot - The new rotation quaternion.
+     */
+    setRotation(rot) {
+        //this._qRot.copy(rot);
+        //
+        //@todo when necessary
+        //
+    }
+    /**
+     * Sets the pitch rotation of the entity.
+     * @param {number} val - The new pitch angle in degrees.
+     */
+    setPitch(val) {
+        this._pitch = val;
+        this._pitchRad = val * RADIANS;
+        this._updateAbsolutePosition();
+    }
+    /**
+     * Sets the yaw rotation of the entity.
+     * @param {number} val - The new yaw angle in degrees.
+     */
+    setYaw(val) {
+        this._yaw = val;
+        this._yawRad = val * RADIANS;
+        this._updateAbsolutePosition();
+    }
+    /**
+     * Sets the roll rotation of the entity.
+     * @public
+     * @param {number} val - The new roll angle in degrees.
+     */
+    setRoll(val) {
+        this._roll = val;
+        this._rollRad = val * RADIANS;
+        this._updateAbsolutePosition();
+    }
+    /**
+     * Gets the pitch angle of the entity.
+     * @public
+     * @returns {number} The pitch angle in degrees.
+     */
+    getPitch() {
+        return this._pitch;
+    }
+    /**
+     * Gets the yaw angle of the entity.
+     * @public
+     * @returns {number} The yaw angle in degrees.
+     */
+    getYaw() {
+        return this._yaw;
+    }
+    /**
+     * Gets the roll angle of the entity.
+     * @public
+     * @returns {number} The roll angle in degrees.
+     */
+    getRoll() {
+        return this._roll;
+    }
+    /**
+     * Sets the absolute pitch of the entity.
+     * @public
+     * @param {number} val - The absolute pitch angle in degrees.
+     */
+    setAbsolutePitch(val) {
+        if (this._relativePosition) {
+            this._absoluteQRot.setPitchYawRoll(val * RADIANS, this.getAbsoluteYaw() * RADIANS, this.getAbsoluteRoll() * RADIANS, this._qFrame);
+            this._updatePitchYawRoll();
+        }
+        else {
+            this.setPitch(val);
+        }
+    }
+    /**
+     * Sets the absolute yaw of the entity.
+     * @public
+     * @param {number} val - The absolute yaw angle in degrees.
+     */
+    setAbsoluteYaw(val) {
+        if (this._relativePosition) {
+            this._absoluteQRot.setPitchYawRoll(this.getAbsolutePitch() * RADIANS, val * RADIANS, this.getAbsoluteRoll() * RADIANS, this._qFrame);
+            this._updatePitchYawRoll();
+        }
+        else {
+            this.setYaw(val);
+        }
+    }
+    /**
+     * Sets the absolute roll of the entity.
+     * @public
+     * @param {number} val - The absolute roll angle in degrees.
+     */
+    setAbsoluteRoll(val) {
+        if (this._relativePosition) {
+            this._absoluteQRot.setPitchYawRoll(this.getAbsolutePitch() * RADIANS, this.getAbsoluteYaw() * RADIANS, val * RADIANS, this._qFrame);
+            this._updatePitchYawRoll();
+        }
+        else {
+            this.setRoll(val);
+        }
+    }
+    /**
+     * Gets the absolute pitch angle of the entity.
+     * @public
+     * @returns {number} The absolute pitch angle in degrees.
+     */
+    getAbsolutePitch() {
+        if (this.parent && this._relativePosition) {
+            return this._qFrame.conjugate().inverse().mul(this._absoluteQRot).getPitch() * DEGREES;
+        }
+        return this._pitch;
+    }
+    /**
+     * Gets the absolute yaw angle of the entity.
+     * @public
+     * @returns {number} The absolute yaw angle in degrees.
+     */
+    getAbsoluteYaw() {
+        if (this.parent && this._relativePosition) {
+            return this._qFrame.conjugate().inverse().mul(this._absoluteQRot).getYaw() * DEGREES;
+        }
+        return this._yaw;
+    }
+    /**
+     * Gets the absolute roll angle of the entity.
+     * @public
+     * @returns {number} The absolute roll angle in degrees.
+     */
+    getAbsoluteRoll() {
+        if (this.parent && this._relativePosition) {
+            return this._qFrame.conjugate().inverse().mul(this._absoluteQRot).getRoll() * DEGREES;
+        }
+        return this._roll;
+    }
+    _getScaleByDistance() {
+        let scd = 1;
+        if (this._entityCollection) {
+            let scaleByDistance = this._entityCollection.scaleByDistance;
+            let lookLength = 1;
+            if (this._entityCollection.renderNode && this._entityCollection.renderNode.renderer) {
+                lookLength = this._entityCollection.renderNode.renderer.activeCamera.eye.distance(this._rootCartesian);
+            }
+            //the same in the shader
+            scd = scaleByDistance[2] * clamp(lookLength, scaleByDistance[0], scaleByDistance[1]) / scaleByDistance[0];
+        }
+        return scd;
+    }
+    /**
+     * Sets the absolute cartesian position of the entity.
+     * @public
+     * @param {number} x - X coordinate.
+     * @param {number} y - Y coordinate.
+     * @param {number} z - Z coordinate.
+     */
+    setAbsoluteCartesian(x, y, z) {
+        this.setAbsoluteCartesian3v(new Vec3(x, y, z));
+    }
+    /**
+     * Sets the absolute cartesian position of the entity using a Vec3.
+     * @public
+     * @param {Vec3} absolutCartesian - The absolute cartesian position.
+     */
+    setAbsoluteCartesian3v(absolutCartesian) {
+        let pos = absolutCartesian;
+        if (this.parent && this._relativePosition) {
+            let scd = this._getScaleByDistance();
+            pos = absolutCartesian.sub(this.parent.getAbsoluteCartesian()).scale(1 / scd);
+            pos = this.parent._absoluteQRot.conjugate().mulVec3(pos);
+        }
+        this.setCartesian3v(pos);
+    }
+    /**
+     * Returns absolute cartesian position.
+     * @public
+     * @returns {Vec3} -
+     */
+    getAbsoluteCartesian() {
+        if (this.parent && this._relativePosition) {
+            let scd = this._getScaleByDistance();
+            return this._rootCartesian.add(this._absoluteLocalPosition.scaleTo(scd));
+        }
+        return this._cartesian.clone();
+    }
     /**
      * Sets entity cartesian position.
      * @public
@@ -156,31 +533,69 @@ class Entity {
      * @param {number} z - 3d space Z - position.
      */
     setCartesian(x, y, z) {
-        let p = this._cartesian;
-        p.x = x || 0.0;
-        p.y = y || 0.0;
-        p.z = z || 0.0;
-        // billboards
-        this.billboard && this.billboard.setPosition3v(p);
-        // geoObject
-        this.geoObject && this.geoObject.setPosition3v(p);
-        // labels
-        this.label && this.label.setPosition3v(p);
-        for (let i = 0; i < this.childrenNodes.length; i++) {
-            this.childrenNodes[i].setCartesian(x, y, z);
-        }
-        let ec = this._entityCollection;
-        if (ec && ec.renderNode && ec.renderNode.ellipsoid) {
-            this._lonLat = ec.renderNode.ellipsoid.cartesianToLonLat(p);
-            if (Math.abs(this._lonLat.lat) < mercator.MAX_LAT) {
-                this._lonLatMerc = this._lonLat.forwardMercator();
+        this._cartesian.set(x, y, z);
+        this._updateAbsolutePosition();
+        for (let i = 0; i < this.childEntities.length; i++) {
+            let chi = this.childEntities[i];
+            if (chi._relativePosition) {
+                chi.setCartesian3v(chi.getCartesian());
             }
-            else {
-                this._lonLatMerc.lon = this._lonLatMerc.lat = this._lonLatMerc.height = 0;
+            else if (chi.forceGlobalPosition) {
+                chi.setCartesian(x, y, z);
             }
         }
+        this._updateLonLat();
         //ec && ec.events.dispatch(ec.events.entitymove, this);
     }
+    _updatePitchYawRoll() {
+        if (this.parent) {
+            this._qRot = this.parent._absoluteQRot.conjugate().mul(this._absoluteQRot);
+            this._pitchRad = this._qRot.getPitch();
+            this._yawRad = this._qRot.getYaw();
+            this._rollRad = this._qRot.getRoll();
+            this._pitch = this._pitchRad * DEGREES;
+            this._yaw = this._yawRad * DEGREES;
+            this._roll = this._rollRad * DEGREES;
+            if (this.geoObject) {
+                this.geoObject.setRotation(this._absoluteQRot);
+            }
+            for (let i = 0; i < this.childEntities.length; i++) {
+                this.childEntities[i]._updateAbsolutePosition();
+            }
+        }
+    }
+    _updateAbsolutePosition() {
+        let parent = this.parent;
+        if (parent && this._relativePosition) {
+            this._qFrame.copy(parent._qFrame);
+            this._rootCartesian.copy(parent._rootCartesian);
+            this._qRot.setPitchYawRoll(this._pitchRad, this._yawRad, this._rollRad);
+            parent._absoluteQRot.mulRes(this._qRot, this._absoluteQRot);
+            let rotCart = parent._absoluteQRot.mulVec3(this._cartesian.add(this._localPosition));
+            parent._absoluteLocalPosition.addRes(rotCart, this._absoluteLocalPosition);
+        }
+        else {
+            this._qFrame = Quat.IDENTITY;
+            if (this._entityCollection && this._entityCollection.renderNode) {
+                this._qFrame = this._entityCollection.renderNode.getFrameRotation(this._cartesian);
+            }
+            this._qRot.setPitchYawRoll(this._pitchRad, this._yawRad, this._rollRad, this._qFrame);
+            this._absoluteQRot.copy(this._qRot);
+            this._rootCartesian.copy(this._cartesian);
+            this._absoluteLocalPosition.copy(this._localPosition);
+        }
+        if (this.geoObject) {
+            this.geoObject.setRotation(this._absoluteQRot);
+            this.geoObject.setPosition3v(this._rootCartesian);
+            this.geoObject.setLocalPosition3v(this._absoluteLocalPosition);
+        }
+        this.billboard && this.billboard.setPosition3v(this._rootCartesian);
+        this.label && this.label.setPosition3v(this._rootCartesian);
+        for (let i = 0, len = this.childEntities.length; i < len; i++) {
+            this.childEntities[i]._updateAbsolutePosition();
+        }
+        this._updateLonLat();
+    }
     /**
      * Sets entity cartesian position without event dispatching.
      * @public
@@ -188,27 +603,25 @@ class Entity {
      * @param {boolean} skipLonLat - skip geodetic calculation.
      */
     _setCartesian3vSilent(cartesian, skipLonLat = false) {
-        let p = this._cartesian;
-        p.x = cartesian.x || 0.0;
-        p.y = cartesian.y || 0.0;
-        p.z = cartesian.z || 0.0;
-        // billboards
-        this.billboard && this.billboard.setPosition3v(p);
-        // geoObject
-        this.geoObject && this.geoObject.setPosition3v(p);
-        // labels
-        this.label && this.label.setPosition3v(p);
-        for (let i = 0; i < this.childrenNodes.length; i++) {
-            this.childrenNodes[i].setCartesian(p.x, p.y, p.z);
+        this._cartesian.copy(cartesian);
+        this._updateAbsolutePosition();
+        for (let i = 0; i < this.childEntities.length; i++) {
+            this.childEntities[i].setCartesian(this._cartesian.x, this._cartesian.y, this._cartesian.z);
+        }
+        if (!skipLonLat) {
+            this._updateLonLat();
         }
+    }
+    _updateLonLat() {
         let ec = this._entityCollection;
-        if (!skipLonLat && ec && ec.renderNode && ec.renderNode.ellipsoid) {
-            this._lonLat = ec.renderNode.ellipsoid.cartesianToLonLat(p);
+        if (ec && ec.renderNode && ec.renderNode.ellipsoid) {
+            //let cart = this._rootCartesian.add(this._absoluteLocalPosition);
+            this._lonLat = ec.renderNode.ellipsoid.cartesianToLonLat(this.getAbsoluteCartesian());
             if (Math.abs(this._lonLat.lat) < mercator.MAX_LAT) {
                 this._lonLatMerc = this._lonLat.forwardMercator();
             }
             else {
-                //this._lonLatMerc = null;
+                this._lonLatMerc.lon = this._lonLatMerc.lat = 0;
             }
         }
     }
@@ -223,7 +636,7 @@ class Entity {
     /**
      * Sets geodetic coordinates of the entity point object.
      * @public
-     * @param {LonLat} lonlat - WGS84 coordinates.
+     * @param {LonLat} lonlat - coordinates.
      */
     setLonLat(lonlat) {
         let l = this._lonLat;
@@ -238,8 +651,9 @@ class Entity {
             else {
                 //this._lonLatMerc = null;
             }
-            ec.renderNode.ellipsoid.lonLatToCartesianRes(l, this._cartesian);
-            this.setCartesian3v(this._cartesian);
+            let temp = new Vec3();
+            ec.renderNode.ellipsoid.lonLatToCartesianRes(l, temp);
+            this.setAbsoluteCartesian3v(temp);
         }
     }
     /**
@@ -262,8 +676,9 @@ class Entity {
             else {
                 this._lonLatMerc.lon = this._lonLatMerc.lat = this._lonLatMerc.height = 0;
             }
-            ec.renderNode.ellipsoid.lonLatToCartesianRes(l, this._cartesian);
-            this.setCartesian3v(this._cartesian);
+            let temp = new Vec3();
+            ec.renderNode.ellipsoid.lonLatToCartesianRes(l, temp);
+            this.setAbsoluteCartesian3v(temp);
         }
     }
     /**
@@ -425,6 +840,11 @@ class Entity {
         this._entityCollection && this._entityCollection.stripHandler.add(strip);
         return strip;
     }
+    /**
+     * Gets layer container
+     * @public
+     * @returns {Vector | null}
+     */
     get layer() {
         return this._layer;
     }
@@ -448,7 +868,7 @@ class Entity {
             entity._pickingColor = this._pickingColor;
         }
         entity.parent = this;
-        this.childrenNodes.push(entity);
+        this.childEntities.push(entity);
         this._entityCollection && this._entityCollection.appendChildEntity(entity);
     }
     /**
@@ -463,8 +883,8 @@ class Entity {
         this.ray && this.ray.setPickingColor3v(c);
         this.strip && this.strip.setPickingColor3v(c);
         this.geoObject && this.geoObject.setPickingColor3v(c);
-        for (let i = 0; i < this.childrenNodes.length; i++) {
-            this.childrenNodes[i].setPickingColor();
+        for (let i = 0; i < this.childEntities.length; i++) {
+            this.childEntities[i].setPickingColor();
         }
     }
     /**
@@ -504,8 +924,8 @@ class Entity {
             if (e.northEast.lat > ne.lat)
                 ne.lat = e.northEast.lat;
         }
-        for (let i = 0; i < this.childrenNodes.length; i++) {
-            let e = this.childrenNodes[i].getExtent();
+        for (let i = 0; i < this.childEntities.length; i++) {
+            let e = this.childEntities[i].getExtent();
             if (e.southWest.lon < sw.lon)
                 sw.lon = e.southWest.lon;
             if (e.southWest.lat < sw.lat)