@openglobus/og 0.11.6 → 0.12.1

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/Label.js

@@ -7,6 +7,7 @@
 import * as utils from "../utils/shared.js";
 import { BaseBillboard } from "./BaseBillboard.js";
 import { Vec4 } from "../math/Vec4.js";
+import { LOCK_FREE, LOCK_UPDATE } from "./LabelWorker.js";
 
 const ALIGN = {
     RIGHT: 0,
@@ -121,8 +122,8 @@ class Label extends BaseBillboard {
      */
     setText(text) {
         this._text = text.toString();
-        if (this._isReady) {
-            this._handler.setText(this._handlerIndex, text, this._fontIndex, this._align);
+        if (this._isReady && this._handler) {
+            this._handler.setText(this._handlerIndex, text, this._fontIndex, this._align);
         }
     }
 
@@ -142,10 +143,10 @@ class Label extends BaseBillboard {
      */
     setAlign(align) {
         this._align = STR2ALIGN[align.trim().toLowerCase()];
-        if (this._isReady) {
-            this._handler.setText(this._handlerIndex, this._text, this._fontIndex, this._align);
-        } else if (this._lockId !== -1) {
-            this._lockId = -2;
+        if (this._isReady && this._handler) {
+            this._handler.setText(this._handlerIndex, this._text, this._fontIndex, this._align);
+        } else if (this._lockId !== LOCK_FREE) {
+            this._lockId = LOCK_UPDATE;
         }
     }
 
@@ -183,11 +184,13 @@ class Label extends BaseBillboard {
      * @param {number} size - Label size in pixels.
      */
     setSize(size) {
-        this._size = size;
-        if (this._isReady) {
-            this._handler.setSizeArr(this._handlerIndex, size);
-        } else if (this._lockId !== -1) {
-            this._lockId = -2;
+        if (size !== this._size) {
+            this._size = size;
+            if (this._isReady && this._handler) {
+                this._handler.setSizeArr(this._handlerIndex, size);
+            } else if (this._lockId !== LOCK_FREE) {
+                this._lockId = LOCK_UPDATE;
+            }
         }
     }
 
@@ -207,10 +210,10 @@ class Label extends BaseBillboard {
      */
     setOutline(outline) {
         this._outline = outline;
-        if (this._isReady) {
-            this._handler.setOutlineArr(this._handlerIndex, outline);
-        } else if (this._lockId !== -1) {
-            this._lockId = -2;
+        if (this._isReady && this._handler) {
+            this._handler.setOutlineArr(this._handlerIndex, outline);
+        } else if (this._lockId !== LOCK_FREE) {
+            this._lockId = LOCK_UPDATE;
         }
     }
 
@@ -229,10 +232,8 @@ class Label extends BaseBillboard {
      * @param {number} a - Label opacity.
      */
     setOpacity(a) {
-        this._color.w = a;
-        this.setColor4v(this._color);
-        this._outlineColor.w = a;
-        this.setOutlineColor4v(this._outlineColor);
+        super.setOpacity(a);
+        this.setOutlineOpacity(a);
     }
 
     /**
@@ -244,14 +245,16 @@ class Label extends BaseBillboard {
      * @param {number} a - Alpha.
      */
     setOutlineColor(r, g, b, a) {
-        this._outlineColor.x = r;
-        this._outlineColor.y = g;
-        this._outlineColor.z = b;
-        this._outlineColor.w = a;
-        if (this._isReady) {
-            this._handler.setOutlineColorArr(this._handlerIndex, this._outlineColor);
-        } else if (this._lockId !== -1) {
-            this._lockId = -2;
+        if (a !== this._outlineColor.w || r !== this._outlineColor.x || g !== this._outlineColor.y || b !== this._outlineColor.z) {
+            this._outlineColor.x = r;
+            this._outlineColor.y = g;
+            this._outlineColor.z = b;
+            this._outlineColor.w = a;
+            if (this._isReady && this._handler) {
+                this._handler.setOutlineColorArr(this._handlerIndex, this._outlineColor);
+            } else if (this._lockId !== LOCK_FREE) {
+                this._lockId = LOCK_UPDATE;
+            }
         }
     }
 
@@ -261,15 +264,7 @@ class Label extends BaseBillboard {
      * @param {Vec4} rgba - Color vector.
      */
     setOutlineColor4v(rgba) {
-        this._outlineColor.x = rgba.x;
-        this._outlineColor.y = rgba.y;
-        this._outlineColor.z = rgba.z;
-        this._outlineColor.w = rgba.w;
-        if (this._isReady) {
-            this._handler.setOutlineColorArr(this._handlerIndex, rgba);
-        } else if (this._lockId !== -1) {
-            this._lockId = -2;
-        }
+        this.setOutlineColor(rgba.x, rgba.y, rgba.z, rgba.w);
     }
 
     /**
@@ -296,11 +291,13 @@ class Label extends BaseBillboard {
      * @param {number} opacity - Outline opacity.
      */
     setOutlineOpacity(opacity) {
-        this._outlineColor.w = opacity;
-        if (this._isReady) {
-            this._handler.setOutlineColorArr(this._handlerIndex, this._outlineColor);
-        } else if (this._lockId !== -1) {
-            this._lockId = -2;
+        if (opacity !== this._outlineColor.w) {
+            this._outlineColor.w = opacity;
+            if (this._isReady && this._handler) {
+                this._handler.setOutlineColorArr(this._handlerIndex, this._outlineColor);
+            } else if (this._lockId !== LOCK_FREE) {
+                this._lockId = LOCK_UPDATE;
+            }
         }
     }
 
@@ -326,11 +323,11 @@ class Label extends BaseBillboard {
 
     _applyFontIndex(fontIndex) {
         this._fontIndex = fontIndex;
-        if (this._isReady) {
+        if (this._isReady && this._handler) {
             this._handler.setFontIndexArr(this._handlerIndex, this._fontIndex);
             this._handler.setText(this._handlerIndex, this._text, this._fontIndex, this._align);
-        } else if (this._lockId !== -1) {
-            this._lockId = -2;
+        } else if (this._lockId !== LOCK_FREE) {
+            this._lockId = LOCK_UPDATE;
         }
     }
 
@@ -340,11 +337,11 @@ class Label extends BaseBillboard {
      * @param {utils.FontAtlas} fontAtlas - Font atlas.
      */
     assignFontAtlas(fontAtlas) {
-        if (!this._fontAtlas) {
-            this._fontAtlas = fontAtlas;
+        if (!this._fontAtlas) {
+            this._fontAtlas = fontAtlas;
         }
         this.update();
-    }
+    }
 }
 
-export { Label, ALIGN };
+export { Label, ALIGN };

package/src/og/entity/LabelHandler.js

@@ -8,6 +8,7 @@ import * as shaders from "../shaders/label.js";
 import { ALIGN } from "./Label.js";
 import { BillboardHandler } from "./BillboardHandler.js";
 import { concatTypedArrays, spliceTypedArray } from "../utils/shared.js";
+import { LOCK_FREE } from "./LabelWorker.js";
 
 const PICKINGCOLOR_BUFFER = 0;
 const POSITION_BUFFER = 1;
@@ -81,28 +82,28 @@ class LabelHandler extends BillboardHandler {
             this.assignFontAtlas(label);
             this.refresh();
         }
-    }
-
-    _addLabelToArrays(label) {
-        this._renderer.labelWorker.make(this, label);
-    }
-
+    }
+
+    _addLabelToArrays(label) {
+        this._renderer.labelWorker.make(this, label);
+    }
+
     assignFontAtlas(label) {
         if (this._entityCollection && this._renderer) {
             label.assignFontAtlas(this._renderer.fontAtlas);
             this._addLabelToArrays(label);
-        } else {
-            this._billboards.push(label);
+        } else {
+            this._billboards.push(label);
         }
-    }
-
-    workerCallback(data, label) {
-        if (label._lockId !== -1) {
-            label._isReady = true;
-            label._lockId = -1;
-            label._handlerIndex = this._billboards.length;
-            this._billboards.push(label);
-
+    }
+
+    workerCallback(data, label) {
+        if (label._lockId !== LOCK_FREE && this.isEqual(label._handler)) {
+            label._isReady = true;
+            label._lockId = LOCK_FREE;
+            label._handlerIndex = this._billboards.length;
+            this._billboards.push(label);
+
             this._vertexArr = concatTypedArrays(this._vertexArr, data.vertexArr);
             this._texCoordArr = concatTypedArrays(this._texCoordArr, data.texCoordArr);
             this._gliphParamArr = concatTypedArrays(this._gliphParamArr, data.gliphParamArr);
@@ -117,11 +118,11 @@ class LabelHandler extends BillboardHandler {
             this._outlineArr = concatTypedArrays(this._outlineArr, data.outlineArr);
             this._noOutlineArr = concatTypedArrays(this._noOutlineArr, data.noOutlineArr);
             this._outlineColorArr = concatTypedArrays(this._outlineColorArr, data.outlineColorArr);
-            this._pickingColorArr = concatTypedArrays(this._pickingColorArr, data.pickingColorArr);
-
-            label.update();
-
-            this.refresh();
+            this._pickingColorArr = concatTypedArrays(this._pickingColorArr, data.pickingColorArr);
+
+            label.update();
+
+            this.refresh();
         }
     }
 
@@ -1038,4 +1039,4 @@ class LabelHandler extends BillboardHandler {
     }
 }
 
-export { LabelHandler };
+export { LabelHandler };