@openglobus/og 0.24.2 → 0.25.0

package/lib/js/entity/GeoObjectHandler.js

@@ -1,515 +0,0 @@
-import * as shaders from "../shaders/geoObject";
-import { concatArrays, loadImage, spliceArray } from "../utils/shared";
-import { Vec3 } from "../math/Vec3";
-import { Object3d } from "../Object3d";
-import { InstanceData } from "./InstanceData";
-//@todo: enums, i know...nah...
-export const VERTEX_BUFFER = 0;
-export const RTC_POSITION_BUFFER = 1;
-export const RGBA_BUFFER = 2;
-export const NORMALS_BUFFER = 3;
-export const INDEX_BUFFER = 4;
-export const QROT_BUFFER = 5;
-export const SIZE_BUFFER = 6;
-export const PICKINGCOLOR_BUFFER = 7;
-export const VISIBLE_BUFFER = 8;
-export const TEXCOORD_BUFFER = 9;
-export const TRANSLATE_BUFFER = 10;
-export const LOCALPOSITION_BUFFER = 11;
-function setParametersToArray(arr, index = 0, length = 0, itemSize = 1, ...params) {
-    const currIndex = index * length;
-    for (let i = currIndex, len = currIndex + length; i < len; i++) {
-        arr[i] = params[i % itemSize];
-    }
-    return arr;
-}
-export class GeoObjectHandler {
-    constructor(entityCollection) {
-        this.__id = GeoObjectHandler.__counter__++;
-        this.pickingEnabled = true;
-        this._entityCollection = entityCollection;
-        this._renderNode = null;
-        this._renderer = null;
-        this._geoObjects = [];
-        this._instanceDataMap = new Map();
-        this._instanceDataMapValues = [];
-        this._dataTagUpdateQueue = [];
-        this._relativeCenter = new Vec3();
-        this._rtcEyePositionHigh = new Float32Array([0, 0, 0]);
-        this._rtcEyePositionLow = new Float32Array([0, 0, 0]);
-    }
-    initProgram() {
-        if (this._renderer) {
-            if (!this._renderer.handler.programs.geo_object) {
-                this._renderer.handler.addProgram(shaders.geo_object());
-            }
-            if (!this._renderer.handler.programs.geo_object_picking) {
-                this._renderer.handler.addProgram(shaders.geo_object_picking());
-            }
-            if (!this._renderer.handler.programs.geo_object_depth) {
-                this._renderer.handler.addProgram(shaders.geo_object_depth());
-            }
-        }
-    }
-    setRenderNode(renderNode) {
-        this._renderNode = renderNode;
-        this._renderer = renderNode.renderer;
-        this.initProgram();
-        //
-        // in case of lazy initialization loading data here
-        for (let i = 0; i < this._instanceDataMapValues.length; i++) {
-            this._loadColorTexture(this._instanceDataMapValues[i]);
-            this._loadNormalTexture(this._instanceDataMapValues[i]);
-            this._loadMetallicRoughnessTexture(this._instanceDataMapValues[i]);
-        }
-        for (let i = 0; i < this._geoObjects.length; i++) {
-            this._geoObjects[i].updateRotation();
-        }
-        this.update();
-    }
-    setColorTextureTag(src, tag) {
-        const tagData = this._instanceDataMap.get(tag);
-        if (tagData) {
-            tagData._colorTextureSrc = src;
-            this._instanceDataMap.set(tag, tagData);
-            this._loadColorTexture(tagData);
-        }
-    }
-    setNormalTextureTag(src, tag) {
-        const tagData = this._instanceDataMap.get(tag);
-        if (tagData) {
-            tagData._normalTextureSrc = src;
-            this._instanceDataMap.set(tag, tagData);
-            this._loadNormalTexture(tagData);
-        }
-    }
-    setMetallicRoughnessTextureTag(src, tag) {
-        const tagData = this._instanceDataMap.get(tag);
-        if (tagData) {
-            tagData._metallicRoughnessTextureSrc = src;
-            this._instanceDataMap.set(tag, tagData);
-            this._loadMetallicRoughnessTexture(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;
-            }
-            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._colorTextureSrc = object.colorTexture;
-            tagData._normalTextureSrc = object.normalTexture;
-            tagData._metallicRoughnessTexture = object.metallicRoughnessTexture;
-            this._loadColorTexture(tagData);
-            this._loadNormalTexture(tagData);
-            this._loadMetallicRoughnessTexture(tagData);
-            this._updateTag(tagData);
-            this._instanceDataMapValues = Array.from(this._instanceDataMap.values());
-        }
-    }
-    _addGeoObjectToArray(geoObject) {
-        const tag = geoObject.tag;
-        let tagData = this._instanceDataMap.get(tag);
-        if (!tagData) {
-            tagData = new InstanceData(this);
-            this._instanceDataMap.set(tag, tagData);
-            this._instanceDataMapValues = Array.from(this._instanceDataMap.values());
-            //
-            // Setting instanced data
-            tagData._vertexArr = geoObject.vertices;
-            tagData._normalsArr = geoObject.normals;
-            tagData._indicesArr = geoObject.indices;
-            tagData._texCoordArr = geoObject.texCoords;
-            tagData._colorTextureSrc = geoObject.object3d.colorTexture;
-            tagData._normalTextureSrc = geoObject.object3d.normalTexture;
-            tagData._metallicRoughnessTextureSrc = geoObject.object3d.metallicRoughnessTexture;
-            tagData.setMaterialParams(geoObject.object3d.ambient, geoObject.object3d.diffuse, geoObject.object3d.specular, geoObject.object3d.shininess);
-            this._loadColorTexture(tagData);
-            this._loadNormalTexture(tagData);
-            this._loadMetallicRoughnessTexture(tagData);
-        }
-        geoObject._tagDataIndex = tagData.numInstances++;
-        geoObject._tagData = tagData;
-        tagData.geoObjects.push(geoObject);
-        let itemSize = 3;
-        tagData._visibleArr = concatArrays(tagData._visibleArr, setParametersToArray([], 0, 1, 1, geoObject.getVisibility() ? 1 : 0));
-        //
-        // Global coordinates
-        this.getRTCPosition(geoObject.getPosition(), geoObject._rtcPositionHigh, geoObject._rtcPositionLow);
-        let x = geoObject._rtcPositionHigh.x, y = geoObject._rtcPositionHigh.y, z = geoObject._rtcPositionHigh.z, w;
-        tagData._rtcPositionHighArr = concatArrays(tagData._rtcPositionHighArr, setParametersToArray([], 0, itemSize, itemSize, x, y, z));
-        x = geoObject._rtcPositionLow.x;
-        y = geoObject._rtcPositionLow.y;
-        z = geoObject._rtcPositionLow.z;
-        tagData._rtcPositionLowArr = concatArrays(tagData._rtcPositionLowArr, setParametersToArray([], 0, itemSize, itemSize, x, y, z));
-        x = geoObject._entity._pickingColor.x / 255;
-        y = geoObject._entity._pickingColor.y / 255;
-        z = geoObject._entity._pickingColor.z / 255;
-        tagData._pickingColorArr = concatArrays(tagData._pickingColorArr, setParametersToArray([], 0, itemSize, itemSize, x, y, z));
-        itemSize = 4;
-        x = geoObject._qRot.x;
-        y = geoObject._qRot.y;
-        z = geoObject._qRot.z;
-        w = geoObject._qRot.w;
-        tagData._qRotArr = concatArrays(tagData._qRotArr, setParametersToArray([], 0, itemSize, itemSize, x, y, z, w));
-        x = geoObject._color.x;
-        y = geoObject._color.y;
-        z = geoObject._color.z;
-        w = geoObject._color.w;
-        tagData._rgbaArr = concatArrays(tagData._rgbaArr, setParametersToArray([], 0, itemSize, itemSize, x, y, z, w));
-        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));
-        let translate = geoObject.getTranslate();
-        x = translate.x;
-        y = translate.y;
-        z = translate.z;
-        tagData._translateArr = concatArrays(tagData._translateArr, setParametersToArray([], 0, itemSize, itemSize, x, y, z));
-        let localPosition = geoObject.getLocalPosition();
-        x = localPosition.x;
-        y = localPosition.y;
-        z = localPosition.z;
-        tagData._localPositionArr = concatArrays(tagData._localPositionArr, setParametersToArray([], 0, itemSize, itemSize, x, y, z));
-    }
-    //
-    // Could be in VAO
-    //
-    _bindCommon() {
-        let r = this._renderer, sh = r.handler.programs.geo_object, p = sh._program, u = p.uniforms, gl = r.handler.gl, ec = this._entityCollection;
-        gl.uniform3fv(u.uScaleByDistance, ec.scaleByDistance);
-        gl.uniform1f(u.useLighting, ec._useLighting);
-        gl.uniform3fv(u.eyePositionHigh, r.activeCamera.eyeHigh);
-        gl.uniform3fv(u.eyePositionLow, r.activeCamera.eyeLow);
-        gl.uniform3fv(u.rtcEyePositionHigh, this._rtcEyePositionHigh);
-        gl.uniform3fv(u.rtcEyePositionLow, this._rtcEyePositionLow);
-        gl.uniformMatrix4fv(u.projectionMatrix, false, r.activeCamera.getProjectionMatrix());
-        gl.uniformMatrix4fv(u.viewMatrix, false, r.activeCamera.getViewMatrix());
-        //
-        // Global sun position
-        gl.uniform3fv(u.sunPosition, this._renderNode._lightPosition);
-    }
-    _displayOpaquePASS() {
-        let r = this._renderer, sh = r.handler.programs.geo_object, p = sh._program;
-        sh.activate();
-        this._bindCommon();
-        for (let i = 0; i < this._instanceDataMapValues.length; i++) {
-            let instanceData = this._instanceDataMapValues[i];
-            instanceData.drawOpaque(p);
-        }
-    }
-    _displayTransparentPASS() {
-        let r = this._renderer, sh = r.handler.programs.geo_object, p = sh._program;
-        sh.activate();
-        //gl.disable(gl.CULL_FACE);
-        this._bindCommon();
-        for (let i = 0; i < this._instanceDataMapValues.length; i++) {
-            this._instanceDataMapValues[i].drawTransparent(p);
-        }
-    }
-    _depthPASS() {
-        let r = this._renderer, sh = r.handler.programs.geo_object_depth, p = sh._program, u = p.uniforms, a = p.attributes, gl = r.handler.gl, ec = this._entityCollection;
-        let cam = r.activeCamera;
-        sh.activate();
-        gl.uniform3fv(u.uScaleByDistance, ec.scaleByDistance);
-        gl.uniform3fv(u.rtcEyePositionHigh, this._rtcEyePositionHigh);
-        gl.uniform3fv(u.rtcEyePositionLow, this._rtcEyePositionLow);
-        gl.uniformMatrix4fv(u.projectionMatrix, false, r.activeCamera.getProjectionMatrix());
-        gl.uniformMatrix4fv(u.viewMatrix, false, r.activeCamera.getViewMatrix());
-        gl.uniform1f(u.frustumPickingColor, cam.frustumColorIndex);
-        for (let i = 0; i < this._instanceDataMapValues.length; i++) {
-            let tagData = this._instanceDataMapValues[i];
-            //
-            // Instance individual data
-            //
-            gl.bindBuffer(gl.ARRAY_BUFFER, tagData._qRotBuffer);
-            gl.vertexAttribPointer(a.qRot, tagData._qRotBuffer.itemSize, gl.FLOAT, false, 0, 0);
-            gl.bindBuffer(gl.ARRAY_BUFFER, tagData._sizeBuffer);
-            gl.vertexAttribPointer(a.aScale, tagData._sizeBuffer.itemSize, gl.FLOAT, false, 0, 0);
-            gl.bindBuffer(gl.ARRAY_BUFFER, tagData._translateBuffer);
-            gl.vertexAttribPointer(a.aTranslate, tagData._translateBuffer.itemSize, gl.FLOAT, false, 0, 0);
-            gl.bindBuffer(gl.ARRAY_BUFFER, tagData._localPositionBuffer);
-            gl.vertexAttribPointer(a.aLocalPosition, tagData._localPositionBuffer.itemSize, gl.FLOAT, false, 0, 0);
-            gl.bindBuffer(gl.ARRAY_BUFFER, tagData._rtcPositionHighBuffer);
-            gl.vertexAttribPointer(a.aRTCPositionHigh, tagData._rtcPositionHighBuffer.itemSize, gl.FLOAT, false, 0, 0);
-            gl.bindBuffer(gl.ARRAY_BUFFER, tagData._rtcPositionLowBuffer);
-            gl.vertexAttribPointer(a.aRTCPositionLow, tagData._rtcPositionLowBuffer.itemSize, gl.FLOAT, false, 0, 0);
-            gl.bindBuffer(gl.ARRAY_BUFFER, tagData._visibleBuffer);
-            gl.vertexAttribPointer(a.aDispose, tagData._visibleBuffer.itemSize, gl.FLOAT, false, 0, 0);
-            //
-            // Instance common data(could be in VAO)
-            //
-            gl.bindBuffer(gl.ARRAY_BUFFER, tagData._vertexBuffer);
-            gl.vertexAttribPointer(a.aVertexPosition, tagData._vertexBuffer.itemSize, gl.FLOAT, false, 0, 0);
-            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, tagData._indicesBuffer);
-            p.drawElementsInstanced(gl.TRIANGLES, tagData._indicesBuffer.numItems, gl.UNSIGNED_INT, 0, tagData.numInstances);
-        }
-    }
-    drawDepth() {
-        if (this._geoObjects.length) {
-            this._depthPASS();
-        }
-    }
-    drawPicking() {
-        if (this._geoObjects.length && this.pickingEnabled) {
-            this._pickingPASS();
-        }
-    }
-    _pickingPASS() {
-        let r = this._renderer, sh = r.handler.programs.geo_object_picking, p = sh._program, u = p.uniforms, a = p.attributes, gl = r.handler.gl, ec = this._entityCollection;
-        sh.activate();
-        gl.uniform3fv(u.uScaleByDistance, ec.scaleByDistance);
-        gl.uniform3fv(u.pickingScale, ec.pickingScale);
-        gl.uniform3fv(u.rtcEyePositionHigh, this._rtcEyePositionHigh);
-        gl.uniform3fv(u.rtcEyePositionLow, this._rtcEyePositionLow);
-        gl.uniformMatrix4fv(u.projectionMatrix, false, r.activeCamera.getProjectionMatrix());
-        gl.uniformMatrix4fv(u.viewMatrix, false, r.activeCamera.getViewMatrix());
-        for (let i = 0; i < this._instanceDataMapValues.length; i++) {
-            let tagData = this._instanceDataMapValues[i];
-            //
-            // Instance individual data
-            //
-            gl.bindBuffer(gl.ARRAY_BUFFER, tagData._qRotBuffer);
-            gl.vertexAttribPointer(a.qRot, tagData._qRotBuffer.itemSize, gl.FLOAT, false, 0, 0);
-            gl.bindBuffer(gl.ARRAY_BUFFER, tagData._sizeBuffer);
-            gl.vertexAttribPointer(a.aScale, tagData._sizeBuffer.itemSize, gl.FLOAT, false, 0, 0);
-            gl.bindBuffer(gl.ARRAY_BUFFER, tagData._translateBuffer);
-            gl.vertexAttribPointer(a.aTranslate, tagData._translateBuffer.itemSize, gl.FLOAT, false, 0, 0);
-            gl.bindBuffer(gl.ARRAY_BUFFER, tagData._localPositionBuffer);
-            gl.vertexAttribPointer(a.aLocalPosition, tagData._localPositionBuffer.itemSize, gl.FLOAT, false, 0, 0);
-            gl.bindBuffer(gl.ARRAY_BUFFER, tagData._pickingColorBuffer);
-            gl.vertexAttribPointer(a.aPickingColor, tagData._pickingColorBuffer.itemSize, gl.FLOAT, false, 0, 0);
-            gl.bindBuffer(gl.ARRAY_BUFFER, tagData._rtcPositionHighBuffer);
-            gl.vertexAttribPointer(a.aRTCPositionHigh, tagData._rtcPositionHighBuffer.itemSize, gl.FLOAT, false, 0, 0);
-            gl.bindBuffer(gl.ARRAY_BUFFER, tagData._rtcPositionLowBuffer);
-            gl.vertexAttribPointer(a.aRTCPositionLow, tagData._rtcPositionLowBuffer.itemSize, gl.FLOAT, false, 0, 0);
-            gl.bindBuffer(gl.ARRAY_BUFFER, tagData._visibleBuffer);
-            gl.vertexAttribPointer(a.aDispose, tagData._visibleBuffer.itemSize, gl.FLOAT, false, 0, 0);
-            //
-            // Instance common data(could be in VAO)
-            //
-            gl.bindBuffer(gl.ARRAY_BUFFER, tagData._vertexBuffer);
-            gl.vertexAttribPointer(a.aVertexPosition, tagData._vertexBuffer.itemSize, gl.FLOAT, false, 0, 0);
-            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, tagData._indicesBuffer);
-            p.drawElementsInstanced(gl.TRIANGLES, tagData._indicesBuffer.numItems, gl.UNSIGNED_INT, 0, tagData.numInstances);
-        }
-    }
-    async _loadColorTexture(tagData) {
-        if (this._renderer && tagData._colorTextureSrc) {
-            const image = await loadImage(tagData._colorTextureSrc);
-            tagData.createColorTexture(image);
-        }
-    }
-    async _loadNormalTexture(tagData) {
-        if (this._renderer && tagData._normalTextureSrc) {
-            const image = await loadImage(tagData._normalTextureSrc);
-            tagData.createNormalTexture(image);
-        }
-    }
-    async _loadMetallicRoughnessTexture(tagData) {
-        if (this._renderer && tagData._metallicRoughnessTextureSrc) {
-            const image = await loadImage(tagData._metallicRoughnessTextureSrc);
-            tagData.createMetallicRoughnessTexture(image);
-        }
-    }
-    setQRotArr(tagData, tagDataIndex, qRot) {
-        setParametersToArray(tagData._qRotArr, tagDataIndex, 4, 4, qRot.x, qRot.y, qRot.z, qRot.w);
-        tagData._changedBuffers[QROT_BUFFER] = true;
-        this._updateTag(tagData);
-    }
-    setVisibility(tagData, tagDataIndex, visibility) {
-        setParametersToArray(tagData._visibleArr, tagDataIndex, 1, 1, visibility ? 1 : 0);
-        tagData._changedBuffers[VISIBLE_BUFFER] = true;
-        this._updateTag(tagData);
-    }
-    setRTCPositionArr(tagData, tagDataIndex, rtcPositionHigh, rtcPositionLow) {
-        setParametersToArray(tagData._rtcPositionHighArr, tagDataIndex, 3, 3, rtcPositionHigh.x, rtcPositionHigh.y, rtcPositionHigh.z);
-        setParametersToArray(tagData._rtcPositionLowArr, tagDataIndex, 3, 3, rtcPositionLow.x, rtcPositionLow.y, rtcPositionLow.z);
-        tagData._changedBuffers[RTC_POSITION_BUFFER] = true;
-        this._updateTag(tagData);
-    }
-    setRgbaArr(tagData, tagDataIndex, rgba) {
-        setParametersToArray(tagData._rgbaArr, tagDataIndex, 4, 4, rgba.x, rgba.y, rgba.z, rgba.w);
-        tagData._changedBuffers[RGBA_BUFFER] = true;
-        this._updateTag(tagData);
-    }
-    setPickingColorArr(tagData, tagDataIndex, color) {
-        setParametersToArray(tagData._pickingColorArr, tagDataIndex, 3, 3, color.x / 255, color.y / 255, color.z / 255);
-        tagData._changedBuffers[PICKINGCOLOR_BUFFER] = true;
-        this._updateTag(tagData);
-    }
-    // setTexCoordArr(tagData, tagDataIndex, tcoordArr) {
-    //     setParametersToArray(tagData._texCoordArr, tagDataIndex, 2, 2, ...tcoordArr);
-    //     tagData._changedBuffers[TEXCOORD_BUFFER] = true;
-    //     this._updateTag(tagData);
-    // }
-    setScaleArr(tagData, tagDataIndex, scale) {
-        setParametersToArray(tagData._sizeArr, tagDataIndex, 3, 3, scale.x, scale.y, scale.z);
-        tagData._changedBuffers[SIZE_BUFFER] = true;
-        this._updateTag(tagData);
-    }
-    setTranslateArr(tagData, tagDataIndex, translate) {
-        setParametersToArray(tagData._translateArr, tagDataIndex, 3, 3, translate.x, translate.y, translate.z);
-        tagData._changedBuffers[TRANSLATE_BUFFER] = true;
-        this._updateTag(tagData);
-    }
-    setLocalPositionArr(tagData, tagDataIndex, localPosition) {
-        setParametersToArray(tagData._localPositionArr, tagDataIndex, 3, 3, localPosition.x, localPosition.y, localPosition.z);
-        tagData._changedBuffers[LOCALPOSITION_BUFFER] = true;
-        this._updateTag(tagData);
-    }
-    _updateTag(dataTag) {
-        if (dataTag.isFree) {
-            dataTag.isFree = false;
-            this._dataTagUpdateQueue.push(dataTag);
-        }
-    }
-    update() {
-        for (let i = 0, len = this._dataTagUpdateQueue.length; i < len; i++) {
-            this._dataTagUpdateQueue[i].update();
-        }
-        this._dataTagUpdateQueue = [];
-    }
-    _removeAll() {
-        let i = this._geoObjects.length;
-        while (i--) {
-            const gi = this._geoObjects[i];
-            gi._tagDataIndex = -1;
-            gi._tagData = null;
-            gi._handlerIndex = -1;
-            gi._handler = null;
-        }
-        this._geoObjects.length = 0;
-        this._geoObjects = [];
-        for (let i = 0; i < this._instanceDataMapValues.length; i++) {
-            this._instanceDataMapValues[i].clear();
-        }
-        this._instanceDataMap.clear();
-        this._instanceDataMapValues = [];
-    }
-    clear() {
-        this._removeAll();
-    }
-    getRTCPosition(pos, rtcPositionHigh, rtcPositionLow) {
-        let rtcPosition = pos.sub(this._relativeCenter);
-        Vec3.doubleToTwoFloats(rtcPosition, rtcPositionHigh, rtcPositionLow);
-    }
-    setRelativeCenter(c) {
-        this._relativeCenter.copy(c);
-        for (let i = 0; i < this._instanceDataMapValues.length; i++) {
-            let instanceData = this._instanceDataMapValues[i];
-            let geoObjects = instanceData.geoObjects;
-            for (let j = 0; j < geoObjects.length; j++) {
-                geoObjects[j].updateRTCPosition();
-            }
-        }
-    }
-    _updateRTCEyePosition() {
-        let r = this._renderer;
-        if (r.activeCamera.isFirstPass) {
-            let rtcEyePosition = r.activeCamera.eye.sub(this._relativeCenter);
-            Vec3.doubleToTwoFloat32Array(rtcEyePosition, this._rtcEyePositionHigh, this._rtcEyePositionLow);
-        }
-    }
-    draw() {
-        if (this._geoObjects.length) {
-            this._updateRTCEyePosition();
-            this.update();
-            this._displayOpaquePASS();
-        }
-    }
-    drawTransparent() {
-        if (this._geoObjects.length) {
-            this._displayTransparentPASS();
-        }
-    }
-    add(geoObject) {
-        if (geoObject._handlerIndex === -1) {
-            geoObject._handler = this;
-            geoObject._handlerIndex = this._geoObjects.length;
-            this._geoObjects.push(geoObject);
-            this._addGeoObjectToArray(geoObject);
-            geoObject.updateRotation();
-            geoObject._tagData.refresh();
-            this._updateTag(geoObject._tagData);
-            geoObject.setObjectSrc(geoObject._objectSrc);
-        }
-    }
-    remove(geoObject) {
-        if (geoObject._handler && this.__id == geoObject._handler.__id) {
-            this._removeGeoObject(geoObject);
-        }
-    }
-    _clearDataTagQueue() {
-        this._dataTagUpdateQueue = [];
-    }
-    _removeGeoObject(geoObject) {
-        let tagData = geoObject._tagData;
-        let tag = geoObject.tag;
-        tagData.numInstances--;
-        let isEmpty = false;
-        // dataTag becomes empty, remove it from the rendering
-        if (tagData.numInstances === 0) {
-            tagData.clear();
-            this._instanceDataMap.delete(tag);
-            this._instanceDataMapValues = [];
-            this._clearDataTagQueue();
-            isEmpty = true;
-        }
-        this._geoObjects.splice(geoObject._handlerIndex, 1);
-        for (let i = geoObject._handlerIndex, len = this._geoObjects.length; i < len; i++) {
-            let gi = this._geoObjects[i];
-            gi._handlerIndex = gi._handlerIndex - 1;
-        }
-        let tdi = geoObject._tagDataIndex;
-        tagData.geoObjects.splice(tdi, 1);
-        for (let i = geoObject._tagDataIndex, len = tagData.geoObjects.length; i < len; i++) {
-            let gi = tagData.geoObjects[i];
-            gi._tagDataIndex = gi._tagDataIndex - 1;
-        }
-        tagData._rgbaArr = spliceArray(tagData._rgbaArr, tdi * 4, 4);
-        tagData._rtcPositionHighArr = spliceArray(tagData._rtcPositionHighArr, tdi * 3, 3);
-        tagData._rtcPositionLowArr = spliceArray(tagData._rtcPositionLowArr, tdi * 3, 3);
-        tagData._qRotArr = spliceArray(tagData._qRotArr, tdi * 4, 4);
-        tagData._pickingColorArr = spliceArray(tagData._pickingColorArr, tdi * 3, 3);
-        tagData._sizeArr = spliceArray(tagData._sizeArr, tdi * 3, 3);
-        tagData._translateArr = spliceArray(tagData._translateArr, tdi * 3, 3);
-        tagData._localPositionArr = spliceArray(tagData._localPositionArr, tdi * 3, 3);
-        tagData._visibleArr = spliceArray(tagData._visibleArr, tdi, 1);
-        geoObject._handlerIndex = -1;
-        geoObject._handler = null;
-        geoObject._tagDataIndex = -1;
-        geoObject._tagData = null;
-        if (!isEmpty) {
-            tagData.refresh();
-            this._updateTag(tagData);
-        }
-    }
-}
-GeoObjectHandler.__counter__ = 0;

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

@@ -1,125 +0,0 @@
-import { Entity } from "./Entity";
-import { Extent } from "../Extent";
-import { GeometryHandler } from "./GeometryHandler";
-import { Vec4 } from "../math/Vec4";
-import type { NumberArray4 } from "../math/Vec4";
-import type { NumberArray2 } from "../math/Vec2";
-import type { NumberArray3 } from "../math/Vec3";
-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[];
-export type IPolygonCoordinates = CoordinatesType[][];
-export type IMultiLineStringCoordinates = ILineStringCoordinates[];
-export type IMultiPolygonCoordinates = IPolygonCoordinates[];
-export type IGeometryCoordinates = IPointCoordinates | IPolygonCoordinates | IMultiPolygonCoordinates | ILineStringCoordinates | IMultiLineStringCoordinates;
-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];
-}
-export interface IGeometryStyle {
-    fillColor?: string | NumberArray4 | Vec4;
-    lineColor?: string | NumberArray4 | Vec4;
-    strokeColor?: string | NumberArray4 | Vec4;
-    lineWidth?: number;
-    strokeWidth?: number;
-}
-interface IGeometryStyleInternal {
-    fillColor: Vec4;
-    lineColor: Vec4;
-    strokeColor: Vec4;
-    lineWidth: number;
-    strokeWidth: number;
-}
-export interface IGeometryParams<T extends keyof typeof GeometryTypeEnum = keyof typeof GeometryTypeEnum> {
-    type?: T;
-    coordinates?: GeometryTypeToCoordinates[T];
-    style?: IGeometryStyle;
-    visibility?: boolean;
-}
-declare class Geometry {
-    static __counter__: number;
-    __id: number;
-    /**
-     * Entity instance that holds this geometry.
-     * @public
-     * @type {Entity}
-     */
-    _entity: Entity | null;
-    _handler: GeometryHandler | null;
-    _handlerIndex: number;
-    _polyVerticesHighMerc: number[];
-    _polyVerticesLowMerc: number[];
-    _polyVerticesLength: number;
-    _polyIndexesLength: number;
-    _polyVerticesHandlerIndex: number;
-    _polyIndexesHandlerIndex: number;
-    _lineVerticesHighMerc: number[];
-    _lineVerticesLowMerc: number[];
-    _lineVerticesLength: number;
-    _lineOrdersLength: number;
-    _lineIndexesLength: number;
-    _lineColorsLength: number;
-    _lineThicknessLength: number;
-    _lineVerticesHandlerIndex: number;
-    _lineOrdersHandlerIndex: number;
-    _lineIndexesHandlerIndex: number;
-    _lineThicknessHandlerIndex: number;
-    _lineColorsHandlerIndex: number;
-    protected _type: GeometryTypeEnum;
-    _coordinates: IGeometryCoordinates;
-    protected _extent: Extent;
-    _style: IGeometryStyleInternal;
-    protected _visibility: boolean;
-    _pickingReady: boolean;
-    constructor(options?: IGeometryParams);
-    get id(): number;
-    get type(): number;
-    static getType(typeStr: keyof typeof GeometryTypeEnum): GeometryTypeEnum;
-    /**
-     * Returns geometry extent.
-     @static
-     @param {IGeometry} geometryObj - GeoJSON style geometry feature.
-     @param {IGeometryCoordinates} outCoordinates - Geometry feature coordinates clone.
-     @returns {Extent} -
-     */
-    static getExtent(geometryObj: IGeometry, outCoordinates: IGeometryCoordinates): Extent;
-    /**
-     * @todo ASAP need test for this method
-     * @param geoJson
-     * @returns {Geometry}
-     */
-    setGeometry(geoJson: IGeometry): Geometry;
-    setFillColor(r: number, g: number, b: number, a?: number): Geometry;
-    overlaps(extent: Extent): boolean;
-    setFillColor4v(rgba: Vec4): Geometry;
-    setStrokeColor(r: number, g: number, b: number, a?: number): Geometry;
-    setLineColor(r: number, g: number, b: number, a?: number): Geometry;
-    setStrokeColor4v(rgba: Vec4): Geometry;
-    setLineColor4v(rgba: Vec4): Geometry;
-    setStrokeOpacity(opacity: number): Geometry;
-    setLineOpacity(opacity: number): Geometry;
-    setStrokeWidth(width: number): Geometry;
-    bringToFront(): Geometry;
-    setLineWidth(width: number): Geometry;
-    setFillOpacity(opacity: number): Geometry;
-    setVisibility(visibility: boolean): Geometry;
-    getVisibility(): boolean;
-    remove(): void;
-    getExtent(): Extent;
-    getType(): number;
-}
-export { Geometry };