@pirireis/webglobeplugins 0.15.35 → 0.16.0

package/dist/rangerings/rangeringangletext.js

@@ -0,0 +1,326 @@
+import { CSObjectArrayUpdateTypes, } from "@pirireis/webglobe";
+import { ENUM_HIDE, ENUM_TEXT_HIDE } from "./enum";
+const fidKey = "__fid__";
+const object = {
+    "displayName": "RangeRingAngleText",
+    "layerType": 3,
+    "wkbGeom": null,
+    "wfsLayerName": null,
+    "objectType": "point",
+    "bbox": null,
+    "startLod": 2,
+    "endLod": 30,
+    "continuousLOD": true,
+    "MVTXYZName": "hd_seyp",
+    "rasterize": false,
+};
+export default class RangeRingAngleText {
+    constructor(globe, id, { style = null, hideAll = false, opacity = 1 } = {}) {
+        this.globe = globe;
+        this.ObjectArray = globe.ObjectArray;
+        this.id = id;
+        this._hideAll = hideAll;
+        this._opacity = opacity;
+        const style_ = style !== null ? style : this.getDefaultStyle();
+        this.object = Object.assign({}, object, { style: style_, id: this.id });
+        this._centerCollection = new Map();
+        // new inner MAP params
+        // hide
+        // textHide
+        this.ObjectArray.Add(this.object);
+    }
+    getDefaultStyle() {
+        const style = this.ObjectArray.GetDefaultStyle();
+        style.fidKey = fidKey;
+        const { labels } = style;
+        const label = labels[0];
+        label.offset = { x: 0, y: 0 };
+        label.fontFamily.hollowWidth = 1;
+        label.vAlignment = 2;
+        label.hAlignment = 2;
+        label.size = 17;
+        // eslint-disable-next-line
+        label.text = "`${aci}`";
+        return style;
+    }
+    setStyle(style) {
+        if (style === null)
+            return;
+        style.opacity = this._opacity;
+        this.object.style = style;
+        this.ObjectArray.StyleChanged(this.object);
+    }
+    setOpacity(opacity) {
+        this._opacity = opacity;
+        const { style } = this.object;
+        style.opacity = opacity;
+        this.ObjectArray.StyleChanged(this.object);
+    }
+    free() {
+        this.flush();
+        this.ObjectArray.Delete(this.id);
+    }
+    /**
+     * @param {Array<{centerID,stepAngle, long,lat, rings>} ringDatas
+     * centerID: string | ObjectArray fidKey de kullanilir
+     * stepAngle: number | 0-360 arasinda
+     * long,lat: number | merkez koordinatlari lat long radian. Globe icin dereceye iceride cevrilir
+     * rings: Array<{radius: number}> | En buyuk halkaya centik acilari yazilir, Sonraki adim yaricaplarin uzunlugunu yazdirmak
+     *
+     * eger bir centerID zaten var ise: Onceki noktalar dusurulur ve yeniden eklenir
+     *
+     * */
+    insertBulk(ringDatas) {
+        const { _hideAll } = this;
+        const addBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        const deleteBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        for (const { centerID, long, lat, rings, stepAngle, hide = ENUM_HIDE.SHOW, textHide = ENUM_TEXT_HIDE.SHOW } of ringDatas) {
+            if (this._centerCollection.has(centerID)) {
+                this._fillDeleteBucket(centerID, deleteBucket);
+            }
+            const maxRadius = rings.reduce((acc, { radius }) => Math.max(acc, radius), 0);
+            const textHide_ = _hideAll ? ENUM_TEXT_HIDE.HIDE : textHide;
+            const show = hide !== ENUM_HIDE.HIDE && textHide_ === ENUM_TEXT_HIDE.SHOW;
+            if (show)
+                this._appendCircle(long, lat, maxRadius, stepAngle, centerID, addBucket);
+            this._centerCollection.set(centerID, new Map([
+                ["stepAngle", stepAngle],
+                ["maxRadius", maxRadius],
+                ["long", long],
+                ["lat", lat],
+                ["hide", hide],
+                ["textHide", textHide_]
+            ]));
+        }
+        if (this._hideAll)
+            return;
+        if (deleteBucket.coords.length > 0)
+            this._updateData(deleteBucket, CSObjectArrayUpdateTypes.DELETE);
+        if (addBucket.coords.length > 0)
+            this._updateData(addBucket, CSObjectArrayUpdateTypes.ADD);
+    }
+    /**
+     * @param {Array<{centerID, x,y}>} centerDatas
+     * aci ve radiuslarin tutulmasi gereklidir.
+     * */
+    updateCentersXY(centerDatas) {
+        const updateBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        for (const { centerID, long, lat } of centerDatas) {
+            if (this._centerCollection.has(centerID)) {
+                const centerMap = this._centerCollection.get(centerID);
+                centerMap.set("long", long);
+                centerMap.set("lat", lat);
+                const hide = centerMap.get("hide");
+                const textHide = centerMap.get("textHide");
+                const isHidden = hide === ENUM_HIDE.HIDE || textHide === ENUM_TEXT_HIDE.HIDE;
+                if (isHidden)
+                    continue;
+                const maxRadius = centerMap.get("maxRadius");
+                const stepAngle = centerMap.get("stepAngle");
+                // long, lat, radius, step, centerID, outBucket
+                this._appendCircle(long, lat, maxRadius, stepAngle, centerID, updateBucket);
+            }
+        }
+        // for (const attribs of updateBucket.attribs) {
+        //     delete attribs["aci"];
+        // }
+        if (updateBucket.coords.length > 0) {
+            this._updateData(updateBucket, CSObjectArrayUpdateTypes.UPDATE);
+        }
+    }
+    /**
+     *
+     * @param {Array<{centerID:string, hide: bool}>} centerHides
+     */
+    updateCentersHide(centerHides) {
+        if (this._hideAll) {
+            console.warn("Tum mesafe halkasi yazilari gizli durum. Islem yapilamaz");
+            return;
+        }
+        ;
+        const addBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        const deleteBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        for (const { centerID, textHide = null, hide = null } of centerHides) {
+            if (!this._centerCollection.has(centerID))
+                continue;
+            const centerMap = this._centerCollection.get(centerID);
+            const isHidden = centerMap.get("hide") === ENUM_HIDE.HIDE || centerMap.get("textHide") === ENUM_TEXT_HIDE.HIDE;
+            const _hide = hide !== null ? hide : centerMap.get("hide");
+            const _textHide = textHide !== null ? textHide : centerMap.get("textHide");
+            const show = (_hide !== ENUM_HIDE.HIDE) && (_textHide === ENUM_TEXT_HIDE.SHOW);
+            if (!isHidden && !show) {
+                this._fillDeleteBucket(centerID, deleteBucket);
+            }
+            else if (isHidden && show) {
+                this._appendCircle(centerMap.get("long"), centerMap.get("lat"), centerMap.get("maxRadius"), centerMap.get("stepAngle"), centerID, addBucket);
+            }
+            if (hide !== null)
+                centerMap.set("hide", hide);
+            if (textHide !== null)
+                centerMap.set("textHide", textHide);
+        }
+        if (deleteBucket.coords.length > 0)
+            this._updateData(deleteBucket, CSObjectArrayUpdateTypes.DELETE);
+        if (addBucket.coords.length > 0)
+            this._updateData(addBucket, CSObjectArrayUpdateTypes.ADD);
+    }
+    // TODO : Implement this
+    removeCenters(centerIDs) {
+        const deleteBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        for (const centerID of centerIDs) {
+            if (this._centerCollection.has(centerID)) {
+                this._fillDeleteBucket(centerID, deleteBucket);
+                this._centerCollection.delete(centerID);
+            }
+        }
+        this._updateData(deleteBucket, CSObjectArrayUpdateTypes.DELETE);
+    }
+    hideAll() {
+        this._hideAll = true;
+        const deleteBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        for (const [centerID, centerMap] of this._centerCollection) {
+            const hide = centerMap.get("hide");
+            const hideText = centerMap.get("textHide");
+            centerMap.set("textHide", ENUM_TEXT_HIDE.HIDE);
+            if (hide === ENUM_HIDE.HIDE)
+                continue;
+            const isHidden = hideText === ENUM_TEXT_HIDE.HIDE;
+            if (!isHidden)
+                this._fillDeleteBucket(centerID, deleteBucket);
+        }
+        this._updateData(deleteBucket, CSObjectArrayUpdateTypes.DELETE);
+    }
+    showAll() {
+        this._hideAll = false;
+        const addBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        for (const [centerID, centerMap] of this._centerCollection) {
+            const hide = centerMap.get("hide");
+            if (hide === ENUM_HIDE.HIDE)
+                continue;
+            const hideText = centerMap.get("textHide");
+            const isHidden = hideText === ENUM_TEXT_HIDE.HIDE;
+            if (isHidden) {
+                const long = centerMap.get("long");
+                const lat = centerMap.get("lat");
+                const maxRadius = centerMap.get("maxRadius");
+                const stepAngle = centerMap.get("stepAngle");
+                this._appendCircle(long, lat, maxRadius, stepAngle, centerID, addBucket);
+                centerMap.set("hide", ENUM_HIDE.SHOW);
+                centerMap.set("textHide", ENUM_TEXT_HIDE.SHOW);
+            }
+        }
+        if (addBucket.coords.length)
+            this._updateData(addBucket, CSObjectArrayUpdateTypes.ADD);
+    }
+    flush() {
+        const data = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        this._idCollector = new Set();
+        this.ObjectArray.SetData(this.object, data);
+    }
+    //------------------PRIVATE METHODS------------------//
+    _appendCircle(long, lat, radius, step, centerID, outBucket) {
+        this.__realCoords(long, lat, radius, step, centerID, outBucket);
+    }
+    __realCoords(longCenter, latCenter, radius, stepAngle, centerID, outBucket) {
+        const { globe } = this;
+        const { coords, coordsZ, attribs } = outBucket;
+        let i = 1;
+        for (let aci = stepAngle; aci < 360; aci += stepAngle) {
+            const { long, lat } = globe.Math.FindPointByPolar(longCenter, latCenter, radius, aci);
+            coords.push(long, lat);
+            coordsZ.push(0);
+            const key = this._key(centerID, i);
+            i++;
+            // fidkey is the key
+            attribs.push({
+                "__fid__": key,
+                "aci": (aci).toFixed(0).toString().padStart(3, '0')
+            });
+        }
+        { // add 0
+            const { long, lat } = globe.Math.FindPointByPolar(longCenter, latCenter, radius, 0);
+            coords.push(long, lat);
+            coordsZ.push(0);
+            const key = this._key(centerID, 0);
+            // fidkey is the key
+            attribs.push({
+                "__fid__": key,
+                "aci": "K"
+            });
+        }
+    }
+    _updateData(bucket, mode) {
+        this.ObjectArray.UpdateData(this.object, mode, [bucket], { attribs: false, icon: false, text: false });
+    }
+    _key(centerRingKey, limpIndex) {
+        return `${centerRingKey}_${limpIndex}`;
+    }
+    _fillDeleteBucket(centerID, outDeleteBucket) {
+        const centerMap = this._centerCollection.get(centerID);
+        const stepAngle = centerMap.get("stepAngle");
+        const { coords, coordsZ, attribs } = outDeleteBucket;
+        let i = 0;
+        for (let aci = 0; aci < 360; aci += stepAngle) {
+            const key = this._key(centerID, i++);
+            coords.push(0, 0);
+            coordsZ.push(0);
+            attribs.push({
+                "__fid__": key,
+            });
+        }
+    }
+    _updateAll() {
+        const updateBucket = {
+            coords: [],
+            coordsZ: [],
+            attribs: []
+        };
+        for (const [centerID, centerMap] of this._centerCollection) {
+            const isHidden = centerMap.get("hide") === ENUM_HIDE.HIDE || centerMap.get("textHide") === ENUM_TEXT_HIDE.HIDE;
+            if (isHidden)
+                continue;
+            const long = centerMap.get("long");
+            const lat = centerMap.get("lat");
+            const maxRadius = centerMap.get("maxRadius");
+            const stepAngle = centerMap.get("stepAngle");
+            this._appendCircle(long, lat, maxRadius, stepAngle, centerID, updateBucket);
+        }
+        this._updateData(updateBucket, CSObjectArrayUpdateTypes.UPDATE);
+    }
+}

package/dist/rangerings/ring-account.js

@@ -0,0 +1,112 @@
+/**
+ * This account interacts with buffer orchestrations and buffers.
+ * For rings, coordinates and paddings
+ */
+const ringKeyMethod = (centerID, ringID) => `${centerID}_${ringID}`;
+const ringBigPaddingKeyMethod = (centerID, ringID, angle) => `${centerID}_${ringID}_${angle}`;
+/**
+ * @typedef { Array < { ringID, radius, paddingRange } >} rings
+ * @param { Array < centerID: string, x: number, y: number, stepAngle: number, rgba: [4 numbers], rings: rings } items
+ */
+class RingAccount {
+    constructor() {
+        this._centralMap = new Map(); // key, new MAP(x,y, rings:[])
+    }
+    /**
+     * @typedef {centerID, long,lat, rings} centralItem
+     *
+     */
+    insertCenter(centralItem) {
+        centralItem.rings.forEach((ring) => {
+            ring.__identity__ = ringKeyMethod(centralItem.centerID, ring.ringID);
+        });
+        this._centralMap.set(centralItem.centerID, {
+            ...centralItem,
+            rgba: new Float32Array(centralItem.rgba),
+        });
+    }
+    getCenter(centerID) {
+        return this._centralMap.get(centerID);
+    }
+    updateCentersCoordinate(items) {
+        for (const { centerID, long, lat } of items) {
+            const center = this.getCenter(centerID);
+            if (center) {
+                center.long = long;
+                center.lat = lat;
+            }
+        }
+    }
+    updateCentersHide(items) {
+        for (const { centerID, hide = null, textHide = null } of items) {
+            const center = this.getCenter(centerID);
+            if (center) {
+                if (hide !== null)
+                    center.hide = hide;
+                if (textHide !== null)
+                    center.textHide = textHide;
+            }
+        }
+    }
+    /**
+     *
+     * @param {Array<{centerID, rgba}>} centersColor
+     */
+    updateCentersColor(centersColor) {
+        for (const { centerID, rgba } of centersColor) {
+            const center = this.getCenter(centerID);
+            if (center) {
+                center.rgba = new Float32Array(rgba);
+            }
+        }
+    }
+    // to delete rings and one degree paddings from buffer  
+    ringKeys(centerID) {
+        const result = [];
+        const center = this.getCenter(centerID);
+        if (center) {
+            const rings = center.rings;
+            for (const { __identity__ } of rings) {
+                result.push(__identity__);
+            }
+        }
+        return result;
+    }
+    // To delete big paddings from buffer
+    ringBigPaddingKeys(centerID) {
+        const result = [];
+        const center = this.getCenter(centerID);
+        if (!center)
+            return [];
+        const { rings, stepAngle } = center;
+        for (const { ringID } of rings) {
+            let angle = 0;
+            while (angle < 360) {
+                result.push(ringBigPaddingKeyMethod(centerID, ringID, angle));
+                angle += stepAngle;
+            }
+        }
+        return result;
+    }
+    removeCenters(centerIDs) {
+        const centralMap = this._centralMap;
+        centerIDs.forEach((centerID) => {
+            centralMap.delete(centerID);
+        });
+    }
+    textUpdate(centerID, textWriterObjs, dataPreAdaptor = null) {
+        const center = this.getCenter(centerID);
+        if (!center)
+            return;
+        const data = (dataPreAdaptor) ? dataPreAdaptor(center) : center;
+        textWriterObjs.forEach((writer) => {
+            writer.insertTextBulk(data.rings, data);
+        });
+    }
+    updateAllText(textWriterObjs, dataPreAdaptor = null) {
+        this._centralMap.forEach((center) => {
+            this.textUpdate(center.centerID, textWriterObjs, dataPreAdaptor);
+        });
+    }
+}
+export { RingAccount, ringKeyMethod, ringBigPaddingKeyMethod };

package/dist/semiplugins/shape-on-terrain/terrain-cover/texture-dem-cover.js

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

package/dist/shaders/fragment-toy/firework.js

@@ -0,0 +1,55 @@
+export const firework = `
+float firework(vec2 point_coord, float phase) {
+    float t = phase + 5.0;
+    float z = 6.0;
+    const int n = 53; // particle count
+
+    vec3 startColor = vec3(0.0, 0.64, 0.2);
+    vec3 endColor = vec3(0.06, 0.35, 0.85);
+
+    float startRadius = 0.84;
+    float endRadius = 1.6;
+
+    float power = 0.51;
+    float duration = 4.0;
+
+    vec2 v = z * (2.0 * point_coord - vec2(1.0) );
+
+    vec3 col = vec3(0.0);
+    vec2 pm = v.yx * 2.8;
+
+    float dMax = duration;
+    float evo = (sin(phase * 0.01 + 400.0) * 0.5 + 0.5) * 99.0 + 1.0;
+
+    float mb = 0.0;
+    float mbRadius = 0.0;
+    float sum = 0.0;
+
+    for(int i = 0; i < n; i++) {
+        float d = fract(t * power + 48934.4238 * sin(float(i / int(evo)) * 692.7398));
+
+        float a = 6.28 * float(i) / float(n);
+        float x = d * cos(a) * duration;
+        float y = d * sin(a) * duration;
+
+        float distRatio = d / dMax;
+        mbRadius = mix(startRadius, endRadius, distRatio);
+
+        vec2 p = v - vec2(x, y);
+        mb = mbRadius / dot(p, p);
+
+        sum += mb;
+        col = mix(col, mix(startColor, endColor, distRatio), mb / sum);
+    }
+
+    sum /= float(n);
+    col = normalize(col) * sum;
+    sum = clamp(sum, 0.0, 0.4);
+
+    vec3 tex = vec3(1.0);
+    col *= smoothstep(tex, vec3(0.0), vec3(sum));
+
+    float alpha = sum * 2.5;
+    return clamp(alpha, 0.0, 1.0);
+}
+`;

package/dist/shaders/fragment-toy/singularity.js

@@ -0,0 +1,56 @@
+const singularity = `
+
+vec3 palette(float d){
+    return mix(vec3(0.2, 0.7, 0.9), vec3(1.0, 0.0, 1.0), d);
+}
+
+vec2 rotate(vec2 p, float a){
+    float c = cos(a);
+    float s = sin(a);
+    return p * mat2(c, s, -s, c);
+}
+
+float map(vec3 p){
+    for (int i = 0; i < 4; ++i){
+        float t = u_phase * 0.2;
+        p.xz = rotate(p.xz, t);
+        p.xy = rotate(p.xy, t * 1.89);
+        p.xz = abs(p.xz);
+        p.xz -= 0.85;
+    }
+    return dot(sign(p), p) / 5.0;
+}
+
+vec4 rm(vec3 ro, vec3 rd){
+    float t = 0.0;
+    vec3 col = vec3(0.0);
+    float d;
+    for (float i = 0.0; i < 56.0; i++){
+        vec3 p = ro + rd * t;
+        d = map(p) * 0.5;
+        if (d < 0.02){
+            break;
+        }
+        if (d > 100.0){
+            break;
+        }
+        col += palette(length(p) * 0.1) / (400.0 * d);
+        t += d;
+    }
+    return vec4(col, 1.0 / d * 2.0 );
+}
+
+vec4 singularity(vec2 pointCoord, float u_phase) {
+    vec2 uv = (pointCoord - 0.5); // Normalized coordinates from gl_PointCoord
+    vec3 ro = vec3(0.0, 0.0, -50.0);
+    ro.xz = rotate(ro.xz, u_phase);
+    vec3 cf = normalize(-ro);
+    vec3 cs = normalize(cross(cf, vec3(0.0, 1.0, 0.0)));
+    vec3 cu = normalize(cross(cf, cs));
+
+    vec3 uuv = ro + cf * 3.0 + uv.x * cs + uv.y * cu;
+    vec3 rd = normalize(uuv - ro);
+
+    return rm(ro, rd);
+}`;
+export { singularity };

package/dist/timetracks/adaptors-line-strip.js

@@ -0,0 +1,65 @@
+import { latLongToPixelXY } from "../util";
+/**
+ * @param {Array.<Array.<number>>} coordinates
+ * @param {Array.<number>} timestamps
+ * @param {Array.<String>} styleGroupNameArray
+ * @param {Object.<string, TrackStyleGroup>} _groupColorMap
+ * @param {Float32Array} floatArray
+ * @param {number} offset
+ *
+ * create floatArray with createFloat32Array before calling this function.
+ * start offset from 0.
+ * feed the floatArray with a track data and offset that is returned from the previous call.
+ */
+function featuresToLineStringData(data) {
+    /**
+     * features are the tracks
+     * feature[i].geometry.coordinates are the points of the track
+     * feature[i].properties.messageTime are the timestamps of the points
+     *
+     */
+    const features = data.features;
+    let size = data.features.length - 1;
+    let startTime = features[0].properties.messageTime[0];
+    let endTime = features[0].properties.messageTime[features[0].properties.messageTime.length - 1];
+    for (let feature of features) {
+        size += feature.properties.messageTime.length;
+        startTime = Math.min(startTime, feature.properties.messageTime[0]);
+        endTime = Math.max(endTime, feature.properties.messageTime[feature.properties.messageTime.length - 1]);
+    }
+    const array = new Float32Array(size * 9);
+    let offset = 0;
+    {
+        const feature = features[0];
+        const coordinates = feature.geometry.coordinates;
+        const timestamps = feature.properties.messageTime.map((time) => (time - startTime) / 1000);
+        offset = fillSliceOfFloat32ArrayLineStrip(array, offset, coordinates, timestamps);
+    }
+    for (let i = 1; i < features.length; i++) {
+        const feature = features[i];
+        const coordinates = feature.geometry.coordinates;
+        const timestamps = feature.properties.messageTime.map((time) => (time - startTime) / 1000);
+        offset = addCuttingPointLineStrip(array, offset);
+        offset = fillSliceOfFloat32ArrayLineStrip(array, offset, coordinates, timestamps);
+    }
+    return { data: array, startTime, endTime };
+}
+function fillSliceOfFloat32ArrayLineStrip(floatArray, offset, coordinates, timestamps, { styleGroupNameArray = null, groupColorFunction = () => [Math.random(), Math.random(), Math.random()] } = {}) {
+    const startTime = timestamps[0];
+    const endTime = timestamps[timestamps.length - 1];
+    for (let i = 0; i < coordinates.length; i++) {
+        const time = timestamps[i];
+        const coord = coordinates[i];
+        const styleGroupName = styleGroupNameArray ? styleGroupNameArray[i] : "default";
+        const { x, y } = latLongToPixelXY(coord[1], coord[0]);
+        const z = coord[2] ? coord[2] / 1000.0 : 0;
+        floatArray.set([x, y, z, time, ...groupColorFunction(styleGroupName), startTime, endTime], offset);
+        offset += 9;
+    }
+    return offset;
+}
+function addCuttingPointLineStrip(floatArray, offset) {
+    floatArray.set(new Float32Array(9).fill(NaN), offset);
+    return offset + 9;
+}
+export { addCuttingPointLineStrip, featuresToLineStringData, fillSliceOfFloat32ArrayLineStrip, latLongToPixelXY };

package/dist/timetracks/index.js

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