@pirireis/webglobeplugins 0.6.30-c → 0.6.32-a

package/timetracks/program.js

@@ -63,12 +63,12 @@ export default class TrackGlowLineProgram {
         gl.useProgram(_blurProgram.program);
         gl.uniform1fv(_blurProgram.u_weight, options.weights || [1, 0.45045946, 0.2216216, 0.154054, 0.056216]);
         gl.uniform1f(_blurProgram.u_alpha_threshold, options.alphaThreshold || 0.0);
+        gl.uniform1i(_blurProgram.u_glow, 1);
 
         gl.useProgram(_combineProgram.program);
         gl.uniform1f(_combineProgram.u_exposure, options.exposure || 1.0);
         gl.uniform1f(_combineProgram.u_gamma, options.gamma || 1.0);
         gl.uniform1f(_combineProgram.u_final_alpha_ratio, options.finalAlphaRatio || 1.0);
-        gl.uniform1i(_blurProgram.u_glow, 1);
         gl.useProgram(currentProgram);
     }
 
@@ -302,130 +302,130 @@ export default class TrackGlowLineProgram {
         const gl = this.gl;
 
         const vertexShader = `#version 300 es
-        precision highp float;
+precision highp float;
 
-        in vec2 a_position;
-        out vec2 v_texcoord;
+in vec2 a_position;
+out vec2 v_texcoord;
 
-        void main() {
-            gl_Position = vec4(a_position, 0.0, 1.0);
-            v_texcoord = a_position.xy * 0.5 + 0.5;
-        }
-        `;
+void main() {
+    gl_Position = vec4(a_position, 0.0, 1.0);
+    v_texcoord = a_position.xy * 0.5 + 0.5;
+}
+`;
         const fragmentShader = `#version 300 es
-        precision highp float;
-        
-        in vec2 v_texcoord;
-        
-        uniform sampler2D u_texture;
-        uniform bool u_horizontal;
-        uniform float u_weight[5];
-        uniform float u_alpha_threshold;
-        uniform bool u_glow;
-        out vec4 outColor;
+precision highp float;
+
+in vec2 v_texcoord;
+
+uniform sampler2D u_texture;
+uniform bool u_horizontal;
+uniform float u_weight[5];
+uniform float u_alpha_threshold;
+uniform bool u_glow;
+out vec4 outColor;
+
+void main()
+{             
+    vec2 tex_offset = vec2( 
+        1.0 / float(textureSize(u_texture, 0).x),
+        1.0 / float(textureSize(u_texture, 0).y) ); // gets size of single texel
+    vec3 color = vec3(0.0);
+    float total_alpha = texture(u_texture, v_texcoord).a * u_weight[0]; 
+    if (total_alpha > 0.0){
+        color = texture(u_texture, v_texcoord).rgb;
+    }
+    vec2 offset = vec2(0.0);
+    float alpha;
+    float color_count = 0.0;
+    if (!u_glow){
+        if(u_horizontal){
+            for(int i = 1; i < 5; ++i)
+            {
+                offset = vec2(tex_offset.x * float(i), 0.0);
+                alpha = texture(u_texture, v_texcoord + offset).a * u_weight[i];
+
+                if (alpha > u_alpha_threshold){
+                    // color =  max( color, texture(u_texture, v_texcoord + offset).rgb);
+                    color += texture(u_texture, v_texcoord + offset).rgb;
+                    total_alpha += alpha;
+                    color_count += 1.0;
+                }
+                alpha = texture(u_texture, v_texcoord - offset).a * u_weight[i];
+                if (alpha > u_alpha_threshold){
+                    // color =  max( color, texture(u_texture, v_texcoord - offset).rgb);
+                    color += texture(u_texture, v_texcoord - offset).rgb ;
+                    total_alpha += alpha;
+                    color_count += 1.0;
 
-        void main()
-        {             
-            vec2 tex_offset = vec2( 
-                1.0 / float(textureSize(u_texture, 0).x),
-                1.0 / float(textureSize(u_texture, 0).y) ); // gets size of single texel
-            vec3 color = vec3(0.0);
-            float total_alpha = texture(u_texture, v_texcoord).a * u_weight[0]; 
-            if (total_alpha > 0.0){
-                color = texture(u_texture, v_texcoord).rgb;
+                }
+            }
+} else {
+            for(int i = 1; i < 5; ++i)
+            {   
+                offset = vec2(0.0, tex_offset.y * float(i));
+                alpha = texture(u_texture, v_texcoord + offset).a * u_weight[i];
+                if (alpha > u_alpha_threshold){
+                    // color =  max( color , texture(u_texture, v_texcoord + offset).rgb);
+                    color += texture(u_texture, v_texcoord + offset).rgb;
+                    total_alpha += alpha;
+                    color_count += 1.0;
+
+                }
+                alpha = texture(u_texture, v_texcoord - offset).a * u_weight[i];
+                if (alpha > u_alpha_threshold){
+                    // color = max( color, texture(u_texture, v_texcoord - offset).rgb );
+                    color += texture(u_texture, v_texcoord - offset).rgb ;
+                    total_alpha += alpha;
+                    color_count += 1.0;
+
+                }
+            }
+
+        }
+                        if (color_count > 0.0){
+                color /= color_count;
             }
-            vec2 offset = vec2(0.0);
-            float alpha;
-            float color_count = 0.0;
-            if (!u_glow){
-                if(u_horizontal){
-                    for(int i = 1; i < 5; ++i)
-                    {
-                        offset = vec2(tex_offset.x * float(i), 0.0);
-                        alpha = texture(u_texture, v_texcoord + offset).a * u_weight[i];
-
-                        if (alpha > u_alpha_threshold){
-                            // color =  max( color, texture(u_texture, v_texcoord + offset).rgb);
-                            color += texture(u_texture, v_texcoord + offset).rgb;
-                            total_alpha += alpha;
-                            color_count += 1.0;
-                        }
-                        alpha = texture(u_texture, v_texcoord - offset).a * u_weight[i];
-                        if (alpha > u_alpha_threshold){
-                            // color =  max( color, texture(u_texture, v_texcoord - offset).rgb);
-                            color += texture(u_texture, v_texcoord - offset).rgb ;
-                            total_alpha += alpha;
-                            color_count += 1.0;
-
-                        }
-                    }
     } else {
-                    for(int i = 1; i < 5; ++i)
-                    {   
-                        offset = vec2(0.0, tex_offset.y * float(i));
-                        alpha = texture(u_texture, v_texcoord + offset).a * u_weight[i];
-                        if (alpha > u_alpha_threshold){
-                            // color =  max( color , texture(u_texture, v_texcoord + offset).rgb);
-                            color += texture(u_texture, v_texcoord + offset).rgb;
-                            total_alpha += alpha;
-                            color_count += 1.0;
-
-                        }
-                        alpha = texture(u_texture, v_texcoord - offset).a * u_weight[i];
-                        if (alpha > u_alpha_threshold){
-                            // color = max( color, texture(u_texture, v_texcoord - offset).rgb );
-                            color += texture(u_texture, v_texcoord - offset).rgb ;
-                            total_alpha += alpha;
-                            color_count += 1.0;
-
-                        }
-                    }
-        
+        if(u_horizontal)
+        {
+            for(int i = 1; i < 5; ++i)
+            {
+                offset = vec2(tex_offset.x * float(i), 0.0);
+                alpha = texture(u_texture, v_texcoord + offset).a * u_weight[i];
+
+                if (alpha > u_alpha_threshold){
+                    color =  max( color, texture(u_texture, v_texcoord + offset).rgb);
+                    total_alpha += alpha;
                 }
-                                if (color_count > 0.0){
-                        color /= color_count;
-                    }
-            } else {
-                if(u_horizontal)
-                {
-                    for(int i = 1; i < 5; ++i)
-                    {
-                        offset = vec2(tex_offset.x * float(i), 0.0);
-                        alpha = texture(u_texture, v_texcoord + offset).a * u_weight[i];
-
-                        if (alpha > u_alpha_threshold){
-                            color =  max( color, texture(u_texture, v_texcoord + offset).rgb);
-                            total_alpha += alpha;
-                        }
-                        alpha = texture(u_texture, v_texcoord - offset).a * u_weight[i];
-                        if (alpha > u_alpha_threshold){
-                            color =  max( color, texture(u_texture, v_texcoord - offset).rgb);
-
-                            total_alpha += alpha;
-                        }
-                    }
+                alpha = texture(u_texture, v_texcoord - offset).a * u_weight[i];
+                if (alpha > u_alpha_threshold){
+                    color =  max( color, texture(u_texture, v_texcoord - offset).rgb);
+
+                    total_alpha += alpha;
                 }
-                else
-                {
-                    for(int i = 1; i < 5; ++i)
-                    {
-                        offset = vec2(0.0, tex_offset.y * float(i));
-                        alpha = texture(u_texture, v_texcoord + offset).a * u_weight[i];
-                        if (alpha > u_alpha_threshold){
-                            color =  max( color, texture(u_texture, v_texcoord + offset).rgb);
-                            total_alpha += alpha;
-                        }
-                        alpha = texture(u_texture, v_texcoord - offset).a * u_weight[i];
-                        if (alpha > u_alpha_threshold){
-                            color = max( color, texture(u_texture, v_texcoord - offset).rgb );
-                            total_alpha += alpha;
-                        }
-                    }
+            }
+        }
+        else
+        {
+            for(int i = 1; i < 5; ++i)
+            {
+                offset = vec2(0.0, tex_offset.y * float(i));
+                alpha = texture(u_texture, v_texcoord + offset).a * u_weight[i];
+                if (alpha > u_alpha_threshold){
+                    color =  max( color, texture(u_texture, v_texcoord + offset).rgb);
+                    total_alpha += alpha;
+                }
+                alpha = texture(u_texture, v_texcoord - offset).a * u_weight[i];
+                if (alpha > u_alpha_threshold){
+                    color = max( color, texture(u_texture, v_texcoord - offset).rgb );
+                    total_alpha += alpha;
                 }
             }
-            outColor = vec4(color, total_alpha);
         }
-        `;
+    }
+    outColor = vec4(color, total_alpha);
+}
+`;
 
         const program = createProgram(this.gl, vertexShader, fragmentShader);
 
@@ -463,77 +463,77 @@ export default class TrackGlowLineProgram {
         const gl = this.gl;
 
         const vertexShader = `#version 300 es
-        precision highp float;
+precision highp float;
 
-        in vec2 a_position;
-        out vec2 v_texcoord;
+in vec2 a_position;
+out vec2 v_texcoord;
 
-        void main() {
-            gl_Position = vec4(a_position, 0.0, 1.0);
-            v_texcoord = a_position.xy * 0.5 + 0.5;
-        }
-        `;
+void main() {
+    gl_Position = vec4(a_position, 0.0, 1.0);
+    v_texcoord = a_position.xy * 0.5 + 0.5;
+}
+`;
         const fragmentShader = `#version 300 es
-        precision highp float;
-        
-        in vec2 v_texcoord;
-        
-        uniform sampler2D u_texture;
-        uniform bool u_horizontal;
-        uniform float u_weight[5];
-        uniform float u_alpha_threshold;
+precision highp float;
 
-        out vec4 outColor;
+in vec2 v_texcoord;
 
-        void main()
-        {             
-            vec2 tex_offset = vec2(1) / vec2(textureSize(u_texture, 0)); // gets size of single texel
-            vec3 color = vec3(0.0);
-            float total_alpha = texture(u_texture, v_texcoord).a * u_weight[0]; 
-            if (total_alpha > 0.0){
-                color = texture(u_texture, v_texcoord).rgb;
-            }
-            vec2 offset = vec2(0.0);
-            float alpha;
+uniform sampler2D u_texture;
+uniform bool u_horizontal;
+uniform float u_weight[5];
+uniform float u_alpha_threshold;
 
-            if(u_horizontal)
-            {
-                for(int i = 1; i < 5; ++i)
-                {
-                    offset = vec2(tex_offset.x * float(i), 0.0);
-                    alpha = texture(u_texture, v_texcoord + offset).a * u_weight[i];
-
-                    if (alpha > u_alpha_threshold){
-                        color =  max( color, texture(u_texture, v_texcoord + offset).rgb);
-                        total_alpha += alpha;
-                    }
-                    alpha = texture(u_texture, v_texcoord - offset).a * u_weight[i];
-                    if (alpha > u_alpha_threshold){
-                        color =  max( color, texture(u_texture, v_texcoord - offset).rgb);
-                        total_alpha += alpha;
-                    }
-                }
+out vec4 outColor;
+
+void main()
+{             
+    vec2 tex_offset = vec2(1) / vec2(textureSize(u_texture, 0)); // gets size of single texel
+    vec3 color = vec3(0.0);
+    float total_alpha = texture(u_texture, v_texcoord).a * u_weight[0]; 
+    if (total_alpha > 0.0){
+        color = texture(u_texture, v_texcoord).rgb;
+    }
+    vec2 offset = vec2(0.0);
+    float alpha;
+
+    if(u_horizontal)
+    {
+        for(int i = 1; i < 5; ++i)
+        {
+            offset = vec2(tex_offset.x * float(i), 0.0);
+            alpha = texture(u_texture, v_texcoord + offset).a * u_weight[i];
+
+            if (alpha > u_alpha_threshold){
+                color =  max( color, texture(u_texture, v_texcoord + offset).rgb);
+                total_alpha += alpha;
             }
-            else
-            {
-                for(int i = 1; i < 5; ++i)
-                {   
-                    offset = vec2(0.0, tex_offset.y * float(i));
-                    alpha = texture(u_texture, v_texcoord + offset).a * u_weight[i];
-                    if (alpha > u_alpha_threshold){
-                        color =  max( color , texture(u_texture, v_texcoord + offset).rgb);
-                        total_alpha += alpha;
-                    }
-                    alpha = texture(u_texture, v_texcoord - offset).a * u_weight[i];
-                    if (alpha > u_alpha_threshold){
-                        color = max( color, texture(u_texture, v_texcoord - offset).rgb );
-                        total_alpha += alpha;
-                    }
-                }
+            alpha = texture(u_texture, v_texcoord - offset).a * u_weight[i];
+            if (alpha > u_alpha_threshold){
+                color =  max( color, texture(u_texture, v_texcoord - offset).rgb);
+                total_alpha += alpha;
             }
-            outColor = vec4(color, total_alpha);
         }
-        `;
+    }
+    else
+    {
+        for(int i = 1; i < 5; ++i)
+        {   
+            offset = vec2(0.0, tex_offset.y * float(i));
+            alpha = texture(u_texture, v_texcoord + offset).a * u_weight[i];
+            if (alpha > u_alpha_threshold){
+                color =  max( color , texture(u_texture, v_texcoord + offset).rgb);
+                total_alpha += alpha;
+            }
+            alpha = texture(u_texture, v_texcoord - offset).a * u_weight[i];
+            if (alpha > u_alpha_threshold){
+                color = max( color, texture(u_texture, v_texcoord - offset).rgb );
+                total_alpha += alpha;
+            }
+        }
+    }
+    outColor = vec4(color, total_alpha);
+}
+`;
 
         const program = createProgram(this.gl, vertexShader, fragmentShader);
 
@@ -583,88 +583,88 @@ export default class TrackGlowLineProgram {
         const gl = this.gl;
 
         const vertexShader = `#version 300 es
-        precision highp float;
-        
-        in vec3 a_position;
-        in float a_time;
-        in vec3 a_color;
-        in float a_track_start_time;
-        in float a_track_end_time;
-        
-        uniform mat4 uModelViewMatrix;
-        uniform mat4 uProjectionMatrix;
-        uniform vec3 uTranslate;
-        
-        uniform bool u_is_3d;
-        uniform vec2 u_mapWH;
-        uniform vec2 u_scrWH;
-        
-        out float v_time;
-        out vec3 v_color;
-        out float v_track_start_time;
-        out float v_track_end_time;
-
-        ` + shaderfunctions.pixelXYToCartesian3DPoint
-            + shaderfunctions.pixelXYToCartesian2DPoint + `
-          
-        void main() {
-            v_time = a_time;
-            v_color = a_color;
-            v_track_start_time = a_track_start_time;
-            v_track_end_time = a_track_end_time;
-            if (u_is_3d){
-                vec3 pos = pixelXYToCartesian3DPoint(a_position);
-                gl_Position = uProjectionMatrix * uModelViewMatrix * vec4(pos - uTranslate, 1.0);
-            }  else {
-                vec2 xy = pixelXYToCartesian2DPoint(a_position.xy, uTranslate.xy, u_mapWH, u_scrWH);
-                gl_Position = uProjectionMatrix * vec4(xy.x, xy.y, 0.0, 1.0);
-            
-            }
-            gl_PointSize = 1.0;
-        }
-        `;
+precision highp float;
+
+in vec3 a_position;
+in float a_time;
+in vec3 a_color;
+in float a_track_start_time;
+in float a_track_end_time;
+
+uniform mat4 uModelViewMatrix;
+uniform mat4 uProjectionMatrix;
+uniform vec3 uTranslate;
+
+uniform bool u_is_3d;
+uniform vec2 u_mapWH;
+uniform vec2 u_scrWH;
+
+out float v_time;
+out vec3 v_color;
+out float v_track_start_time;
+out float v_track_end_time;
+
+${shaderfunctions.pixelXYToCartesian3DPoint}
+${shaderfunctions.pixelXYToCartesian2DPoint}
+    
+void main() {
+    v_time = a_time;
+    v_color = a_color;
+    v_track_start_time = a_track_start_time;
+    v_track_end_time = a_track_end_time;
+    if (u_is_3d){
+        vec3 pos = pixelXYToCartesian3DPoint(a_position);
+        gl_Position = uProjectionMatrix * uModelViewMatrix * vec4(pos - uTranslate, 1.0);
+    }  else {
+        vec2 xy = pixelXYToCartesian2DPoint(a_position.xy, uTranslate.xy, u_mapWH, u_scrWH);
+        gl_Position = uProjectionMatrix * vec4(xy.x, xy.y, 0.0, 1.0);
+    
+    }
+    gl_PointSize = 1.0;
+}
+`;
 
         const fragmentShader = `#version 300 es
-        precision lowp float;
+precision lowp float;
 
-        in float v_time;
-        in vec3 v_color;
-        in float v_track_start_time;
-        in float v_track_end_time;
+in float v_time;
+in vec3 v_color;
+in float v_track_start_time;
+in float v_track_end_time;
 
-        uniform float u_head_time;
-        uniform float u_tail_time;
+uniform float u_head_time;
+uniform float u_tail_time;
 
-        uniform float u_head_percentage;
-        uniform float u_route_alpha;
+uniform float u_head_percentage;
+uniform float u_route_alpha;
 
-        layout(location = 0) out vec4 outColor0;
-        layout(location = 1) out vec4 outColor1;
+layout(location = 0) out vec4 outColor0;
+layout(location = 1) out vec4 outColor1;
 
 
-        void main() {
-            if ( u_tail_time > v_track_end_time || u_head_time < v_track_start_time) discard;
-            // if ( v_time < u_tail_time || v_time > u_head_time) discard;
-
-            float gap = u_head_time - u_tail_time;
-            float head = gap * u_head_percentage;
-            float dist = u_head_time - v_time;
-            if ((v_time > u_head_time ) || (v_time < u_tail_time) ){ 
-                
-                outColor0 = vec4(v_color , u_route_alpha); 
-            } else if (dist < head) {
-                // white head
-                outColor0 = vec4(1.0, 1.0, 1.0, 0.77 + ( u_route_alpha * 0.23)); 
-                outColor1 = vec4(1.0, 1.0, 1.0, 0.77 + ( u_route_alpha * 0.23)); 
-            // 
-            } else {
-                // colored body of lines
-                float alpha = ((gap - dist) / gap) / 2.0 + 0.5;
-                outColor0 = vec4(v_color , alpha ); 
-                outColor1 = vec4(v_color , alpha );  
-            }
-        }
-        `;
+void main() {
+    if ( u_tail_time > v_track_end_time || u_head_time < v_track_start_time) discard;
+    // if ( v_time < u_tail_time || v_time > u_head_time) discard;
+
+    float gap = u_head_time - u_tail_time;
+    float head = gap * u_head_percentage;
+    float dist = u_head_time - v_time;
+    if ((v_time > u_head_time ) || (v_time < u_tail_time) ){ 
+        
+        outColor0 = vec4(v_color , u_route_alpha); 
+    } else if (dist < head) {
+        // white head
+        outColor0 = vec4(1.0, 1.0, 1.0, 0.77 + ( u_route_alpha * 0.23)); 
+        outColor1 = vec4(1.0, 1.0, 1.0, 0.77 + ( u_route_alpha * 0.23)); 
+    // 
+    } else {
+        // colored body of lines
+        float alpha = ((gap - dist) / gap) / 2.0 + 0.5;
+        outColor0 = vec4(v_color , alpha ); 
+        outColor1 = vec4(v_color , alpha );  
+    }
+}
+`;
         const program = createProgram(this.gl, vertexShader, fragmentShader);
         const a_position = gl.getAttribLocation(program, "a_position");
         const a_time = gl.getAttribLocation(program, "a_time");

package/write-text/context-text3.js

@@ -104,7 +104,7 @@ export class ContextTextWriter3 {
         const angleIsOn = is3D ? (this.angleAdaptorIsOn && this.angleOnSphere) : (this.angleAdaptorIsOn)
         const zoomLevel = globe.api_GetCurrentLODWithDecimal();
         const zoomAdaptor = this.zoomLevelAdaptor(zoomLevel);
-        for (const [key, item] of itemMap) {
+        for (const item of itemMap.values()) {
             const { lat, long, text, opacity = null, angle = null, payload, position } = item;
             const { x, y } = globe.api_GetScreenPointFromGeo(
                 {
@@ -160,12 +160,6 @@ export class ContextTextWriter3 {
     }
 
 
-    updateText() {
-        this.itemMap.forEach((v, k, m) => {
-            const { payload } = v;
-            this.insertText(payload, 0, m, payload);
-        });
-    }
 
     clear() {
         this.itemMap.clear();