@pirireis/webglobeplugins 0.15.22-alpha → 0.15.25

package/wind/plugin.js

@@ -2,7 +2,7 @@
  * Author: Toprak Nihat Deniz Ozturk
  */
 import * as util from "../util";
-import imageToMagnitude from "./imagetovectorfieldandmagnitude";
+import imageToMagnitude, { imageToRadianAngle } from "./imagetovectorfieldandmagnitude";
 import { TexturePointSampler } from "../util/heatwavedatamanager/texture-point-sampler";
 /**
  * Shader Dökümanı:
@@ -54,6 +54,9 @@ varying vec2 v_tex_pos;
 void main() {
     vec4 color = texture2D(u_screen, 1.0 - v_tex_pos);
     // a hack to guarantee opacity fade out even with a value close to 1.0
+    if ( color.a < 0.005) {
+        discard;
+    }
     gl_FragColor = vec4( floor(255.0 * color * u_opacity) / 255.0);
 }
 
@@ -82,15 +85,15 @@ float rand(const vec2 co) {
 
 // wind speed lookup; use manual bilinear filtering based on 4 adjacent pixels for smooth interpolation
 vec2 lookup_wind(const vec2 uv) {
-    // return texture2D(u_wind, uv).rg; // lower-res hardware filtering
-    vec2 px = 1.0 / u_wind_res;
-    vec2 vc = (floor(uv * u_wind_res)) * px;
-    vec2 f = fract(uv * u_wind_res);
-    vec2 tl = texture2D(u_wind, vc).rg;
-    vec2 tr = texture2D(u_wind, vc + vec2(px.x, 0)).rg;
-    vec2 bl = texture2D(u_wind, vc + vec2(0, px.y)).rg;
-    vec2 br = texture2D(u_wind, vc + px).rg;
-    return mix(mix(tl, tr, f.x), mix(bl, br, f.x), f.y);
+    return texture2D(u_wind, uv).rg; // lower-res hardware filtering
+    // vec2 px = 1.0 / u_wind_res;
+    // vec2 vc = (floor(uv * u_wind_res)) * px;
+    // vec2 f = fract(uv * u_wind_res);
+    // vec2 tl = texture2D(u_wind, vc).rg;
+    // vec2 tr = texture2D(u_wind, vc + vec2(px.x, 0)).rg;
+    // vec2 bl = texture2D(u_wind, vc + vec2(0, px.y)).rg;
+    // vec2 br = texture2D(u_wind, vc + px).rg;
+    // return mix(mix(tl, tr, f.x), mix(bl, br, f.x), f.y);
 }
 
 void main() {
@@ -218,13 +221,16 @@ void main() {
         color.r / 255.0 + color.b,
         color.g / 255.0 + color.a);
     
-
-    if ( v_particle_pos.y < 0.0265 || v_particle_pos.y > 0.9735 ) {
+    
+    // if ( v_particle_pos.y < 0.0265 || v_particle_pos.y > 0.9735 ) {
+    float y = v_particle_pos.y - 0.0055;//a
+    if ( y > 0.9735 || y < 0.0265 ) {
         gl_Position = vec4(-2.0, -2.0, -2.0, 1.0);
         return;
     }
-    vec3 pos = u_bbox_matrix * vec3(v_particle_pos.x, v_particle_pos.y, 1.0);
-    
+    // vec3 pos = u_bbox_matrix * vec3(v_particle_pos.x, v_particle_pos.y, 1.0);
+    vec3 pos = u_bbox_matrix * vec3(v_particle_pos.x, y, 1.0);
+
 
     float xRad = PI * (2.0 * pos.x - 1.0);
     float yRad = pos.y * PI;
@@ -267,12 +273,12 @@ void main() {
     v_particle_pos = vec2(
         color.r / 255.0 + color.b,
         color.g / 255.0 + color.a);
-
-    if ( v_particle_pos.y < 0.0265 || v_particle_pos.y > 0.9735 ) {
+    float y = v_particle_pos.y - 0.0055;//a
+    if ( y < 0.0265 || y > 0.9735 ) {
         gl_Position = vec4(-2.0, -2.0, -2.0, 1.0);
         return;
     }
-    vec3 pos = u_bbox_matrix * vec3(v_particle_pos.x, v_particle_pos.y, 1.0);
+    vec3 pos = u_bbox_matrix * vec3(v_particle_pos.x, y, 1.0);
     
     float x = (2.0 * pos.x - 1.0);
     float mercator_x = x * POLE;
@@ -505,6 +511,7 @@ export default class WindPlugin {
         gl.uniform2f(this.updateProgram.u_wind_min, this.windData.uMin, this.windData.vMin);
         gl.uniform2f(this.updateProgram.u_wind_max, this.windData.uMax, this.windData.vMax);
         this.setGeometry();
+        console.log("windData bbox", windData.bbox);
         const minXY = this._latLongToPixelXY(windDataMeta.bbox[1], windDataMeta.bbox[0]);
         const maxXY = this._latLongToPixelXY(windDataMeta.bbox[3], windDataMeta.bbox[2]);
         this._loadBoundingBoxData(minXY.x, minXY.y, maxXY.x, maxXY.y);
@@ -531,22 +538,49 @@ export default class WindPlugin {
             this.setWind(windData);
         };
     }
-    getTexturePointSampler() {
-        if (!this.texturePointSampler)
-            this._createTexturePointSampler();
-        return this.texturePointSampler;
+    /**
+     * @param
+     * @returns
+     */
+    getTexturePointSampler(type = `magnitude`) {
+        if (type == `magnitude`) {
+            if (!this.texturePointSampler) {
+                this._createTexturePointSampler();
+                this._setCoorcinatesDataCalculatorData();
+            }
+            return this.texturePointSampler;
+        }
+        else if (type == `angle`) {
+            if (!this.texturePointSamplerAngle) {
+                this._createTexturePointSamplerAngle();
+                this._setCoorcinatesDataCalculatorData();
+            }
+            return this.texturePointSamplerAngle;
+        }
+        else {
+            throw new Error(`WindPlugin.getTexturePointSampler: type must be either 'magnitude' or 'angle'.`);
+        }
+    }
+    _createTexturePointSamplerAngle() {
+        const { bbox, width, height } = this._windDataMeta;
+        this.texturePointSamplerAngle = new TexturePointSampler(bbox, width, height);
     }
     _createTexturePointSampler() {
         const { bbox, width, height } = this._windDataMeta;
         this.texturePointSampler = new TexturePointSampler(bbox, width, height);
-        this._setCoorcinatesDataCalculatorData();
     }
     _setCoorcinatesDataCalculatorData() {
-        if (!this.windData || !this.texturePointSampler) {
+        if (!this.windData) {
             return;
         }
-        const magnitude = imageToMagnitude(this.windData);
-        this.texturePointSampler.updateTextureData(0, magnitude, magnitude);
+        if (this.texturePointSamplerAngle) {
+            const angle = imageToRadianAngle(this.windData);
+            this.texturePointSamplerAngle.updateTextureData(0, angle, angle);
+        }
+        if (this.texturePointSampler) {
+            const magnitude = imageToMagnitude(this.windData);
+            this.texturePointSampler.updateTextureData(0, magnitude, magnitude);
+        }
     }
     // -----------------------------------------------
     //             --- inner methods ---

package/write-text/context-text4.js

@@ -0,0 +1,140 @@
+// @ts-ignore
+import { CSZMode } from "@pirireis/webglobe";
+import { isTextFont, opacityCheck } from "../util/check/typecheck";
+/**
+ * TODOs:
+ * 1) update all if initials change (propably need a context and a callback to iterate over zPayload)
+ * 2) expose a mechanic to update text on zoom change
+ * 3) extend the mechanic on 2 to other events
+ *
+ * TODO: key check and raise error if doesnt exist
+ */
+const defaultStyle = {
+    textFont: {
+        name: 'Arial',
+        textColor: '#FFFFFF', // beyaz
+        hollowColor: '#000000', // siyah
+        size: 12, // piksel
+        hollow: true,
+        bold: true,
+        italic: false,
+    },
+    opacity: 1.0,
+    zMode: CSZMode.Z_GROUND_PERVERTEX,
+};
+// xOffset = 0,
+// yOffset = 0,
+// doDraw = true,
+// textAdaptor = null,
+// coordinatesAdaptor = null,
+// keyAdaptor = null,
+// opacityAdaptor = null,
+// angleAdaptor = null,
+// angleOnSphere = false,
+// positionAdaptor = (item: any, i: number, container: any[], properties?: any): string => "left",
+export class ContextTextWriter4 {
+    globe;
+    itemMap;
+    style;
+    doDraw;
+    textAdaptor;
+    deleteAdaptor;
+    zoomLevelAdaptor;
+    xOffset;
+    yOffset;
+    angleOptions;
+    constructor(globe, textAdaptor, deleteAdaptor, zoomLevelAdaptor = (zoomLevel) => (item) => {
+        return {
+            opacityMultiplier: 1,
+            sizeMultiplier: 1
+        };
+    }, style = defaultStyle, angleOptions = {
+        angleOnSphere: false,
+        angleIsOn: false
+    }, doDraw = true, offset = { x: 0, y: 0 }) {
+        this.globe = globe;
+        this.itemMap = new Map();
+        this.setStyle(style);
+        this.angleOptions = angleOptions;
+        this.doDraw = doDraw;
+        this.style = style;
+        this.angleOptions = angleOptions;
+        this.textAdaptor = textAdaptor;
+        this.deleteAdaptor = deleteAdaptor;
+        this.zoomLevelAdaptor = zoomLevelAdaptor;
+        this.xOffset = offset.x;
+        this.yOffset = offset.y;
+    }
+    setDoDraw(bool) {
+        this.doDraw = bool;
+        this.globe.DrawRender();
+    }
+    setStyle(style) {
+        isTextFont(style.textFont);
+        opacityCheck(style.opacity); //TODO: use shallow copy
+        this.style = style;
+        this.globe.DrawRender();
+    }
+    setOpacity(opacity) {
+        this.style.opacity = opacity;
+        this.globe.DrawRender();
+    }
+    draw() {
+        if (!this.doDraw)
+            return;
+        const { globe, style, itemMap, xOffset, yOffset } = this;
+        const { textFont, opacity: opacity_ } = style;
+        const textSize = textFont.size;
+        const is3D = globe.api_GetCurrentGeometry() === 0;
+        const angleIsOn = is3D ? (this.angleOptions.angleIsOn && this.angleOptions.angleOnSphere) : (this.angleOptions.angleIsOn);
+        const zoomLevel = globe.api_GetCurrentLODWithDecimal();
+        const zoomAdaptor = this.zoomLevelAdaptor(zoomLevel);
+        for (const item of itemMap.values()) {
+            const { lat, long, text, opacity = null, angle = null, zPayload, position } = item;
+            const { x, y } = globe.api_GetScreenPointFromGeo({
+                long: long,
+                lat: lat,
+                z: 0,
+            }, style.zMode === CSZMode.Z_MSL);
+            const { opacityMultiplier, sizeMultiplier } = zoomAdaptor(zPayload);
+            const o = (opacity === null ? opacity_ : opacity * opacity_) * opacityMultiplier;
+            textFont.size = sizeMultiplier * textSize;
+            textFont.position = position;
+            if (x !== null && y !== null)
+                globe.api_DrawContextTextMultiLine(text, textFont, o, { x: x + xOffset, y: y - yOffset }, angleIsOn, angle);
+        }
+        textFont.size = textSize;
+    }
+    insertText(data) {
+        const textDatas = this.textAdaptor(data);
+        for (const textData of textDatas) {
+            this.itemMap.set(textData.key, textData);
+        }
+    }
+    insertTextBulk(datas) {
+        for (const data of datas) {
+            this.insertText(data);
+        }
+    }
+    deleteText(data) {
+        const key = this.deleteAdaptor ? this.deleteAdaptor(data) : data;
+        if (this.itemMap.has(key)) {
+            this.itemMap.delete(key);
+        }
+    }
+    deleteTextBulk(datas) {
+        for (const data of datas) {
+            this.deleteText(data);
+        }
+    }
+    setOffsets(x, y) {
+        this.xOffset = x;
+        this.yOffset = y;
+    }
+    clear() {
+        this.itemMap.clear();
+    }
+    free() {
+        this.itemMap = null;
+    }
+}