@openglobus/og 0.11.8 → 0.12.0

package/src/og/entity/GeoObjectHandler.js

@@ -87,7 +87,7 @@ class GeoObjectHandler {
         for (let i = 0, len = this._vertexArr.length; i < len; i++) {
             this._vertexBuffer && h.gl.deleteBuffer(this._vertexBuffer[i]);
             this._vertexArr[i] = makeArrayTyped(this._vertexArr[i]);
-            this._vertexBuffer[i] = h.createArrayBuffer(this._vertexArr[i], 3, len / 3);
+            this._vertexBuffer[i] = h.createArrayBuffer(this._vertexArr[i], 3, this._vertexArr[i].length / 3);
         }
     }
 
@@ -96,7 +96,7 @@ class GeoObjectHandler {
         for (let i = 0, len = this._pitchRollArr.length; i < len; i++) {
             this._pitchRollBuffer && h.gl.deleteBuffer(this._pitchRollBuffer[i]);
             this._pitchRollArr[i] = makeArrayTyped(this._pitchRollArr[i]);
-            this._pitchRollBuffer[i] = h.createArrayBuffer(this._pitchRollArr[i], 2, len / 2);
+            this._pitchRollBuffer[i] = h.createArrayBuffer(this._pitchRollArr[i], 2, this._pitchRollArr[i].length / 2);
         }
     }
 
@@ -105,7 +105,7 @@ class GeoObjectHandler {
         for (let i = 0, len = this._sizeArr.length; i < len; i++) {
             this._sizeBuffer && h.gl.deleteBuffer(this._sizeBuffer[i]);
             this._sizeArr[i] = makeArrayTyped(this._sizeArr[i]);
-            this._sizeBuffer[i] = h.createArrayBuffer(this._sizeArr[i], 1, len);
+            this._sizeBuffer[i] = h.createArrayBuffer(this._sizeArr[i], 1, this._sizeArr[i].length);
         }
     }
 
@@ -114,14 +114,10 @@ class GeoObjectHandler {
         for (let i = 0, len = this._positionHighArr.length; i < len; i++) {
             this._positionHighBuffer && h.gl.deleteBuffer(this._positionHighBuffer[i]);
             this._positionHighArr[i] = makeArrayTyped(this._positionHighArr[i]);
-            this._positionHighBuffer[i] = h.createArrayBuffer(this._positionHighArr[i], 3, len / 3);
+            this._positionHighBuffer[i] = h.createArrayBuffer(this._positionHighArr[i], 3, this._positionHighArr[i].length / 3);
             this._positionLowBuffer && h.gl.deleteBuffer(this._positionLowBuffer[i]);
             this._positionLowArr[i] = makeArrayTyped(this._positionLowArr[i]);
-            this._positionLowBuffer[i] = h.createArrayBuffer(
-                this._positionLowArr[i],
-                3,
-                this._positionLowArr[i].length / 3
-            );
+            this._positionLowBuffer[i] = h.createArrayBuffer(this._positionLowArr[i], 3, this._positionLowArr[i].length / 3);
         }
     }
 
@@ -130,7 +126,7 @@ class GeoObjectHandler {
         for (let i = 0, len = this._rgbaArr.length; i < len; i++) {
             this._rgbaBuffer && h.gl.deleteBuffer(this._rgbaBuffer[i]);
             this._rgbaArr[i] = makeArrayTyped(this._rgbaArr[i]);
-            this._rgbaBuffer[i] = h.createArrayBuffer(this._rgbaArr[i], 4, len / 4);
+            this._rgbaBuffer[i] = h.createArrayBuffer(this._rgbaArr[i], 4, this._rgbaArr[i].length / 4);
         }
     }
 
@@ -139,7 +135,7 @@ class GeoObjectHandler {
         for (let i = 0, len = this._directionArr.length; i < len; i++) {
             this._directionBuffer && h.gl.deleteBuffer(this._directionBuffer[i]);
             this._directionArr[i] = makeArrayTyped(this._directionArr[i]);
-            this._directionBuffer[i] = h.createArrayBuffer(this._directionArr[i], 3, len / 3);
+            this._directionBuffer[i] = h.createArrayBuffer(this._directionArr[i], 3, this._directionArr[i].length / 3);
         }
     }
 
@@ -148,7 +144,7 @@ class GeoObjectHandler {
         for (let i = 0, len = this._normalsArr.length; i < len; i++) {
             this._normalsBuffer && h.gl.deleteBuffer(this._normalsBuffer[i]);
             this._normalsArr[i] = makeArrayTyped(this._normalsArr[i]);
-            this._normalsBuffer[i] = h.createArrayBuffer(this._normalsArr[i], 3, len / 3);
+            this._normalsBuffer[i] = h.createArrayBuffer(this._normalsArr[i], 3, this._normalsArr[i].length / 3);
         }
     }
 
@@ -157,11 +153,7 @@ class GeoObjectHandler {
         for (let i = 0, len = this._indicesArr.length; i < len; i++) {
             this._indicesBuffer && h.gl.deleteBuffer(this._indicesBuffer[i]);
             this._indicesArr[i] = makeArrayTyped(this._indicesArr[i], Uint16Array);
-            this._indicesBuffer[i] = h.createElementArrayBuffer(
-                this._indicesArr[i],
-                1,
-                this._indicesArr[i].length
-            );
+            this._indicesBuffer[i] = h.createElementArrayBuffer(this._indicesArr[i], 1, this._indicesArr[i].length);
         }
     }
 
@@ -170,7 +162,7 @@ class GeoObjectHandler {
         for (let i = 0, len = this._pickingColorArr.length; i < len; i++) {
             this._pickingColorBuffer && h.gl.deleteBuffer(this._pickingColorBuffer[i]);
             this._pickingColorArr[i] = makeArrayTyped(this._pickingColorArr[i]);
-            this._pickingColorBuffer[i] = h.createArrayBuffer(this._pickingColorArr[i], 3, len / 3);
+            this._pickingColorBuffer[i] = h.createArrayBuffer(this._pickingColorArr[i], 3, this._pickingColorArr[i].length / 3);
         }
     }
 
@@ -215,14 +207,15 @@ class GeoObjectHandler {
         if (!alreadyAdded) {
             this._instancedTags.set(tag, {
                 iCounts: 1,
+                maxIndex: Math.max(...geoObject._indices),
                 index: this._instancedTags.size
             });
         } else {
             const prevState = this._instancedTags.get(tag),
                 nextCount = prevState.iCounts + 1;
             this._instancedTags.set(tag, {
-                iCounts: nextCount,
-                index: prevState.index
+                ...prevState,
+                iCounts: nextCount
             });
         }
         const tagData = this._instancedTags.get(tag),
@@ -233,7 +226,8 @@ class GeoObjectHandler {
          */
         geoObject._tagIndex = tagData.iCounts - 1;
         if (geoObject._visibility) {
-            if (!alreadyAdded) {
+            if (!this._vertexArr[ti] || this._vertexArr[ti].length !== geoObject._vertices.length) {
+
                 this._vertexArr[ti] = concatArrays(
                     this._vertexArr[ti],
                     setParametersToArray(
@@ -306,8 +300,6 @@ class GeoObjectHandler {
             setParametersToArray([], 0, itemSize, itemSize, x, y, z, w)
         );
 
-        this._indicesArr[ti] = concatArrays(this._indicesArr[ti], geoObject._indices);
-
         x = geoObject._pitch;
         y = geoObject._roll;
 
@@ -324,7 +316,7 @@ class GeoObjectHandler {
             this._sizeArr[ti],
             setParametersToArray([], 0, itemSize, itemSize, geoObject.scale)
         );
-        this._recalculateIndices();
+        this._addIndices(geoObject);
     }
 
     _displayPASS() {
@@ -357,47 +349,19 @@ class GeoObjectHandler {
                 ti = tagData.index;
 
             gl.bindBuffer(gl.ARRAY_BUFFER, this._normalsBuffer[ti]);
-            gl.vertexAttribPointer(
-                a.aVertexNormal,
-                this._normalsBuffer[ti].itemSize,
-                gl.FLOAT,
-                false,
-                0,
-                0
-            );
+            gl.vertexAttribPointer(a.aVertexNormal, this._normalsBuffer[ti].itemSize, gl.FLOAT, false, 0, 0);
 
             gl.bindBuffer(gl.ARRAY_BUFFER, this._vertexBuffer[ti]);
-            gl.vertexAttribPointer(
-                a.aVertexPosition,
-                this._vertexBuffer[ti].itemSize,
-                gl.FLOAT,
-                false,
-                0,
-                0
-            );
+            gl.vertexAttribPointer(a.aVertexPosition, this._vertexBuffer[ti].itemSize, gl.FLOAT, false, 0, 0);
 
             gl.bindBuffer(gl.ARRAY_BUFFER, this._directionBuffer[ti]);
-            gl.vertexAttribPointer(
-                a.aDirection,
-                this._directionBuffer[ti].itemSize,
-                gl.FLOAT,
-                false,
-                0,
-                0
-            );
+            gl.vertexAttribPointer(a.aDirection, this._directionBuffer[ti].itemSize, gl.FLOAT, false, 0, 0);
 
             gl.bindBuffer(gl.ARRAY_BUFFER, this._sizeBuffer[ti]);
             gl.vertexAttribPointer(a.aScale, this._sizeBuffer[ti].itemSize, gl.FLOAT, false, 0, 0);
 
             gl.bindBuffer(gl.ARRAY_BUFFER, this._pitchRollBuffer[ti]);
-            gl.vertexAttribPointer(
-                a.aPitchRoll,
-                this._pitchRollBuffer[ti].itemSize,
-                gl.FLOAT,
-                false,
-                0,
-                0
-            );
+            gl.vertexAttribPointer(a.aPitchRoll, this._pitchRollBuffer[ti].itemSize, gl.FLOAT, false, 0, 0);
 
             gl.bindBuffer(gl.ARRAY_BUFFER, this._rgbaBuffer[ti]);
             gl.vertexAttribPointer(a.aColor, this._rgbaBuffer[ti].itemSize, gl.FLOAT, false, 0, 0);
@@ -561,7 +525,7 @@ class GeoObjectHandler {
         gl.disable(gl.CULL_FACE);
     }
 
-    _recalculateIndices() {
+    _recalculateIndices(startIndex) {
         const allIndices = this._indicesArr,
             goArr = this._geoObjects,
             maxIndicesByTags = new Array(this._instancedTags.size).fill(0);
@@ -590,10 +554,62 @@ class GeoObjectHandler {
         }
     }
 
-    //todo refactor for support instancing
-    setVertexArr(index, vertexArr) {
-        this._vertexArr = [-0.5, 0.0, 0.5, -0.5, 0.0, -0.5, 0.5, 0.0, -0.5, 0.5, 0.0, 0.5];
-        this._changedBuffers[VERTEX_BUFFER] = true;
+    _addIndices(g) {
+        let i = g._handlerIndex;
+        const allIndices = this._indicesArr,
+            gArr = this._geoObjects,
+            iLen = g._indices.length,
+            tagData = this._instancedTags.get(g.tag),
+            maxIndex = tagData.maxIndex,
+            ti = tagData.index;
+
+        allIndices[ti] = concatArrays(allIndices[ti], g._indices);
+
+        while (gArr[i]) {
+            const g = gArr[i];
+
+            if (g._tagIndex > 0) {
+                setParametersToArray(allIndices[ti], g._tagIndex, iLen, iLen, ...g._indices.reduce((acc, cur) => {
+                    acc.push(cur + ((maxIndex + 1) * g._tagIndex));
+                    return acc;
+                }, []));
+            }
+            i++;
+
+        }
+
+    }
+
+    _removeIndices(geoObject) {
+        const allIndices = this._indicesArr,
+            gArr = this._geoObjects,
+            iLen = geoObject._indices.length,
+            tagData = this._instancedTags.get(geoObject.tag),
+            maxIndex = tagData.maxIndex,
+            ti = tagData.index,
+            count = tagData.iCounts;
+
+        let i = geoObject._handlerIndex;
+
+        this._indicesArr[ti] = spliceArray(this._indicesArr[ti], geoObject._tagIndex * geoObject._indicesCount, geoObject._indicesCount);
+
+        while (gArr[i]) {
+            if (geoObject.tag === gArr[i].tag) {
+                if (count !== 0) {
+                    const startI = (gArr[i]._tagIndex - 1) * iLen;
+                    let stopI = startI + geoObject._indicesCount;
+                    while (stopI > startI) {
+                        this._indicesArr[ti][stopI - 1] = allIndices[ti][stopI - 1] - maxIndex - 1;
+                        stopI--;
+                    }
+                } else {
+                    allIndices[ti] = geoObject._indices;
+                }
+            }
+            i++;
+
+        }
+
     }
 
     setDirectionArr(index, direction) {
@@ -606,15 +622,7 @@ class GeoObjectHandler {
             length = itemSize;
         }
 
-        setParametersToArray(
-            this._directionArr[ti],
-            ob._tagIndex,
-            length,
-            itemSize,
-            direction.x,
-            direction.y,
-            direction.z
-        );
+        setParametersToArray(this._directionArr[ti], ob._tagIndex, length, itemSize, direction.x, direction.y, direction.z);
         this._changedBuffers[DIRECTION_BUFFER] = true;
     }
 
@@ -639,26 +647,10 @@ class GeoObjectHandler {
             length = itemSize;
         }
 
-        setParametersToArray(
-            this._positionHighArr[ti],
-            ob._tagIndex,
-            length,
-            itemSize,
-            positionHigh.x,
-            positionHigh.y,
-            positionHigh.z
-        );
+        setParametersToArray(this._positionHighArr[ti], ob._tagIndex, length, itemSize, positionHigh.x, positionHigh.y, positionHigh.z);
 
         // Low
-        setParametersToArray(
-            this._positionLowArr[ti],
-            ob._tagIndex,
-            length,
-            itemSize,
-            positionLow.x,
-            positionLow.y,
-            positionLow.z
-        );
+        setParametersToArray(this._positionLowArr[ti], ob._tagIndex, length, itemSize, positionLow.x, positionLow.y, positionLow.z);
 
         this._changedBuffers[POSITION_BUFFER] = true;
     }
@@ -673,16 +665,7 @@ class GeoObjectHandler {
             length = itemSize;
         }
 
-        setParametersToArray(
-            this._rgbaArr[ti],
-            ob._tagIndex,
-            length,
-            itemSize,
-            rgba.x,
-            rgba.y,
-            rgba.z,
-            rgba.w
-        );
+        setParametersToArray(this._rgbaArr[ti], ob._tagIndex, length, itemSize, rgba.x, rgba.y, rgba.z, rgba.w);
 
         this._changedBuffers[RGBA_BUFFER] = true;
     }
@@ -771,16 +754,16 @@ class GeoObjectHandler {
         this._indicesArr = null;
         this._pickingColorArr = null;
 
-        this._pitchRollArr = new Float32Array();
-        this._sizeArr = new Float32Array();
-        this._vertexArr = new Float32Array();
-        this._positionHighArr = new Float32Array();
-        this._positionLowArr = new Float32Array();
-        this._rgbaArr = new Float32Array();
-        this._directionArr = new Float32Array();
-        this._normalsArr = new Float32Array();
-        this._indicesArr = new Uint16Array();
-        this._pickingColorArr = new Float32Array();
+        this._pitchRollArr = [new Float32Array()];
+        this._sizeArr = [new Float32Array()];
+        this._vertexArr = [new Float32Array()];
+        this._positionHighArr = [new Float32Array()];
+        this._positionLowArr = [new Float32Array()];
+        this._rgbaArr = [new Float32Array()];
+        this._directionArr = [new Float32Array()];
+        this._normalsArr = [new Float32Array()];
+        this._indicesArr = [new Uint16Array()];
+        this._pickingColorArr = [new Float32Array()];
 
         this._removeGeoObjects();
         this._deleteBuffers();
@@ -866,19 +849,20 @@ class GeoObjectHandler {
         const gi = geoObject._handlerIndex,
             tag = geoObject.tag,
             ti = this.getTagIndexByObjectIndex(gi),
-            prevState = this._instancedTags.get(tag);
+            prevState = this._instancedTags.get(tag),
+            iCount = prevState.iCounts - 1;
 
         this._instancedTags.set(tag, {
-            iCounts: prevState.iCounts - 1,
-            index: prevState.index
+            ...prevState,
+            iCounts: iCount
         });
 
         this._geoObjects.splice(gi, 1);
 
-        let i = gi * 4;
+        let i = geoObject._tagIndex * 4;
         this._rgbaArr[ti] = spliceArray(this._rgbaArr[ti], i, 4);
 
-        i = gi * 3;
+        i = geoObject._tagIndex * 3;
         if (prevState.iCounts <= 1) {
             this._vertexArr[ti] = spliceArray(this._vertexArr[ti], 0, geoObject._verticesCount * 3);
             this._normalsArr[ti] = spliceArray(
@@ -892,14 +876,15 @@ class GeoObjectHandler {
         this._directionArr[ti] = spliceArray(this._directionArr[ti], i, 3);
         this._pickingColorArr[ti] = spliceArray(this._pickingColorArr[ti], i, 3);
 
-        i = gi * 2;
+        i = geoObject._tagIndex * 2;
         this._pitchRollArr[ti] = spliceArray(this._pitchRollArr[ti], i, 2);
-        this._indicesArr[ti] = spliceArray(this._indicesArr[ti], i, geoObject._indicesCount);
-        i = gi * 1;
+        i = geoObject._tagIndex;
         this._sizeArr[ti] = spliceArray(this._sizeArr[ti], i, 1);
 
+        this._removeIndices(geoObject);
+
         this._reindexGeoObjects(gi, tag);
-        this._recalculateIndices();
+
         this.refresh();
 
         geoObject._handlerIndex = -1;

package/src/og/entity/LabelHandler.js

@@ -469,7 +469,8 @@ class LabelHandler extends BillboardHandler {
         this.refresh();
 
         label._handlerIndex = -1;
-        label._handler = null;
+        label._handler = null;
+        label._isReady = false;
     }
 
     setText(index, text, fontIndex, align) {

package/src/og/layer/XYZ.js

@@ -237,9 +237,6 @@ class XYZ extends Layer {
         if (material.isReady) {
             return material.texOffset;
         } else {
-            // if (material.loadingAttempts > 20) {
-            //     debugger;
-            // }
 
             let segment = material.segment,
                 pn = segment.node,
@@ -257,25 +254,27 @@ class XYZ extends Layer {
             }
 
             let maxNativeZoom = material.layer.maxNativeZoom;
-
-            if (pn.segment.tileZoom === maxNativeZoom) {
-                material.textureNotExists();
-            } else if (material.segment.tileZoom <= maxNativeZoom) {
-                !material.isLoading && !material.isReady && this.loadMaterial(material);
-            } else {
-                let pn = segment.node;
-                while (pn.segment.tileZoom > material.layer.maxNativeZoom) {
-                    pn = pn.parentNode;
-                }
-                let pnm = pn.segment.materials[material.layer._id];
-                if (pnm) {
-                    !pnm.isLoading && !pnm.isReady && this.loadMaterial(pnm, true);
+
+            if (segment.loadTile) {
+                if (pn.segment.tileZoom === maxNativeZoom) {
+                    material.textureNotExists();
+                } else if (material.segment.tileZoom <= maxNativeZoom) {
+                    !material.isLoading && !material.isReady && this.loadMaterial(material);
                 } else {
-                    pnm = pn.segment.materials[material.layer._id] = material.layer.createMaterial(
-                        pn.segment
-                    );
-                    this.loadMaterial(pnm, true);
-                }
+                    let pn = segment.node;
+                    while (pn.segment.tileZoom > material.layer.maxNativeZoom) {
+                        pn = pn.parentNode;
+                    }
+                    let pnm = pn.segment.materials[material.layer._id];
+                    if (pnm) {
+                        !pnm.isLoading && !pnm.isReady && this.loadMaterial(pnm, true);
+                    } else {
+                        pnm = pn.segment.materials[material.layer._id] = material.layer.createMaterial(
+                            pn.segment
+                        );
+                        this.loadMaterial(pnm, true);
+                    }
+                }
             }
 
             if (notEmpty) {

package/src/og/math/Vec3.js

@@ -699,8 +699,24 @@ export class Vec3 {
      * @param {Vec3} point3 - Distant point.
      * @returns {number} -
      */
-    distance(point3) {
-        return Vec3.sub(this, point3).length();
+    distance(point3) {
+        let dx = this.x - point3.x,
+            dy = this.y - point3.y,
+            dz = this.z - point3.z;
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+
+    /**
+     * Gets square distance to point.
+     * @public
+     * @param {Vec3} point3 - Distant point.
+     * @returns {number} -
+     */
+    distance2(point3) {
+        let dx = this.x - point3.x,
+            dy = this.y - point3.y,
+            dz = this.z - point3.z;
+        return dx * dx + dy * dy + dz * dz;
     }
 
     /**