@pirireis/webglobeplugins 0.6.28-c → 0.6.30-c

package/bearing-line/plugin.js

@@ -5,7 +5,7 @@ import { CircleCache, EDGE_COUNT as flatCircleEdgeCount, centerCoords2dflatDataC
 import { BufferOrchestrator, BufferManager } from '../util/account';
 import { mapGetOrThrow } from "../util/check/get";
 import { populateFloat32Array } from "../util/jshelpers/data-filler";
-import { ContextTextWriter } from '../write-text/context-text'
+import { ContextTextWriter3 } from '../write-text/context-text3'
 
 
 export const RINGPARTIAL_DRAW_MODE = Object.freeze({
@@ -29,7 +29,7 @@ const constraintFloat = (x, lowerBound, upperBound) => {
  * @property {string} id
  * @property {function} coordsAdaptor
  * @property {function} textAdaptor
- * @property {ContextTextWriter} writer
+ * @property {ContextTextWriter3} writer
  * 
  */
 
@@ -40,7 +40,7 @@ export default class Plugin {
     /**
      * 
      * @param {*} id 
-     * @param {Map<[K ,{writer:ContextTextWriter, coordsAdaptor, textAdaptor}]} textContextInjectionMap  import { ContextTextWriter } from '@pirireis/webglobeplugins/write-text/context-text';
+     * @param {Map<[key, ContextTextWriter3]>} textContextInjectionMap
      *
      */
 
@@ -48,6 +48,7 @@ export default class Plugin {
         {
             opacity = 1,
             textContextInjectionMap = new Map(),
+            textDataPreAdaptor = null,
             drawVRM = true,
             drawBearingLine = true,
             drawAngleRing = true,
@@ -57,12 +58,15 @@ export default class Plugin {
         this.id = id;
         this._opacity = opacity;
         this.bufferOrchestrator = new BufferOrchestrator({ capacity: 10 });
-        this._checkTextContextInjectionMap(textContextInjectionMap);
+        this._checkTextContextWriterInjectionMap(textContextInjectionMap);
         this._textContextInjectionMap = textContextInjectionMap;
+        this._textContextInjectionMap.forEach((writer) => writer.keyAdaptor = (item) => item.key);
         this.drawVRM = drawVRM;
         this.drawBearingLine = drawBearingLine;
         this.drawAngleRing = drawAngleRing;
 
+        this._textDataPreAdaptor = textDataPreAdaptor;
+        this._memoryForText = new Map();
 
         this.drawText = drawText;
 
@@ -87,15 +91,8 @@ export default class Plugin {
         this.globe.DrawRender();
     }
 
-    _checkTextContextInjectionMap(textContextInjectionMap) {
-        if (!(textContextInjectionMap instanceof Map)) throw new TypeError("textContextInjectionMap is not instance of Map");
-        textContextInjectionMap.forEach((v) => {
-            if (typeof v !== 'object') throw new TypeError("textContextInjectionMap format is wrong");
-            if (typeof v.coordsAdaptor !== 'function') throw new TypeError("textContextInjectionMap coordsAdaptor format is wrong");
-            if (typeof v.textAdaptor !== 'function') throw new TypeError("textContextInjectionMap textAdaptor format is wrong");
-            if (!(v.writer instanceof ContextTextWriter)) throw new TypeError("textContextInjectionMap writer is not instance of ContextTextWriter");
-        })
-    }
+
+
 
     setDoDrawAngleRing(bool) {
         if (bool === this.drawAngleRing) return;
@@ -104,21 +101,13 @@ export default class Plugin {
     }
 
 
-    settextContextInjectionMap(textContextInjectionMap, data = null) {
-        this._textContextInjectionMap = textContextInjectionMap;
-        this._textContextInjectionMap.forEach(({ writer }) => writer.clear());
-        if (data) {
-            for (const item of data) {
-                this._insertTexts(item);
-            }
-        }
-    }
+
 
 
     setOpacity(opacity) {
         constraintFloat(opacity, 0, 1);
         this._opacity = opacity;
-        this._textContextInjectionMap.forEach(({ writer }) => writer.setOpacity(opacity));
+        this._textContextInjectionMap.forEach((writer) => writer.setOpacity(opacity));
         this.globe.DrawRender();
     }
 
@@ -277,6 +266,7 @@ export default class Plugin {
             ...["centerCoords3d", "bigRadius", "rgba", "circleDashAngle", "dashOpacity"].map(key => obj(this.bufferManagersCompMap.get(key)))
         );
 
+
     }
 
 
@@ -301,7 +291,7 @@ export default class Plugin {
             }
         }
         if (this.drawText) {
-            this._textContextInjectionMap.forEach((e) => { e.writer.draw(); });
+            this._textContextInjectionMap.forEach((writer) => writer.draw());
         }
         gl.enable(gl.DEPTH_TEST);
     }
@@ -323,29 +313,34 @@ export default class Plugin {
      * @property {number} dashOpacity 0-1
      * @property {number} circleDashAngle 0-360
      * @param {Array<item>} items 
-     * @param {Array<string>} textWriterInjectionSubSetIDs | textContextInjectionMap keys to be used for writing text.
+     * @param {Array<string>} textWriterIDs | textContextInjectionMap keys to be used for writing text.
      */
-    insertBulk(items, textWriterInjectionSubSetIDs = []) {
+    insertBulk(items, textWriterIDs = []) {
         const { globe, bufferOrchestrator, bufferManagersCompMap } = this;// angleTextContext, distanceTextContext,
-        const textWriterInjectionSubSets = textWriterGetOrThrow(this._textContextInjectionMap, textWriterInjectionSubSetIDs);
         const data = []
         for (let item of items) {
-            this._insertTexts(item, textWriterInjectionSubSets);
             data.push(this.__insertAdaptor(item));
         }
         bufferOrchestrator.insertBulk(data, bufferManagersCompMap);
-        this._textContextInjectionMap.forEach((v) => {
-            const { writer } = v;
-            writer.updateOpacityBulk(items, (e) => e.key, (e) => e.rgba[3]);
-        })
+        this.__insertTexts(items, textWriterIDs);
+
         globe.DrawRender();
     }
 
 
-
+    updateText(textWriterIDs) {
+        const textContextInjectionMap = textWriterGetOrThrow(this._textContextInjectionMap, textWriterIDs);
+        this._memoryForText.forEach((item) => {
+            textContextInjectionMap.forEach((writer) => writer.insertText(item));
+        });
+        this.globe.DrawRender();
+    }
 
     deleteBulk(keys) {
         this.bufferOrchestrator.deleteBulk(keys, this.bufferManagersCompMap);
+        for (const key of keys) {
+            this._memoryForText.delete(key);
+        }
         this._deleteTexts(keys);
         this.globe.DrawRender();
     }
@@ -355,20 +350,18 @@ export default class Plugin {
         this.bufferOrchestrator.defrag(this.bufferManagersCompMap);
     }
 
+
     /**
-     * 
      * @param {Array<{key, long, lat, endLong, endLat, bearingAngle}>} items
-     * @param {Array<string>} textWriterInjectionSubSetIDs | textContextInjectionMap keys to be used for writing text.
+     * @param {Array<string>} textWriterIDs | textContextInjectionMap keys to be used for writing text.
      */
-    updateCoordinatesBulk(items, textWriterInjectionSubSetIDs = []) {
-        const injectionsSubSet = textWriterGetOrThrow(this._textContextInjectionMap, textWriterInjectionSubSetIDs);;
+    updateCoordinatesBulk(items, textWriterIDs = []) {
         const { globe, bufferOrchestrator, bufferManagersCompMap, } = this;
         const data = []
         for (let item of items) {
-            this._insertTexts(item, injectionsSubSet);
             data.push(this.__updateCoordsAdaptor(item));
         }
-
+        this.__insertTexts(items, textWriterIDs);
         bufferOrchestrator.updateBulk(data, bufferManagersCompMap, ["centerCoords2d", "centerCoords3d", "targetCoords2d", "targetCoords3d", "startAngle", "tailAngle",
             "startAngle2d", "tailAngle2d", "startAngle3d", "tailAngle3d", "bearingTargetCoords2d", "bearingTargetCoords3d", "centerCoords2dflat",
             "bearingAngle", "bigRadius", "radius"]);
@@ -380,37 +373,46 @@ export default class Plugin {
      * 
      * @param {*} items some colums EXCEPT positional ones
      * @param {string} propertyIDs 
-     * @param {string} textWriterInjectionSubSetIDs 
+     * @param {string} textWriterIDs 
      * Do NOT send empty data if property ID of this data is entered or NaN is loaded to the buffer, resulting in an unwanted behaviour.
+     * textWriterIDs = []
      */
-    updatePartial(items, propertyIDs = [], textWriterInjectionSubSetIDs = []) { // textWriterInjectionSubSetIDs = []
+    updatePartial(items, propertyIDs = [], textWriterIDs = []) {
         if (propertyIDs.length === 0) console.warn("updatePartial is called with no target propertyIDs");
         const fixedPropertyIDs = this.__fixPartialProperties(propertyIDs)
-        const { _textContextInjectionMap, bufferOrchestrator, bufferManagersCompMap } = this;
-        const writers = textWriterGetOrThrow(this._textContextInjectionMap, textWriterInjectionSubSetIDs);
-        for (let item of items) { this._insertTexts(item, writers) }
+        const { bufferOrchestrator, bufferManagersCompMap } = this;
         bufferOrchestrator.updateBulk(items, bufferManagersCompMap, fixedPropertyIDs);
         // patch to update text opacity
-        for (const property of fixedPropertyIDs) {
-            if (property === "rgba") {
-                _textContextInjectionMap.forEach((v) => {
-                    const { writer } = v;
-                    writer.updateOpacityBulk(items, (e) => e.key, (e) => e.rgba[3]);
-                })
-            }
-        }
+        this.__insertTexts(items, textWriterIDs);
         this.globe.DrawRender();
     }
 
 
-    __insertAdaptor(item) {
+    _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");
+        });
+    }
+
 
+    __insertTexts(items, textWriterIDs) {
+        const textContextInjectionMap = textWriterGetOrThrow(this._textContextInjectionMap, textWriterIDs);
+        for (const item of items) {
+            const oldItem = this._memoryForText.get(item.key);
+            let _item = oldItem !== undefined ? { ...oldItem, ...item } : item;
+            if (this._textDataPreAdaptor !== null) _item = this._textDataPreAdaptor(_item);
+            this._memoryForText.set(item.key, _item);
+            textContextInjectionMap.forEach((writer) => writer.insertText(_item));
+        }
+    }
+
+    __insertAdaptor(item) {
         const rgba = item.rgba !== undefined ? item.rgba : [0, 0, 0, 0];
         const rgbaMode = item.rgbaMode !== undefined ? item.rgbaMode : 0;
         const dashRatio = item.dashRatio !== undefined ? item.dashRatio : 1.0;
         const dashOpacity = item.dashOpacity !== undefined ? item.dashOpacity : 0.9;
         const circleDashAngle = item.circleDashAngle !== undefined ? item.circleDashAngle : 360;
-
         const coordsData = this.__updateCoordsAdaptor(item);
 
         return {
@@ -502,24 +504,14 @@ export default class Plugin {
 
 
 
-    _insertTexts(item, textWriterInjectionSubSet) {
-        //TODO This method can be more performant if it works horizontally, tabular
-        textWriterInjectionSubSet.forEach((v) => {
-            const { coordsAdaptor, textAdaptor, writer } = v
-            const { lat, long } = coordsAdaptor(item);
-            const text = textAdaptor(item);
-            writer.insertText(item.key, lat, long, text);
-        });
-    }
-
-
     _deleteTexts(keys) {
-        this._textContextInjectionMap.forEach((e) => {
-            e.writer.deleteTextBulk(keys);
+        this._textContextInjectionMap.forEach((writer) => {
+            writer.deleteTextBulk(keys);
         });
     }
 
 
+
 }
 
 

package/package.json

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

package/programs/line-on-globe/degree-padding-around-circle-3d.js

@@ -2,12 +2,11 @@ import { createProgram } from "../../util/webglobjectbuilders";
 import { CameraUniformBlockString, CameraUniformBlockTotemCache } from "../totems/camerauniformblock";
 import { noRegisterGlobeProgramCache } from "../programcache";
 import { vaoAttributeLoader } from "../../util/account/util";
+import { Z_ALPHA_MODE } from "./util";
 import {
-    longLatRadToMercator, longLatRadToCartesian3D, cartesian3DToGLPosition, mercatorXYToGLPosition, realDistanceOnSphereR1,
+    cartesian3DToGLPosition,
     circleLimpFromLongLatRadCenterCartesian3D_accurate,
-    circleLimpFromLongLatRadCenterMercatorCompass_accurate,
-    circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate,
-    POLE
+    POLE,
 } from "../../util/shaderfunctions/geometrytransformations";
 
 
@@ -25,14 +24,8 @@ const INITIAL_EDGE_COUNT = 360;
 const vertexShaderSource = `#version 300 es
 precision highp float;
 ${CameraUniformBlockString}
-${longLatRadToMercator}
-${longLatRadToCartesian3D}
 ${cartesian3DToGLPosition}
-${mercatorXYToGLPosition}
-${realDistanceOnSphereR1}
 ${circleLimpFromLongLatRadCenterCartesian3D_accurate}
-${circleLimpFromLongLatRadCenterMercatorCompass_accurate}
-${circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate}
 
 
 in vec3 center_position3d;
@@ -42,6 +35,7 @@ in vec4 color;
 
 uniform float edge_count;
 uniform float step_angle;
+uniform int z_alpha_on;
 
 out float interpolation;
 out vec4 v_color;
@@ -49,6 +43,12 @@ void main() {
     if( !is3D) {
         return;
     }
+    v_color = color;
+    if ( z_alpha_on == 1 ){
+        float z_alpha = pow(z_level * 0.75, 3.0) * distance(big_radius, small_radius) / (R * 2.0);
+        if ( z_alpha < 0.1 ) { return; }
+        v_color.a *= z_alpha;
+    }
     int pad_phase =  gl_VertexID % 2; // 0 or 1
     interpolation = float( gl_VertexID - pad_phase) / edge_count;
     float angle = float( gl_VertexID - pad_phase) * step_angle;
@@ -59,7 +59,7 @@ void main() {
         position = circleLimpFromLongLatRadCenterCartesian3D_accurate(center_position3d, small_radius, angle);
     }
     gl_Position = cartesian3DToGLPosition(position);
-    v_color = color;
+
     gl_PointSize = 5.0;
 }`
 
@@ -87,13 +87,15 @@ class Logic {
         this._lastOpacity = 1.0;
         this._lastEdgeCount = INITIAL_EDGE_COUNT;
         this._lastStepAngle = 360 / INITIAL_EDGE_COUNT;
+        this._lastZAlphaMode = Z_ALPHA_MODE.ON;
         this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
 
         const { gl, program } = this;
         this.program.uniforms = {
             opacity: gl.getUniformLocation(program, "opacity"),
             edgeCount: gl.getUniformLocation(program, "edge_count"),
-            stepAngle: gl.getUniformLocation(program, "step_angle")
+            stepAngle: gl.getUniformLocation(program, "step_angle"),
+            zAlphaMode: gl.getUniformLocation(program, "z_alpha_on")
         };
 
         { // initial uniform values
@@ -102,6 +104,7 @@ class Logic {
             gl.uniform1f(program.uniforms.opacity, 1.0);
             gl.uniform1f(program.uniforms.edgeCount, INITIAL_EDGE_COUNT * 2);
             gl.uniform1f(program.uniforms.stepAngle, this._lastStepAngle * Math.PI / 180);
+            gl.uniform1i(program.uniforms.zAlphaMode, Z_ALPHA_MODE.ON);
             gl.useProgram(currentProgram);
         }
 
@@ -147,7 +150,7 @@ class Logic {
         return vao;
     }
 
-    draw(vao, length, edgeCount, stepAngle, opacity) {
+    draw(vao, length, edgeCount, stepAngle, opacity, zAlphaMode = Z_ALPHA_MODE.ON) {
         const { gl, program, cameraBlockTotem, cameraBindingPoint } = this;
         gl.useProgram(program);
 
@@ -163,6 +166,10 @@ class Logic {
             gl.uniform1f(program.uniforms.stepAngle, stepAngle * Math.PI / 180);
             this._lastStepAngle = stepAngle;
         }
+        if (this._lastZAlphaMode !== zAlphaMode) {
+            gl.uniform1i(program.uniforms.zAlphaMode, zAlphaMode);
+            this._lastZAlphaMode = zAlphaMode;
+        }
         gl.bindVertexArray(vao);
         cameraBlockTotem.bind(cameraBindingPoint);
         gl.drawArraysInstanced(gl.LINES, 0, edgeCount * 2, length);

package/programs/line-on-globe/lines-color-instanced-flat.js

@@ -3,17 +3,15 @@ import { mercatorXYToGLPosition, POLE } from "../../util/shaderfunctions/geometr
 import { noRegisterGlobeProgramCache } from "../programcache";
 import { createProgram } from "../../util";
 import { vaoAttributeLoader } from "../../util/account/util";
+import { Z_ALPHA_MODE } from "./util";
 
 /**
  * This program draws line between points provided from the first and second buffer.
  * draw method gl.drawArraysInstanced( gl.POINTS, 0,2, lineCount);
  * */
 
-const Z_ALPHA_MODE = Object.freeze({
-    ON: 1,
-    OFF: 0
-});
 
+// TODO: find better way to eleminate edge case distance(posA, posB) > 37000000.0
 const vertexShaderSource = `#version 300 es
 precision highp float;
 ${CameraUniformBlockString}
@@ -32,10 +30,11 @@ void main() {
     if ( is3D ) {
         return;
     }
-    float gap =  distance(posA, posB);
+    float gap = max( distance(posA.x, posB.x), distance(posA.y,posB.y)); // 
+    if ( gap > 37000000.0) { return; }
     float z_alpha;
-    if ( z_alpha_on == 1 || gap > 37000000.0){
-        z_alpha =  z_level * z_level /  ( gap / 100.0 );
+    if ( z_alpha_on == 1 ){ 
+        z_alpha =  pow(z_level,3.0) /  ( 37000000.0 / gap);
         if( z_alpha < 0.1 ) {return;}
         if( z_alpha > 1.0 ) {z_alpha = 1.0;}
     } else {
@@ -115,7 +114,7 @@ class Logic {
     }
 
 
-    draw(vao, lineCount, opacity = 1.0, zAlphaOn = Z_ALPHA_MODE.OFF) {
+    draw(vao, lineCount, opacity = 1.0, zAlphaOn = Z_ALPHA_MODE.ON) {
         const { gl, program, _cameraBindingPoint, _cameraUniformBlock } = this;
         gl.useProgram(program);
         _cameraUniformBlock.bind(_cameraBindingPoint);

package/programs/line-on-globe/util.js

@@ -0,0 +1,8 @@
+
+const Z_ALPHA_MODE = Object.freeze({
+    ON: 1,
+    OFF: 0
+});
+
+
+export { Z_ALPHA_MODE }

package/programs/util.js

@@ -1,6 +1,6 @@
 
 
-export function longlatbbox2normalbbox({ minLon = -180, maxLon = 180, minLat = -90, maxLat = 90 } = {}) {
+function longlatbbox2normalbbox({ minLon = -180, maxLon = 180, minLat = -90, maxLat = 90 } = {}) {
     // x
     const horOffset = (minLon) * Math.PI / 180;
     const horSize = (maxLon - minLon) * Math.PI / 180;
@@ -15,3 +15,6 @@ export function longlatbbox2normalbbox({ minLon = -180, maxLon = 180, minLat = -
     console.log("longlatbbox2normalbbox", result);
     return result;
 }
+
+
+export { longlatbbox2normalbbox }