@pirireis/webglobeplugins 0.6.17 → 0.6.19

package/programs/line-on-globe/circle-accurate-flat.js

@@ -0,0 +1,200 @@
+import { createProgram } from "../../util/webglobjectbuilders";
+import { CameraUniformBlockString, CameraUniformBlockTotemCache } from "../totems/camerauniformblock";
+import { noRegisterGlobeProgramCache } from "../programcache";
+import { vaoAttributeLoader } from "../../util/account/util";
+import {
+    mercatorXYToGLPosition, POLE
+} from "../../util/shaderfunctions/geometrytransformations";
+
+/**
+* Warning:
+* Insert the points from the second index and skip 1 point as you placed 361 points
+*/
+
+const EDGE_COUNT = 62; // 1 for returning to the start point. 1 for cutting the circle into pieces. 
+
+const vertexShaderSource = `#version 300 es
+precision highp float;
+${CameraUniformBlockString}
+${mercatorXYToGLPosition}
+
+uniform float edge_count;
+
+
+in vec2 position2d;
+in vec4 color;
+in float dash_ratio;
+in float dash_opacity;
+
+out float interpolation;
+out vec4 v_color;
+out float v_dash_ratio;
+out float v_dash_opacity;
+out vec2 v_limp;
+void main() {
+    interpolation = float( gl_VertexID % 62 ) / ${EDGE_COUNT}.0;
+    if ( gl_VertexID % 62 == 0 ) { return; } // cut on the first point.
+    if ( is3D ) {
+        return;
+        v_limp = vec2(0.0, 0.0);
+    } else {
+        v_limp = position2d;
+        gl_Position = mercatorXYToGLPosition( position2d);
+    }
+    v_dash_ratio = dash_ratio;
+    v_dash_opacity = dash_opacity;
+    v_color = color;
+    gl_PointSize = 15.0;
+
+}`
+
+const fragmentShaderSource = `#version 300 es
+${POLE}
+precision highp float;
+uniform float opacity;
+in vec4 v_color;
+in float v_dash_ratio;
+in float v_dash_opacity;
+in float interpolation;
+in vec2 v_limp;
+out vec4 color;
+void main() {
+    if ( v_limp.x < -POLE || v_limp.x > POLE || v_limp.y < -POLE || v_limp.y > POLE ){ color = vec4(0.0,0.0,0.0,0.0); return; }
+    color = v_color;
+    color.a *= opacity;
+    if ( v_dash_ratio == 1.0 || v_dash_ratio == 0.0 ) return;
+    if (fract(interpolation / (2.0 * v_dash_ratio)) < 0.5 ) {
+        color.a *= v_dash_opacity;
+    }   
+}
+`;
+
+
+
+class Logic {
+
+
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this._lastOpacity = 1.0;
+        this._lastMercatorMode = 0;
+        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
+
+        const { gl, program } = this;
+        this.program.uniforms = {
+            opacity: gl.getUniformLocation(program, "opacity"),
+            mercator_calculation_mode: gl.getUniformLocation(program, "mercator_calculation_mode")
+        };
+
+        { // initial uniform values
+            const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+            gl.useProgram(program);
+            gl.uniform1f(program.uniforms.opacity, 1.0);
+            gl.uniform1i(program.uniforms.mercator_calculation_mode, 0);
+            gl.useProgram(currentProgram);
+
+
+        }
+
+        {   // assign attribute locations
+            gl.bindAttribLocation(program, 0, "position2d");
+            gl.bindAttribLocation(program, 1, "color");
+            gl.bindAttribLocation(program, 2, "dash_ratio");
+            gl.bindAttribLocation(program, 3, "dash_opacity");
+        }
+
+        this.cameraBindingPoint = 0;
+        this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
+        const cameraBlockLocation = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+        gl.uniformBlockBinding(program, cameraBlockLocation, this.cameraBindingPoint);
+    }
+
+
+    createVAO(centerObj, colorObj, dashRatioObj, dashOpacityObj) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        {  // make this a function end import from account module. 
+            const { buffer, stride = 0, offset = 0, divisor = 1 } = centerObj;
+            vaoAttributeLoader(gl, buffer, 0, 2, stride, offset, null);
+        }
+
+        {
+            const { buffer, stride = 0, offset = 0, divisor = 1 } = colorObj;
+            vaoAttributeLoader(gl, buffer, 1, 4, stride, offset, null);
+        }
+        {
+            const { buffer, stride = 0, offset = 0, divisor = 1 } = dashRatioObj;
+            vaoAttributeLoader(gl, buffer, 2, 1, stride, offset, null);
+        }
+        {
+            const { buffer, stride = 0, offset = 0, divisor = 1 } = dashOpacityObj;
+            vaoAttributeLoader(gl, buffer, 3, 1, stride, offset, null);
+        }
+        gl.bindVertexArray(null);
+        gl.bindVertexArray(null);
+        return vao;
+    }
+
+
+    draw(vao, length, opacity) {
+        const { gl, program, cameraBlockTotem, cameraBindingPoint } = this;
+        gl.useProgram(program);
+        if (this._lastOpacity !== opacity) {
+            gl.uniform1f(program.uniforms.opacity, opacity);
+            this._lastOpacity = opacity;
+        }
+        gl.bindVertexArray(vao);
+        cameraBlockTotem.bind(cameraBindingPoint);
+        gl.drawArrays(gl.LINE_STRIP, 0, length * EDGE_COUNT)
+        // gl.drawArrays(gl.POINTS, 0, length * EDGE_COUNT)
+        cameraBlockTotem.unbind(cameraBindingPoint);
+        gl.bindVertexArray(null);
+    }
+
+
+    free() {
+        if (this.isFreed) return;
+        CameraUniformBlockTotemCache.release(this.globe);
+        this.gl.deleteProgram(this.program);
+        this.isFreed = true;
+    }
+}
+
+
+
+const CircleCache = Object.freeze({
+    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, Logic),
+    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, Logic)
+});
+
+
+function centerCoords2dflatDataCreator(globe, centerLong, centerLat, targetLong, targetLat, { startAngleOfCircle = null } = {}) {
+    const centerCoords2dflat = new Float32Array(EDGE_COUNT * 2);
+    const radius2d = globe.Math.GetDist2D(centerLong, centerLat, targetLong, targetLat);
+    let angle;
+    if (startAngleOfCircle === null) {
+        angle = globe.Math.GetAzimuthAngle(centerLong, centerLat, targetLong, targetLat);
+    } else {
+        angle = startAngleOfCircle;
+    }
+    const pointsLongLat = globe.Math.GetEllipseGeo(
+        centerLong,
+        centerLat,
+        radius2d,
+        radius2d,
+        angle,
+        360 / (EDGE_COUNT - 2), // 1 for return to start point, 1 for cutting circles
+    );
+
+    for (let i = 1; i < EDGE_COUNT; i++) {
+        const { long: lg, lat: lt } = pointsLongLat[i - 1];
+        centerCoords2dflat.set(globe.api_GetMercator2DPoint(lg, lt), i * 2);
+    }
+    return centerCoords2dflat;
+}
+
+export {
+    CircleCache, EDGE_COUNT, centerCoords2dflatDataCreator
+}

package/programs/line-on-globe/circle-accurate.js

@@ -58,7 +58,7 @@ void main() {
         v_limp = vec2(0.0, 0.0);
     } else {
         vec2 position;  
-        if ( radius < 1000.0) {
+        if ( radius < 0.0) {
             float cosine1 = cos(asin(tanh(center_position.y / 6378137.0)));
             position = circleLimpFromLongLatRadCenterMercatorCompass_accurate(center_position, radius /  cosine1 , angle);
         } else {
@@ -71,6 +71,7 @@ void main() {
     v_dash_ratio = dash_ratio;
     v_dash_opacity = dash_opacity;
     v_color = color;
+    gl_PointSize = 3.0;
 
 }`
 
@@ -178,6 +179,7 @@ class Logic {
         gl.bindVertexArray(vao);
         cameraBlockTotem.bind(cameraBindingPoint);
         gl.drawArraysInstanced(gl.LINE_STRIP, 0, EDGE_COUNT_ON_SPHERE + 1, length);
+        gl.drawArraysInstanced(gl.POINTS, 0, EDGE_COUNT_ON_SPHERE + 1, length);
         cameraBlockTotem.unbind(cameraBindingPoint);
         gl.bindVertexArray(null);
     }

package/programs/line-on-globe/naive-accurate.js

@@ -5,7 +5,7 @@ import { noRegisterGlobeProgramCache, globeProgramCache } from "../programcache"
 import BufferOffsetManger from "../../util/account/bufferoffsetmanager";
 import { programCache } from "../rings/distancering/circleflatprogram";
 
-const GLOBE_MIDPOINT_COUNT = 100;
+const GLOBE_MIDPOINT_COUNT = 30;
 const ITEM_SIZE = 9;
 
 const vertexShader = `#version 300 es
@@ -17,7 +17,7 @@ ${mercatorXYToGLPosition}
 ${cartesian3DToGLPosition}
 
 in vec2 start_position;
-in vec3 start_poisition3d;
+in vec3 start_position3d;
 in vec2 end_position;
 in vec3 end_position3d;
 in float dash_ratio;
@@ -34,7 +34,12 @@ void main() {
     vec2 longLat;
     if (is3D) {
         interpolation = float(gl_VertexID) / ${GLOBE_MIDPOINT_COUNT - 1}.0;
-        vec3 cartesian = pointsOnSphereBetween(start_poisition3d, end_position3d, interpolation) * length(end_position3d);
+        vec3 cartesian;
+        if ( length( start_position3d - end_position3d) < 4.4){
+            cartesian = mix( start_position3d, end_position3d, interpolation);
+        } else {
+            cartesian = pointsOnSphereBetween(start_position3d, end_position3d, interpolation) * length(end_position3d);
+        }
         gl_Position = cartesian3DToGLPosition(cartesian);
         v_limp = vec2(0.0, 0.0);
     } else {
@@ -124,11 +129,9 @@ class Logic {
             this._lastOpacity = opacity;
         }
         const drawCount = globe.api_GetCurrentGeometry() === 0 ? GLOBE_MIDPOINT_COUNT : 2;
-        // gl.disable(gl.DEPTH_TEST);
         gl.drawArraysInstanced(gl.LINE_STRIP, 0, drawCount, length);
         gl.bindVertexArray(null);
         cameraBlockTotem.unbind(cameraBlockBindingPoint);
-        // gl.enable(gl.DEPTH_TEST);
     }
 
     //

package/programs/rings/partial-ring/piece-of-pie.js

@@ -0,0 +1,315 @@
+import { createProgram, shaderfunctions } from "../../../util";
+import { CameraUniformBlockTotem, CameraUniformBlockString } from "../../totems";
+import { noRegisterGlobeProgramCache, globeProgramCache } from "../../programcache";
+import {
+    POLE,
+    PI,
+    longLatRadToMercator,
+    mercatorXYToGLPosition,
+    longLatRadToCartesian3D,
+    circleLimpFromLongLatRadCenterCartesian3D_accurate,
+    circleLimpFromLongLatRadCenterMercatorCompass_accurate,
+    //circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate,
+    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,
+});
+
+
+//${ circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate }
+
+const vertexShaderSource = `#version 300 es
+
+${CameraUniformBlockString} 
+${PI} 
+${longLatRadToMercator}
+${mercatorXYToGLPosition}
+${longLatRadToCartesian3D}
+${circleLimpFromLongLatRadCenterCartesian3D_accurate}
+${circleLimpFromLongLatRadCenterMercatorCompass_accurate}
+${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 vec2 center2d;
+in vec3 center3d;
+in float start_angle2d; 
+in float tail_angle2d;
+
+in float start_angle3d;
+in float tail_angle3d;
+
+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 start_angle, tail_angle;
+    if (is3D) {
+        start_angle = start_angle3d;
+        tail_angle = tail_angle3d;
+    } else {
+        start_angle = start_angle2d;
+        tail_angle = tail_angle2d;
+    }
+    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_accurate(center3d, radius_, angle);
+        v_pos = vec2(0.0, 0.0);
+        gl_Position = cartesian3DToGLPosition(pos);
+    }
+    else {
+        vec2 pos2 = circleLimpFromLongLatRadCenterMercatorCompass_accurate(center2d, radius_, angle);
+        v_pos = pos2;
+        gl_Position = mercatorXYToGLPosition(pos2);
+    }
+
+    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, 'center2d');
+            gl.bindAttribLocation(program, 1, 'center3d')
+            gl.bindAttribLocation(program, 2, 'start_angle2d');
+            gl.bindAttribLocation(program, 3, 'tail_angle2d');
+            gl.bindAttribLocation(program, 4, 'start_angle3d');
+            gl.bindAttribLocation(program, 5, 'tail_angle3d');
+            gl.bindAttribLocation(program, 6, 'color');
+            gl.bindAttribLocation(program, 7, 'radius');
+            gl.bindAttribLocation(program, 8, '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;
+    }
+
+
+    /**
+     * 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(center2dObj, center3dObj, startAngle2DObj, tailAngle2DObj, startAngle3DObj, tailAngle3DObj, colorObj, radiusObj, colorModeObj) {
+
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+
+        {
+            const { buffer, stride, offset } = center2dObj;
+            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 } = center3dObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(1);
+            gl.vertexAttribPointer(1, 3, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(1, 1);
+        }
+
+        {
+            const { buffer, stride, offset } = startAngle2DObj;
+            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 } = tailAngle2DObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(3);
+            gl.vertexAttribPointer(3, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(3, 1);
+        }
+        {
+            const { buffer, stride, offset } = startAngle3DObj;
+            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 } = tailAngle3DObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(5);
+            gl.vertexAttribPointer(5, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(5, 1);
+        }
+        {
+            const { buffer, stride, offset } = colorObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(6);
+            gl.vertexAttribPointer(6, 4, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(6, 1);
+        }
+        {
+            const { buffer, stride, offset } = radiusObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(7);
+            gl.vertexAttribPointer(7, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(7, 1);
+        }
+        {
+            const { buffer, stride, offset } = colorModeObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(8);
+            gl.vertexAttribPointer(8, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(8, 1);
+        }
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return vao;
+    }
+
+
+
+}
+
+export const pieceOfPieProgramCache = Object.freeze({
+    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, Logic),
+    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, Logic)
+});

package/util/check/get.js

@@ -4,7 +4,7 @@ export const mapGetOrThrow = (errorNote) => {
         const result = [];
         for (let i = 0; i < ids.length; i++) {
             const e = mapInstance.get(ids[i]);
-            if (e === undefined) throw new Error(errorNote + ":" + ids[i]);
+            if (e === undefined) throw new Error(errorNote + " " + ids[i]);
             result.push(e);
         }
         return result;

package/util/jshelpers/data-filler.js

@@ -0,0 +1,19 @@
+const populateFloat32Array = Object.freeze({
+    fillFloat32Array: (length, data) => {
+        const result = new Float32Array(length);
+        result.fill(data);
+        return result;
+    },
+
+    fillWithListData: (length, listdata) => {
+        const result = new Float32Array(length * listdata.length);
+        let offset = 0;
+        for (let i = 0; i < length; i++) {
+            result.set(listdata, offset);
+            offset += listdata.length;
+        }
+        return result
+    }
+});
+
+export { populateFloat32Array };

package/util/shaderfunctions/geometrytransformations.js

@@ -134,10 +134,11 @@ vec2 circleLimpFromLongLatRadCenterMercatorRealDistance(vec2 center, float radiu
 
     float delta_long = atan(sin(ang) * sin_r * cos(center.y), cos_r - sin(center.y) * sin_lat);
     float longi = center.x + delta_long;
+    
 
     return vec2(
         R * longi,
-        R * log(tan(PI / 4.0 + lat / 2.0))
+        R * log(tan(PI / 4.0 + lat / 2.0)) 
     );
 }`;
 
@@ -343,11 +344,16 @@ vec2 circleLimpFromLongLatRadCenterMercatorRealDistanceNew_accurate(vec2 mercato
 
     float delta_long = atan(sin(ang) * sin_r * cos(center.y), cos_r - sin(center.y) * sin_lat);
     float longi = center.x + delta_long;
-
-    return vec2(
+    // float y = mix(-80.5, 80.5, abs(center.y + PI / 2.0));
+    vec2 limp = vec2(
         R * longi,
         R * log(tan(PI / 4.0 + lat / 2.0))
     );
+    vec2 center_mercator = vec2(
+        R * center.x,
+        R * log(tan(PI/4.0+ center.y / 2.0))
+    );
+    return mercator_center - center_mercator + limp;
 }`;
 
 export {

package/write-text/context-text3.js

@@ -160,6 +160,10 @@ export class ContextTextWriter3 {
     clear() {
         this.itemMap.clear();
     }
+
+    free() {
+        this.itemMap = null;
+    }
 }