@pirireis/webglobeplugins 0.6.12 → 0.6.15

package/circle-line-chain/chain-list-map.js

@@ -174,8 +174,8 @@ export class ChainListMap {
      */
     textUpdate(chainKey, textWriterObjs, dataPreAdaptor) {
         const chain = this._chainMap.get(chainKey);
-        const data = (dataPreAdaptor) ? chain.map(dataPreAdaptor) : chain;
         if (!chain) return;
+        const data = (dataPreAdaptor) ? chain.map(dataPreAdaptor) : chain;
         const properties = this._chainSideProperties.get(chainKey);
         textWriterObjs.forEach((writer) => {
             writer.insertTextBulk(data, properties);

package/circle-line-chain/plugin-accurate.js

@@ -0,0 +1,406 @@
+import { LineOnGlobeCache } from '../programs/line-on-globe/naive-accurate';
+import { CircleCache } from '../programs/line-on-globe/circle';
+import { LineToTheOriginCache } from "../programs/line-on-globe/to-the-origin"
+import { BufferOrchestrator, BufferManager } from "../util/account";
+import { ChainListMap } from "./chain-list-map";
+import { mapGetOrThrow } from "../util/check/get";
+import { keyMethod } from "./util";
+import { ContextTextWriter3 } from '../write-text/context-text3';
+// TODO: Add update buffer and update text mehods on add, delete, update methods
+
+
+/**
+ * Insert info to chain list map (nodes and properties)
+ * 
+ * ask chain list map for text data
+ * ask chain list map for buffer data
+ * 
+ * 
+ * addNode
+ * insertBulk
+ * deleteChain
+ * deleteNodes
+ * updateCoordinates()
+ * updateChainProperties
+ */
+
+
+/**
+ * @typedef StyleProperties
+ * @property {[0-1,0-1,0-1,0-1]} rgba
+ * @property { 0-1 } dashOpacity 
+ * @property { 0-1 } dashRatio
+ * @property {0-360} circleDashAngle 
+ * @property {Array<node>} nodes
+ */
+
+const radian = Math.PI / 180;
+
+export class CircleLineChainPlugin {
+    /**
+     * 
+     * @param {*} id 
+     * @param {Map<[key, ContextTextWriter3]} textContextWriterInjectionMap //import { ContextTextWriter3 } from "@pirireis/webglobeplugins/write-text/context-text3"; 
+     */
+    constructor(id, {
+        drawCircleOn = true,
+        textContextWriterInjectionMap = new Map(),
+        textDataPreAdaptor = null
+    } = {}) {
+        this.id = id;
+        this._checkTextContextWriterInjectionMap(textContextWriterInjectionMap);
+        this._textContextWriterInjectionMap = textContextWriterInjectionMap;
+        this._textContextWriterInjectionMap.forEach((writer) => writer.setKeyAdaptor((v, i, c, properties) => v.__identity__));
+        this._opacity = 1;
+        this._chainListMap = new ChainListMap(keyMethod);
+        this.bufferOrchestrator = new BufferOrchestrator({ capacity: 10 });
+        this._drawCircleOn = drawCircleOn;
+        this._textDataPreAdaptor = textDataPreAdaptor;
+    }
+
+    // init
+
+    init(globe, gl) {
+        this.gl = gl;
+        this.globe = globe
+        this._initOrchestrations()
+    }
+
+    _checkTextContextWriterInjectionMap(textContextWriterInjectionMap) {
+        if (!(textContextWriterInjectionMap instanceof Map)) throw new Error("textContextWriterInjectionMap is not an instance of Map");
+        textContextWriterInjectionMap.forEach((v) => {
+            if (!(v instanceof ContextTextWriter3)) throw new Error("textContextWriterInjectionMap element is not an instance of ContextTextWriter3");
+        });
+    }
+
+    _initOrchestrations() {
+        const { gl, globe } = this;
+        this.lineProgram = LineOnGlobeCache.get(globe);
+        this.circleProgram = CircleCache.get(globe);
+        this.lineToTheOriginProgram = LineToTheOriginCache.get(globe);
+        {
+            // createBuffers
+            const bufferType = "DYNAMIC_DRAW";
+            const initialCapacity = this.bufferOrchestrator.capacity;
+            this.bufferManagersCompMap = new Map(
+                [
+                    ["centerCoords2d", {
+                        'bufferManager': new BufferManager(gl, 2, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array(globe.api_GetMercator2DPoint(item.long, item.lat)),
+                    }],
+                    ["centerCoords3d", {
+                        'bufferManager': new BufferManager(gl, 3, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array(globe.api_GetCartesian3DPoint(item.long, item.lat, 0, 0)),
+                    }],
+                    ["targetCoords2d", {
+                        'bufferManager': new BufferManager(gl, 2, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array(globe.api_GetMercator2DPoint(item.targetLong, item.targetLat)),
+                    }],
+                    ["targetCoords3d", {
+                        'bufferManager': new BufferManager(gl, 3, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array(globe.api_GetCartesian3DPoint(item.targetLong, item.targetLat, 0, 0)),
+                    }],
+                    ["rgba", {
+                        'bufferManager': new BufferManager(gl, 4, { bufferType, initialCapacity }),
+                        'adaptor': (item) => {
+                            if (item.lineProperties?.rgba) return new Float32Array(item.lineProperties.rgba);
+                            return new Float32Array(item.chainProperties.rgba);
+                        }
+                    }],
+                    ["bigRadius", {
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.bigRadius])
+                    }],
+                    ["dashRatio", {
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.chainProperties.dashRatio])
+                    }],
+
+                    ["dashOpacity", {
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => new Float32Array([item.chainProperties.dashOpacity])
+                    }],
+                    ["circleDashAngle", {
+                        'bufferManager': new BufferManager(gl, 1, { bufferType, initialCapacity }),
+                        'adaptor': (item) => {
+                            if (item.circleProperties?.circleDashAngle) return new Float32Array([item.circleProperties.circleDashAngle / 360]);
+                            return new Float32Array([item.chainProperties.circleDashAngle / 360]);
+                        }
+                    }],
+                    ["rgbaCircle", {
+                        "bufferManager": new BufferManager(gl, 4, { bufferType, initialCapacity }),
+                        "adaptor": (item) => {
+                            if (item.circleProperties?.rgba) return new Float32Array(item.circleProperties.rgba);
+                            return new Float32Array(item.chainProperties.rgba);
+                        }
+                    }]
+                ]
+            );
+            // (startPotisionBufferObj, endPositionBufferObj, dashRatioBufferObj, colorBufferObj)
+            const obj = function (bufferManagerComp) {
+                return { 'buffer': bufferManagerComp.bufferManager.buffer, 'stride': 0, 'offset': 0 }
+            };
+            this.lineVao = this.lineProgram.createVAO(
+                ...['centerCoords2d', 'centerCoords3d', 'targetCoords2d', 'targetCoords3d', 'dashRatio', 'dashOpacity', 'rgba'].map(key => obj(this.bufferManagersCompMap.get(key))));
+            // this.circleVao = this.circleProgram.createVAO(
+            //     ...["centerCoords", "bigRadius", "rgbaCircle", "circleDashAngle", "dashOpacity"].map(key => obj(this.bufferManagersCompMap.get(key))));
+            // this.toOriginVao = this.lineToTheOriginProgram.createVAO(
+            //     ...["targetCoords", "rgba"].map(key => obj(this.bufferManagersCompMap.get(key))));
+        }
+
+    }
+
+
+    // API
+    setDrawCircleOn(bool) {
+        if (typeof bool !== 'boolean') throw new Error("setDrawCircleOn parameter must be a boolean");
+        this._drawCircleOn = bool;
+        this.globe.DrawRender();
+    }
+    // -- update bulk family
+    /**
+     * 
+     * @param {Array<chain>} data 
+     * @typedef chain
+     * @property {string} chainKey
+     * @property {Array<node>} nodes
+     * @typedef {Object} node
+     * @property {string} key
+     * @property {number} long
+     * @property {number} lat  
+     */
+    updateCoordinatesBulk(data, { textWriterIDs = [] } = {}) {
+        // update implicit data structure
+        // find keys to update.. (inserted data and the radius of "from")
+        // updateBuffers
+        // update text
+        const chainKeys = [];
+        for (const chain of data) {
+            chainKeys.push(chain.chainKey);
+            chain.nodes.forEach((node) => {
+                this._chainListMap.updateCoordsinatesOfNode(node, chain.chainKey);
+            });
+        }
+        this._reconstructChains(chainKeys);
+        this._updateTexts(chainKeys, textWriterIDs);
+    }
+
+
+    /**
+     * 
+     * @param {*} chainKey 
+     * @param {Array<{nodeKey, circleProperties:Map[propertyName ,value],  lineProperties:Map[propertyName ,value] }} propertyMap 
+     */
+    updateNodesProperties(chainKey, nodesAndPropertyMap, { textWriterIDs = [] } = {}) {
+        this._chainListMap.updateNodesProperties(chainKey, nodesAndPropertyMap)
+        this._reconstructChains([chainKey]);
+        this._updateTexts([chainKey], textWriterIDs);
+        this.globe.DrawRender();
+    }
+
+    /**
+     * 
+     * @param {*} chainKey 
+     * @param {Map<propertyName ,value} propertyMap 
+     */
+    updateChainProperties(chainKey, propertyMap, { textWriterIDs = [] } = {}) {
+        this._chainListMap.updateChainProperties(chainKey, propertyMap);
+        this._reconstructChains([chainKey]);
+        if (textWriterIDs) this._updateTexts([chainKey], textWriterIDs);
+    }
+
+    // ---- insertBulk family
+    /**
+     * 
+     * @param {Array<chain>} data 
+     * @typedef chain
+     * @property {string} chainKey
+     * @property {StyleProperties} chainProperties
+
+     *  } chainProperties
+     * 
+     * @typedef {Object} node
+     * @property {string} key
+     * @property {number} long
+     * @property {number} lat  
+     * @property {StyleProperties} circleProperties
+     */
+    insertBulk(data, { textWriterIDs = [] } = []) {
+        // first insert everything to implicit structure,
+        // then iterate over data again to update text
+        // let _reconstractChainBufferData method interact with data and bufferOrchestrator.
+        const chainKeysToConstruct = [];
+
+        for (const { chainKey, chainProperties, nodes } of data) {
+            this._chainListMap.setChain(chainKey, nodes);
+            this._chainListMap.setChainProperties(chainKey, chainProperties);
+            chainKeysToConstruct.push(chainKey);
+        }
+        this._reconstructChains(chainKeysToConstruct);
+        if (textWriterIDs) this._updateTexts(chainKeysToConstruct, textWriterIDs);
+        this.globe.DrawRender();
+    }
+
+    /**
+     * 
+     * @param {{key, long, lat}} node
+     * @param {*} chainKey 
+     * @param {*} theNodeKeyFront | node key of the next node, null places to the last
+     */
+    addNode(node, chainKey, { theNodeKeyFront = null, textWriterIDs = [] } = {}) {
+        // TODO: if before object is null update the last two elements of the chain only. 
+        this._chainListMap.addNode(node, chainKey, theNodeKeyFront);
+        if (textWriterIDs) this._updateTexts([chainKey], textWriterIDs);
+        this._reconstructChains([chainKey]);
+        this.globe.DrawRender();
+
+    }
+
+
+
+    updateNodeCoordinates(node, chainKey, { textWriterIDs = [] } = {}) {
+        this._chainListMap.updateCoordsinatesOfNode(node, chainKey);
+        if (textWriterIDs) this._updateTexts([chainKey], textWriterIDs);
+        this._reconstructChains([chainKey]);
+        this.globe.DrawRender();
+    }
+
+
+
+    setOpacity(opacity) {
+        if (typeof opacity !== 'number') throw new Error("opacity must be a number");
+        if (opacity < 0 || 1 < opacity) throw new Error("opacity must be between 0-1");
+        this._textContextWriterInjectionMap.forEach((writer) => writer.setOpacity(opacity));
+        this._opacity = opacity;
+        this.globe.DrawRender();
+    }
+
+
+
+    getChain(chainKey) {
+        this._chainListMap.getChain(chainKey);
+    }
+
+    /**
+     * 
+     * @param {*} chainKeys 
+     */
+    deleteChains(chainKeys) {
+        const bufferKeys = [];
+        for (const chainKey of chainKeys) {
+            bufferKeys.push(...this._chainListMap.deleteChainAndReturnChainKeys(chainKey));
+        }
+        this._textContextWriterInjectionMap.forEach((writer) => writer.deleteTextBulk(bufferKeys));
+        this._updateTexts(chainKeys, this._textContextWriterInjectionMap.keys());
+        this.bufferOrchestrator.deleteBulk(bufferKeys, this.bufferManagersCompMap);
+        this.globe.DrawRender();
+    }
+
+
+    /**
+     * 
+     * @param {Array<{chainKey, nodeKeys:[]} keysAndNodes
+     */
+    deleteNodes(keysAndNodes, { textWriterIDs = [] } = {}) {
+        const bufferKeys = [];
+        const chainKeysToReconstuct = [];
+        keysAndNodes.forEach(({ chainKey, nodeKeys }) => {
+            bufferKeys.push(...this._chainListMap.deleteNodesBelongToAChain(chainKey, nodeKeys));
+            chainKeysToReconstuct.push(chainKey);
+        });
+        this._textContextWriterInjectionMap.forEach((writer) => writer.deleteTextBulk(bufferKeys));
+        this.bufferOrchestrator.deleteBulk(bufferKeys, this.bufferManagersCompMap);
+        this._reconstructChains(chainKeysToReconstuct);
+        this._updateTexts(chainKeysToReconstuct, textWriterIDs);
+        this.globe.DrawRender();
+
+    }
+
+
+    updateText(textWriterIDs) {
+        const chainKeyIterator = this._chainListMap.getAllChainKeysIterator();
+        this._updateTexts(chainKeyIterator, textWriterIDs);
+    }
+
+
+    // implicit
+
+    _updateTexts(chainKeys, textWriterIDs) {
+        if (textWriterIDs.length === 0) return;
+        const textWriters = textWriterGetOrThrow(this._textContextWriterInjectionMap, textWriterIDs)
+        chainKeys.forEach((chainKey) => {
+            this._chainListMap.textUpdate(chainKey, textWriters, this._textDataPreAdaptor);
+        })
+    }
+
+
+    _reconstructChains(chainKeys) {
+        const { globe } = this;
+        //     this.lineVao = this.lineProgram.createVAO(
+        //         ...['centerCoords', 'targetCoords', 'dashRatio', 'dashOpacity', 'rgba'].map(key => obj(this.bufferManagersCompMap.get(key))));
+        //     this.circleVao = this.circleProgram.createVAO(
+        //         ...["centerCoords", "bigRadius", "rgba", "circleDashAngle", "dashOpacity"].map(key => obj(this.bufferManagersCompMap.get(key))));
+        // }   
+
+        const radiusM = radiusMethod(globe);
+        const callback = (v, i, array, chainProperties) => {
+            if (i == array.length - 1) return null;
+            return {
+                chainProperties: chainProperties,
+                bigRadius: radiusM(v, i, array),
+                targetLong: array[i + 1].long,
+                targetLat: array[i + 1].lat,
+                long: v.long,
+                lat: v.lat,
+                lineProperties: v.lineProperties,
+                circleProperties: v.circleProperties,
+                key: v.__identity__
+            }
+        }
+        const bulkData = [];
+        chainKeys.forEach((k) => {
+            this._chainListMap.calculateBufferPropertiesChain(k, callback, bulkData);
+        })
+
+        this._insertBulk(bulkData);
+    }
+
+
+    _insertBulk(bulkData) {
+        this.bufferOrchestrator.insertBulk(bulkData, this.bufferManagersCompMap);
+        this.globe.DrawRender();
+    }
+
+
+    // GLOBE API
+    //TODO:
+    free() {
+        if (this.isFreed) return;
+        this.bufferManagersCompMap.forEach(({ bufferManager }) => {
+            bufferManager.free();
+        })
+        LineOnGlobeCache.release(this.globe);
+        CircleCache.release(this.globe);
+        this.lineProgram = null;
+        this.circleProgram = null;
+        this.isFreed = true;
+    }
+
+    draw3D() {
+        const { gl, globe } = this;
+        gl.disable(gl.DEPTH_TEST);
+        this.lineProgram.draw(this.lineVao, this.bufferOrchestrator.length, this._opacity);
+        if (this._drawCircleOn) this.circleProgram.draw(this.circleVao, this.bufferOrchestrator.length, this._opacity);
+        this._textContextWriterInjectionMap.forEach((writer) => writer.draw());
+        gl.enable(gl.DEPTH_TEST);
+        this.lineToTheOriginProgram.draw(this.toOriginVao, this.bufferOrchestrator.length, this._opacity);
+    }
+}
+
+
+
+const radiusMethod = (globe) => (v, i, array) => {
+    return globe.Math.GetDist3D(v.long, v.lat, array[i + 1].long, array[i + 1].lat)
+}
+
+const textWriterGetOrThrow = mapGetOrThrow("textWriterIds is invalid")

package/circle-line-chain/plugin.js

@@ -1,5 +1,6 @@
 import { LineOnGlobeCache } from '../programs/line-on-globe/naive';
 import { CircleCache } from '../programs/line-on-globe/circle';
+import { LineToTheOriginCache } from "../programs/line-on-globe/to-the-origin"
 import { BufferOrchestrator, BufferManager } from "../util/account";
 import { ChainListMap } from "./chain-list-map";
 import { mapGetOrThrow } from "../util/check/get";
@@ -76,6 +77,7 @@ export class CircleLineChainPlugin {
         const { gl, globe } = this;
         this.lineProgram = LineOnGlobeCache.get(globe);
         this.circleProgram = CircleCache.get(globe);
+        this.lineToTheOriginProgram = LineToTheOriginCache.get(globe);
         {
             // createBuffers
             const bufferType = "DYNAMIC_DRAW";
@@ -134,14 +136,14 @@ export class CircleLineChainPlugin {
                 ...['centerCoords', 'targetCoords', 'dashRatio', 'dashOpacity', 'rgba'].map(key => obj(this.bufferManagersCompMap.get(key))));
             this.circleVao = this.circleProgram.createVAO(
                 ...["centerCoords", "bigRadius", "rgbaCircle", "circleDashAngle", "dashOpacity"].map(key => obj(this.bufferManagersCompMap.get(key))));
+            this.toOriginVao = this.lineToTheOriginProgram.createVAO(
+                ...["targetCoords", "rgba"].map(key => obj(this.bufferManagersCompMap.get(key))));
         }
 
     }
 
 
     // API
-
-
     setDrawCircleOn(bool) {
         if (typeof bool !== 'boolean') throw new Error("setDrawCircleOn parameter must be a boolean");
         this._drawCircleOn = bool;
@@ -377,12 +379,13 @@ export class CircleLineChainPlugin {
     }
 
     draw3D() {
-        const { gl } = this;
+        const { gl, globe } = this;
         gl.disable(gl.DEPTH_TEST);
         this.lineProgram.draw(this.lineVao, this.bufferOrchestrator.length, this._opacity);
         if (this._drawCircleOn) this.circleProgram.draw(this.circleVao, this.bufferOrchestrator.length, this._opacity);
         this._textContextWriterInjectionMap.forEach((writer) => writer.draw());
         gl.enable(gl.DEPTH_TEST);
+        this.lineToTheOriginProgram.draw(this.toOriginVao, this.bufferOrchestrator.length, this._opacity);
     }
 }
 

package/compass-rose/compass-rose-padding-flat.js

@@ -57,14 +57,27 @@ export class PixelPaddingCompassPlugin {
         this._initOrchestrations()
     }
 
+
+    /**
+     * @param {string} key
+     * @param {number} long
+     * @param {number} lat
+     * @typedef properties
+     * @property {number} pixelRadiusBig
+     * @property {number} pixelRadiusSmall
+     * @property {[4 numbers between 0-1]} rgba 
+     */
     insert(key, long, lat, properties = null) {
         this.__insertText(key, null, null, { properties, update: true });
         this.compassMap.insert(key, long, lat, properties);
         this.globe.DrawRender();
-
     }
 
 
+    /**
+     * 
+     * @param {string} key 
+     */
     delete(key) {
         this.compassMap.delete(key);
         this.globe.DrawRender();
@@ -166,7 +179,10 @@ export class PixelPaddingCompassPlugin {
     }
 
     free() {
-
+        this.compassMap.free();
+        this.bufferManagersCompMap.forEach(v => {
+            v.bufferManager.free();
+        })
 
     }
 }
@@ -190,6 +206,13 @@ class CompassMap {
         this.propertyMemory.delete(key);
     }
 
+    free() {
+        this.coordsMemory.clear();
+        this.propertyMemory.clear();
+        this.coordsMemory = null;
+        this.propertyMemory = null;
+    }
+
     query(globe, writer) {
         const { coordsMemory, propertyMemory } = this;
         const defaultProperties = this.parent.defaultProperties;

package/heatwave/plugins/heatwaveglobeshell.js

@@ -140,8 +140,6 @@ export default class Plugin {
     }
 
 
-
-
     _updateData(ratio, textureData0 = null, textureData1 = null) {
         if (!textureData0 || !textureData1) {
             this.isAble = false;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pirireis/webglobeplugins",
-    "version": "0.6.12",
+    "version": "0.6.15",
     "main": "index.js",
     "author": "Toprak Nihat Deniz Ozturk",
     "license": "MIT"

package/{heatwavemaps/isobar/objectarraylabels.js → pin/pin-object-array.js}

@@ -1,9 +1,30 @@
+
+/**
+ * IconData;
+ *  iconMap, iconCoords for objectArray
+ * 
+ * Pin data:
+ *  long, lat, payload
+ * 
+ * methods insertPin pin and its data
+ * methods deletePin
+ * 
+ * Behaviur injection:
+ * hover
+ * move
+ * pick drop
+ * mouseclicks
+ * keyboard clicks
+ * mouse curser changes ( this can be implemented inside above methods)
+ */
+
 import {
     CSGlobe,
     CSIconTypes,
     CSObjectTypes,
     CSObjectArrayUpdateTypes,
 } from "@pirireis/webglobe";
+import AlarmTimeLineFadeInFadeOut from "../../plugins/alarms/alarmFadeInFadeOutPlugin/AlarmTimeLineFadeInFadeOutPlugin";
 
 /**
  * @typedef {Object} IconPayload
@@ -30,6 +51,118 @@ import {
  * @property {PointPayload[]} attribs
  */
 
+function addIconMap(globe, mapName = "IconMapName", ICON_MAP_URL, ICON_MAP_JSON_URL) {
+    globe.api_AddIconMap('IconMapName', ICON_MAP_URL, ICON_MAP_JSON_URL);
+}
+
+class ObjectArray {
+    constructor(symbolSet, style) {
+        this.symbolSet = symbolSet;
+        this.style = style;
+    }
+
+    setSymbolSet(symbolSet) {
+        this.symbolSet = symbolSet;
+    }
+
+
+}
+
+
+class PinPointObjectArray {
+    constructor(id,
+        globe,
+        symbolSet, // iconMapName
+        style,
+        callBacks = {
+            mouseDown: (pinItem, event) => { },
+            mouseMove: (pinItem, event) => { },
+            mouseUp: (pinItem, event) => { },
+            mouseClick: (pinItem, event) => { },
+            mouseDblClick: (pinItem, event) => { },
+
+        } = {}) {
+        this.id = id
+        this.globe = globe;
+        this.symbolSet = symbolSet;
+        this.style = style;
+        this.iconMapName = iconMapName;
+        this.callBacks = callBacks;
+
+        // this item will be used
+
+        this.currentItem = null
+    }
+
+
+    insertPins(pins) {
+
+    }
+
+    deletePins(pinsIDs) {
+        const deleteBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        }
+    }
+
+
+    _queryByScreenFindFirst() {
+        const { clientX, clientY } = this.globe.api_GetMousePos();
+        const allObjects = this.globe.queryByScreen(clientX, clientY);
+        for (let i = 0; i < allObjects.length; i++) {
+            const { obj, owner } = allObjects[i];
+            if (owner === this.objectArray) {
+                return obj;
+            }
+        }
+    }
+
+    // mouseDown(x, y, event) {
+    //     return false
+    // }
+
+
+    // // mouse'a basılıp hareket ettirildiğinde, mouseDown'dan true dönmüşse çağrılır
+    // mouseMove(x, y, event) {
+
+    // }
+
+    // // mouse bırakıldığında çağrılır
+    // mouseUp(x, y, event) {
+
+    // }
+
+    // // harita üzerinde tıklandığında çağrılır
+    // mouseClick() {
+    //     return false
+    // }
+
+    // // harita üzerinde çift tıklandığında çağrılır
+    // mouseDblClick() {
+    //     return false
+    // }
+
+
+    free() {
+        this.globe.api_ClearMouseEvents() // TODO
+    }
+
+    _setMouseEvent() {
+        const { globe } = this;
+        globe.api_SetMouseEvents()
+    }
+
+    _getIdForGlobe() {
+        const { globe, objectArray } = this;
+        const callback = () => {
+            const allObjects = globe.api_queryByScreen()
+        }
+        return `${this.id}_pinObjectArrayMouseEvent`;
+    }
+}
+
 class ObjectArrayLabels {
     /**
      * @param {number | string} id
@@ -244,4 +377,5 @@ class ObjectArrayLabels {
     }
 }
 
-export default ObjectArrayLabels;
+export default ObjectArrayLabels;
+