@pirireis/webglobeplugins 0.15.34 → 0.16.0

package/dist/partialrings/program.js

@@ -0,0 +1,279 @@
+import { createProgram, shaderfunctions } from "../util";
+import { CameraUniformBlockTotem, CameraUniformBlockString, noRegisterGlobeProgramCache, globeProgramCache } from "../programs";
+import BufferManager from "./buffer-manager";
+import { POLE, PI, longLatRadToMercator, mercatorXYToGLPosition, longLatRadToCartesian3D, circleLimpFromLongLatRadCenterCartesian3D, circleLimpFromLongLatRadCenterMercatorRealDistance, cartesian3DToGLPosition } from "../util/shaderfunctions/geometrytransformations";
+/**
+ * TODO:
+ * 1. Triangle face looks at screen. if rotation angle is positive the last vertex must be the faintest.
+ *
+ */
+const drawModeMap = Object.freeze({
+    LINE_STRIP: 0,
+    TRIANGLE_FAN: 1,
+});
+const vertexShaderSource = `#version 300 es
+
+${CameraUniformBlockString} 
+${PI} 
+${longLatRadToMercator}
+${mercatorXYToGLPosition}
+${longLatRadToCartesian3D}
+${circleLimpFromLongLatRadCenterCartesian3D}
+${circleLimpFromLongLatRadCenterMercatorRealDistance}
+${cartesian3DToGLPosition}
+
+uniform float edge_count;
+uniform int draw_mode; // %2 => 0: LINE_STRIP, 1: TRIANGLE_FAN 
+uniform float plugin_alpha_multiplier;
+//, lat, startAngle, tailAngle, ...rgba, radius, rgbaMode
+in vec2 center; // long, lat in radian
+in float start_angle; // the start of partial circle from bearing point
+in float tail_angle; // the rotation of the partial circle
+in vec4 color;
+in float radius; // in meter
+in float color_mode; // 0.0: constant, 1.0: fading, 2.0: hide
+// flat out int vid;
+// flat out float v_phase;
+out vec2 v_pos;
+out vec4 v_color;
+// flat out float v_angle;
+
+void main() {
+    // vid = gl_VertexID;
+    if (color_mode == 2.0 || radius == 0.0) { return; }
+    float color_mode_ = color_mode;
+    if ( draw_mode == 0 && color_mode == 1.0) {color_mode_ = 0.0;}
+    float vertexID = float(gl_VertexID);
+    float radius_ = radius;
+    float alpha = plugin_alpha_multiplier;
+    if (draw_mode == 1) { // TRIANGLE_FAN
+        if (gl_VertexID == 0) { 
+            radius_ = 0.0; 
+            if ( color_mode == 1.0 ) { alpha = 0.0; }
+        }
+        vertexID -= 1.0;
+    }
+    float phase = ( vertexID  / (edge_count - 1.0) );
+    // v_angle = tail_angle;
+    
+    if ( color_mode_ == 1.0 ) {
+        if ( tail_angle < 0.0 ) {
+                v_color = vec4( color.rgb , color.a * ( 1.0 - phase ) * alpha );
+            } else {
+                v_color = vec4( color.rgb , color.a * phase * alpha );
+        }
+    } else {
+        v_color = vec4( color.rgb , color.a * alpha );
+    }
+    if ( color_mode == 0.0 && draw_mode == 1 ) {
+        v_color.a /= 2.0;
+    }
+    float angle;
+    if ( tail_angle > 0.0 ) { 
+        angle =  tail_angle * (-phase + 1.0) + start_angle;
+        } else {
+        angle = tail_angle * phase + start_angle;
+    }
+    if (is3D) {
+
+        vec3 pos = circleLimpFromLongLatRadCenterCartesian3D(center, radius_, angle);
+        v_pos = vec2(0.0, 0.0);
+        gl_Position = cartesian3DToGLPosition(pos);
+    }
+    else {
+        
+        vec2 pos = circleLimpFromLongLatRadCenterMercatorRealDistance(center, radius_, angle);
+        v_pos = pos;
+        gl_Position = mercatorXYToGLPosition(pos);
+    }
+
+    gl_PointSize = 10.0;
+}`;
+const fragmentShaderSource = `#version 300 es` + POLE + PI + `
+precision highp float;
+// flat in int vid;
+in vec4 v_color;
+in vec2 v_pos;
+// flat in float v_phase;
+// in float v_angle;
+out vec4 outColor;
+void main() {
+    // if( vid % 2 == 0 ) { discard; }
+    // if ( mod(v_angle, PI / 36.0 ) < (PI / 72.0)) { discard; }
+    // if ( mod(v_angle * v_phase,  PI / 90.0 ) < (PI / 180.0)) { discard; }
+    if ( v_pos.x < -POLE || v_pos.x > POLE || v_pos.y < -POLE || v_pos.y > POLE ) { discard; }
+    outColor = v_color;
+}`;
+export const ITEM_SIZE = 10;
+export class Logic {
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this._lastMode = 0;
+        this._lastEdgeCount = 64;
+        this._lastAlphaMultiplier = 1.0;
+        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
+        const { gl, program } = this;
+        { // set attributes locations 
+            gl.bindAttribLocation(program, 0, 'center');
+            gl.bindAttribLocation(program, 1, 'start_angle');
+            gl.bindAttribLocation(program, 2, 'tail_angle');
+            gl.bindAttribLocation(program, 3, 'color');
+            gl.bindAttribLocation(program, 4, 'radius');
+            gl.bindAttribLocation(program, 5, 'color_mode');
+            // vao
+            // instanced draw read 1 
+        }
+        { // Uniforms
+            this._edgeCountLocation = gl.getUniformLocation(program, 'edge_count');
+            this._draw_modeLocation = gl.getUniformLocation(program, 'draw_mode');
+            this._plugin_alpha_multiplierLocation = gl.getUniformLocation(program, 'plugin_alpha_multiplier');
+            const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+            gl.useProgram(program);
+            gl.uniform1i(this._draw_modeLocation, this._lastMode);
+            gl.uniform1f(this._edgeCountLocation, this._lastEdgeCount);
+            gl.uniform1f(this._plugin_alpha_multiplierLocation, 1.0);
+            this.cameraBlockBindingPoint = 0;
+            this.cameraBlockTotem = globeProgramCache.getProgram(globe, CameraUniformBlockTotem);
+            const cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+            gl.uniformBlockBinding(program, cameraBlockIndex, this.cameraBlockBindingPoint);
+            gl.useProgram(currentProgram);
+        }
+    }
+    draw(length, vao, edgeCount, alphaMultiplier, drawMode) {
+        const { gl, program, cameraBlockTotem, cameraBlockBindingPoint } = this;
+        // gl.disable(gl.DEPTH_TEST);
+        gl.useProgram(program);
+        if (drawMode !== this._lastMode) {
+            gl.uniform1i(this._draw_modeLocation, drawModeMap[drawMode]);
+            this._lastMode = drawMode;
+        }
+        if (edgeCount !== this._lastEdgeCount) {
+            gl.uniform1f(this._edgeCountLocation, edgeCount);
+            this._lastEdgeCount = edgeCount;
+        }
+        if (alphaMultiplier !== this._lastAlphaMultiplier) {
+            gl.uniform1f(this._plugin_alpha_multiplierLocation, alphaMultiplier);
+            this._lastAlphaMultiplier = alphaMultiplier;
+        }
+        const overdraw = drawModeMap[drawMode];
+        cameraBlockTotem.bind(cameraBlockBindingPoint);
+        gl.bindVertexArray(vao);
+        gl.drawArraysInstanced(gl[drawMode], 0, edgeCount + overdraw, length);
+        cameraBlockTotem.unbind(cameraBlockBindingPoint);
+        gl.bindVertexArray(null);
+        // gl.enable(gl.DEPTH_TEST);
+    }
+    free() {
+        noRegisterGlobeProgramCache.releaseProgram(this.globe, CameraUniformBlockTotem);
+        this.gl.deleteProgram(this.program);
+        this.program = null;
+    }
+    getVaoBuffer() {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        const buffer = gl.createBuffer();
+        gl.bindVertexArray(vao);
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        const stride = ITEM_SIZE * 4;
+        let offset = 0;
+        gl.enableVertexAttribArray(0);
+        gl.vertexAttribPointer(0, 2, gl.FLOAT, false, stride, offset);
+        offset += 2 * 4;
+        gl.enableVertexAttribArray(1);
+        gl.vertexAttribPointer(1, 1, gl.FLOAT, false, stride, offset);
+        offset += 1 * 4;
+        gl.enableVertexAttribArray(2);
+        gl.vertexAttribPointer(2, 1, gl.FLOAT, false, stride, offset);
+        offset += 1 * 4;
+        gl.enableVertexAttribArray(3);
+        gl.vertexAttribPointer(3, 4, gl.FLOAT, false, stride, offset);
+        offset += 4 * 4;
+        gl.enableVertexAttribArray(4);
+        gl.vertexAttribPointer(4, 1, gl.FLOAT, false, stride, offset);
+        offset += 1 * 4;
+        gl.enableVertexAttribArray(5);
+        gl.vertexAttribPointer(5, 1, gl.FLOAT, false, stride, offset);
+        gl.vertexAttribDivisor(0, 1);
+        gl.vertexAttribDivisor(1, 1);
+        gl.vertexAttribDivisor(2, 1);
+        gl.vertexAttribDivisor(3, 1);
+        gl.vertexAttribDivisor(4, 1);
+        gl.vertexAttribDivisor(5, 1);
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return {
+            vao,
+            buffer,
+        };
+    }
+    /**
+     * in vec2 center; // long, lat in radian
+in float start_angle; // the start of partial circle from bearing point
+in float tail_angle; // the rotation of the partial circle
+in vec4 color;
+in float radius; // in meter
+in float color_mode; // 0.0: constant, 1.0: fading, 2.0: hide
+     */
+    createVAO(centerObj, startAngleObj, tailAngleObj, colorObj, radiusObj, colorModeObj) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        {
+            const { buffer, stride, offset } = centerObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(0);
+            gl.vertexAttribPointer(0, 2, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(0, 1);
+        }
+        {
+            const { buffer, stride, offset } = startAngleObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(1);
+            gl.vertexAttribPointer(1, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(1, 1);
+        }
+        {
+            const { buffer, stride, offset } = tailAngleObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(2);
+            gl.vertexAttribPointer(2, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(2, 1);
+        }
+        {
+            const { buffer, stride, offset } = colorObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(3);
+            gl.vertexAttribPointer(3, 4, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(3, 1);
+        }
+        {
+            const { buffer, stride, offset } = radiusObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(4);
+            gl.vertexAttribPointer(4, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(4, 1);
+        }
+        {
+            const { buffer, stride, offset } = colorModeObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(5);
+            gl.vertexAttribPointer(5, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(5, 1);
+        }
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return vao;
+    }
+    getBufferManagerAndVao({ capacity = 10, bufferType = "DYNAMIC_DRAW" } = {}) {
+        const { vao, buffer } = this.getVaoBuffer();
+        return {
+            bufferManager: new BufferManager(this.globe, this.gl, buffer, { capacity, bufferType }),
+            vao
+        };
+    }
+}
+export const programCache = Object.freeze({
+    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, Logic),
+    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, Logic)
+});

package/dist/pin/pin-object-array.js

@@ -0,0 +1,300 @@
+/**
+ * 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
+ * @property {string} app6DCode
+ * @property {string} accsCode
+ */
+/**
+ * @typedef {IconPayload & Object.<string, any>} PointPayload
+ */
+/**
+ * @typedef {Object} CanChangeOptions
+ * @property {boolean} [attribs=false]
+ * @property {boolean} [icon=false]
+ * @property {boolean} [label=false]
+ * @property {boolean} [heading=false]
+ */
+/**
+ * @typedef {Object} PointObjectArray
+ * @property {number[]} coords [longitude1, latitude1, longitude2, latitude2, ....]
+ * @property {number[]} coordsZ [z1, z2, ....]
+ * @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
+     * @param {CSGlobe} globe
+     */
+    constructor(id, globe, labelStyle = null) {
+        this.id = id;
+        this.setGlobe(globe);
+        this.data = [
+            {
+                coords: [],
+                coordsZ: [],
+                attribs: [],
+            },
+        ];
+        this.primaryKey = "id";
+        this.objectType = CSObjectTypes.POINT;
+        this.filter = null;
+        this.bbox = null;
+        this.startLod = 2;
+        this.endLod = 19;
+        this.query = true;
+        this.reportObj = function (values, mouseEvent) { };
+        this._idCollector = new Set();
+        this._setStyle(labelStyle);
+    }
+    _setStyle(labelStyle) {
+        this.style = this.globe.ObjectArray.GetDefaultStyle();
+        if (labelStyle) {
+            this.style.labels[0] = labelStyle;
+        }
+        else {
+            this.style.labels[0].vAlignment = 2; // dikey olarak tam noktanın ortası
+            this.style.labels[0].hAlignment = 2; // yatay olarak tam noktanın ortası
+            this.style.labels[0].size = 11;
+            this.style.labels[0].drawAlways = true;
+            this.style.labels[0].fontFamily.name = "arial";
+            this.style.labels[0].fontFamily.bold = false;
+            this.style.labels[0].fontFamily.hollow = true;
+            this.style.labels[0].fontFamily.hollowWidth = 1;
+            this.style.labels[0].fontFamily.hollowOpacity = 1;
+        }
+        this.style.labels[0].text = "${value}";
+        this.style.fidKey = this.primaryKey;
+        this.style.iconType = CSIconTypes.NOICON; // milIcon ekleyebilmek için icon tipi MAP olmalı
+    }
+    /**
+     * @param {CSGlobe} [globe]
+     */
+    setGlobe(globe) {
+        if (!globe)
+            return;
+        this.globe = globe;
+    }
+    addToMap() {
+        this.globe.ObjectArray.Add(this);
+    }
+    removeFromMap() {
+        this.flush();
+        this.globe.ObjectArray.Delete(this.id);
+    }
+    /**
+     * Haritaya kullanılacak veriyi verir. Her çağrıldığında tüm hesaplamalar yeniden yapılır
+     * @param {PointObjectArray} data
+     */
+    setData(data) {
+        this.globe.ObjectArray.SetData(this, [data]);
+    }
+    /**
+     * @param {PointObjectArray} data
+     * @param {CSObjectArrayUpdateTypes} operation
+     * @param {CanChangeOptions} [canChange]
+     */
+    updateData(data, operation, canChange) {
+        this.globe.ObjectArray.UpdateData(this, operation, [data], canChange);
+    }
+    flush() {
+        const deleteBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: [],
+        };
+        this.setData(deleteBucket);
+        this._idCollector = new Set();
+    }
+    /**
+     * Haritaya kullanılacak veriyi verir. Her çağrıldığında tüm hesaplamalar yeniden yapılmaz, ancak ön hesaplama maliyeti vardır
+     * @param {PointObjectArray} data
+     */
+    setControlledData(data) {
+        const paritalData = {
+            add: {
+                coords: [],
+                coordsZ: [],
+                attribs: [],
+            },
+            update: {
+                coords: [],
+                coordsZ: [],
+                attribs: [],
+            },
+            delete: {
+                coords: [],
+                coordsZ: [],
+                attribs: [],
+            },
+            canChange: {
+                // Tüm değişimler gözardı edilecek
+                attribs: false,
+                icon: false,
+                label: false,
+                heading: false,
+            },
+        };
+        // İlk toplu ekleme adımı
+        if (this._idCollector.size === 0) {
+            this.setData(data);
+            // Eklenen id'ler set edildi
+            for (let i = 0; i < data.attribs.length; i++) {
+                const currentPayload = data.attribs[i];
+                const id = currentPayload[this.primaryKey];
+                this._idCollector.add(id);
+            }
+            return;
+        }
+        /** @type {Set<string>} */
+        const dataIds = new Set();
+        for (let i = 0; i < data.attribs.length; i++) {
+            const currentPayload = data.attribs[i];
+            const id = currentPayload[this.primaryKey];
+            let bucket = paritalData.add;
+            dataIds.add(id);
+            if (this._idCollector.has(id)) {
+                bucket = paritalData.update;
+            }
+            else {
+                this._idCollector.add(id);
+            }
+            bucket.coords.push(data.coords[2 * i], data.coords[2 * i + 1]);
+            bucket.coordsZ.push(data.coordsZ[i]);
+            bucket.attribs.push(currentPayload);
+        }
+        // Artık varolmayan elemenları sil
+        const deleteBucket = paritalData.delete;
+        this._idCollector.forEach((id) => {
+            if (!dataIds.has(id)) {
+                this._idCollector.delete(id);
+                deleteBucket.coords.push(0, 0);
+                deleteBucket.coordsZ.push(0);
+                deleteBucket.attribs.push({
+                    [this.primaryKey]: id,
+                });
+            }
+        });
+        if (paritalData.add.coords.length > 0) {
+            this.updateData(paritalData.add, CSObjectArrayUpdateTypes.ADD);
+        }
+        if (paritalData.update.coords.length > 0) {
+            this.updateData(paritalData.update, CSObjectArrayUpdateTypes.UPDATE, paritalData.canChange);
+        }
+        if (paritalData.delete.coords.length > 0) {
+            this.updateData(paritalData.delete, CSObjectArrayUpdateTypes.DELETE);
+        }
+    }
+    setPrimarykey(key) {
+        this.primaryKey = key;
+    }
+    setSymbolSet(symbolSet) {
+        this.symbolSet = symbolSet;
+    }
+    getLabelStyle() {
+        return this.style.labels[0];
+    }
+    setLabelStyle(style) {
+        this.style.labels[0] = style;
+    }
+}
+export default ObjectArrayLabels;

package/dist/pin/pin-point-totem.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * This class registered as globe plugin one for each globe. to the head of plugin call stack.
+ */
+class PinPointTotem {
+    constructor(globe) {
+        this.objectArrayMap = new Map();
+    }
+    /**
+     * objectArray
+     * callbacks ={
+     *  mouseDown,
+     *  mouseMove,
+     *  mouseUp,
+     *  mouseClick,
+     *  mouseDbClick,
+     *  keyDown,
+     *  keyUp
+     * }
+     */
+    registerPinMap(objectArray, callbacks) {
+        this.objectArrayMap.set(objectArray, callbacks);
+    }
+    unregisterPinMap(objectArray) {
+        if (this.objectArrayMap.has(objectArray)) {
+            this.objectArrayMap.delete(objectArray);
+        }
+        else {
+            console.warn('PinPointTotem objectArrayMap does not contain the objectArray');
+        }
+    }
+    // GlobeMethods
+    // haritada sol butona basıldığında çağrılır
+    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 up'ın left'i mouseDown'dan true dönmüşse çağrılır, edit mode içindir
+    // right'i ise sağ tıka basılıp bırakıldığında çağrılır
+    mouseUp(x, y, event) {
+    }
+    // harita üzerinde tıklandığında çağrılır
+    mouseClick(x, y, event) {
+        return false;
+    }
+    // harita üzerinde çift tıklandığında çağrılır
+    mouseDblClick(x, y, event) {
+        return false;
+    }
+    // klavyeden bir tuşa basıldığı anda ve tuşa basılı kalınmaya devam edildiği durumlarda çalışır
+    keyDown(event) {
+        return false;
+    }
+    // klavyedeki bir tuştan parmak çekildiği anda çalışır
+    keyUp(event) {
+        return false;
+    }
+}

package/dist/point-heat-map/adaptors/timetracksplugin-format-to-this.js

@@ -0,0 +1,63 @@
+/**
+ * @typedef {Float32Array} TimeTrackMultiColorData  | A linestring is representation, let A{a1, a2, a3}, B{b1, b2} be the points of the line.
+     * TimeTrackMultiColorData is [
+     *  a1x, a1y, a1z, a1time, a1r, a1g, a1b, a1time, a3time,
+     *  a2x, a2y, a2z, a2time, a2r, a2g, a2b, a1time, a3time,
+     *  a3x, a3y, a3z, a3time, a3r, a3g, a3b, a1time, a3time,
+     *  0, 0, 0, 0, -1, -1, -1, 0, 0,
+     *  b1x, b1y, b1z, b1time, b1r, b1g, b1b, b1time, b2time,
+     *  b2x, b2y, b2z, b2time, b2r, b2g, b2b, BstartTime, BendTime
+     * ]
+     * there is a cutting point between A and B
+     *
+*/
+/**
+ * ABOVE
+ *  TO
+ * BELOW
+
+/**
+ * @typedef {Array<number>} vec3 [x, y, z]
+ * @typedef {Array<number>} vec2 [x, y]
+ * @typedef {Array<number>} vec4 [x, y, z, w]
+ * @typedef {number} fraction a number between 0 and 1
+ * @typedef {Array<number>} wgs84 [long, lat]
+ */
+/**
+ * @typedef Timetrack
+ * @property {Array<vec4>}} coordinates [x,y,z, length]
+ * @property {Array<Number>} times
+ * @param {Array<Timetrack>} timeTracks
+ */
+import { pixelXYLenghtToUnitVectorWithHeight } from "../../Math/methods";
+const processACut = (array, offset) => {
+    // first 3 values of array
+    const v3 = array.slice(offset, offset + 3);
+    const v4 = pixelXYLenghtToUnitVectorWithHeight(v3);
+    const time = array[offset + 3];
+    return [v4, time];
+};
+const timeTrackPluginDataToPointHeatInterpolatorAdapter = (timeTrackPluginData) => {
+    const timeTracks = [];
+    let offset = 0;
+    let timeTrack = {
+        coordinates: [],
+        times: []
+    };
+    while (offset < timeTrackPluginData.length) {
+        if (!timeTrackPluginData[offset]) {
+            timeTracks.push(timeTrack);
+            timeTrack = {
+                coordinates: [],
+                times: []
+            };
+            offset += 9;
+        }
+        const point = processACut(timeTrackPluginData, offset);
+        offset += 9;
+        timeTrack.coordinates.push(point[0]);
+        timeTrack.times.push(point[1]);
+    }
+    return timeTracks;
+};
+export { timeTrackPluginDataToPointHeatInterpolatorAdapter };

package/dist/point-heat-map/index.js

@@ -0,0 +1 @@
+"use strict";