@pirireis/webglobeplugins 0.0.1

package/programs/programcache.js

@@ -0,0 +1,119 @@
+/**
+ * @module programcache
+ * @description This module provides a cache for programs. It is used to avoid creating the same program multiple times.
+ * 
+ * # globeProgramCache 
+ * Creates and registers programs to the globe. To the 1st object in the draw order.
+ * The programs are generally sets sets a global uniform block.
+ * 
+ * # glProgramCache
+ * Creates and manages programs that are not related to the globe but to the WebGL context.
+ * The programs created by are lightweight absraction of program logic with `constructer(gl)`.
+ * These programs are generally wrapped by another class with more functionality. 
+ */
+
+const globeProgramCache = (function () {
+
+    const cache = {};
+    function getProgram(globe, ProgramClass) {
+        if (!cache[globe]) { cache[globe] = {} };
+        if (!cache[globe][ProgramClass]) {
+            cache[globe][ProgramClass] = {
+                program: new ProgramClass(),
+                count: 1
+            }
+            const firstObject = globe.DrawOrder.GetObj(0)
+            globe.api_RegisterPlugin(cache[globe][ProgramClass].program, firstObject);
+        } else {
+            cache[globe][ProgramClass].count++;
+        }
+        return cache[globe][ProgramClass].program;
+    };
+
+    function releaseProgram(globe, ProgramClass) {
+        if (cache[globe] && cache[globe][ProgramClass]) {
+            cache[globe][ProgramClass].count--;
+            if (cache[globe][ProgramClass].count === 0) {
+                globe.api_UnRegisterPlugin(cache[globe][ProgramClass].program.id); // it calls program.free() 
+                delete cache[globe][ProgramClass];
+            }
+        }
+    };
+
+    return Object.freeze({
+        getProgram,
+        releaseProgram
+    });
+
+})();
+
+
+const glProgramCache = (function () {
+
+    const cache = {};
+    function getProgram(gl, ProgramClass) {
+        if (!cache[gl]) { cache[gl] = {} };
+        if (!cache[gl][ProgramClass]) {
+            cache[gl][ProgramClass] = {
+                program: new ProgramClass(gl),
+                count: 1
+            }
+        } else {
+            cache[gl][ProgramClass].count++;
+        }
+        return cache[gl][ProgramClass].program;
+    };
+
+    function releaseProgram(gl, ProgramClass) {
+        if (cache[gl] && cache[gl][ProgramClass]) {
+            cache[gl][ProgramClass].count--;
+            if (cache[gl][ProgramClass].count === 0) {
+                cache[gl][ProgramClass].program.free();
+                delete cache[gl][ProgramClass];
+            }
+        }
+    };
+
+    return Object.freeze({
+        getProgram,
+        releaseProgram
+    });
+
+})();
+
+
+const noRegisterGlobeProgramCache = (function () {
+
+    const cache = {};
+
+    function getProgram(globe, ProgramClass) {
+        if (!cache[globe]) { cache[globe] = {} };
+        if (!cache[globe][ProgramClass]) {
+            cache[globe][ProgramClass] = {
+                program: new ProgramClass(globe),
+                count: 1
+            }
+        } else {
+            cache[globe][ProgramClass].count++;
+        }
+        return cache[globe][ProgramClass].program;
+    }
+
+    function releaseProgram(globe, ProgramClass) {
+        if (cache[globe] && cache[globe][ProgramClass]) {
+            cache[globe][ProgramClass].count--;
+            if (cache[globe][ProgramClass].count === 0) {
+                cache[globe][ProgramClass].program.free();
+                delete cache[globe][ProgramClass];
+            }
+        }
+    }
+
+    return Object.freeze({
+        getProgram,
+        releaseProgram
+    });
+
+})();
+
+export { globeProgramCache, glProgramCache, noRegisterGlobeProgramCache };

package/programs/rings/distancering/circleflatprogram.js

@@ -0,0 +1,135 @@
+import { createProgram, shaderfunctions } from "../../../util";
+import CameraUniformBlockTotem, { CameraUniformBlockString } from "../../totems/camerauniformblock";
+import { noRegisterGlobeProgramCache, globeProgramCache } from "../../programcache";
+
+const CIRCLE_EDGE_COUNT = 72;
+
+const vertexShader = `#version 300 es ` +
+    shaderfunctions.PI +
+    shaderfunctions.R +
+    shaderfunctions.POLE +
+    CameraUniformBlockString +
+    shaderfunctions.mercatorXYTo2DPoint +
+    shaderfunctions.longLatRadToMercator +
+    shaderfunctions.longLatRadToCartesian3D +
+    shaderfunctions.circleLimpFromLongLatRadCenterCartesian3D +
+    shaderfunctions.circleLimpFromLongLatRadCenterMercatorCompass +
+    shaderfunctions.circleLimpFromLongLatRadCenterMercatorRealDistance + `
+
+uniform int compass;
+uniform float circle_edge_count;
+
+in vec2 center;
+in float radius;
+in vec4 color;
+in float flag;
+out vec4 v_color;
+out vec2 v_limp;
+
+void main() {
+    if( flag == 1.0 || radius == 0.0) return; // 1.0 is hide
+    v_color = color;
+    gl_PointSize = 2.0;
+    float angle = 3.1415926535897932384626433832795 * 2.0 * (float(gl_VertexID) /  circle_edge_count);
+    if ( is3D ){
+            gl_Position = projection * view * vec4(
+            circleLimpFromLongLatRadCenterCartesian3D( center, radius, angle) - translate, 1.0);
+        v_limp = vec2(0.0, 0.0);
+        return;
+    }
+    vec2 limp;
+    if ( compass == 1 ){
+        limp = circleLimpFromLongLatRadCenterMercatorCompass(center, radius, angle);
+    } else {
+        limp = circleLimpFromLongLatRadCenterMercatorRealDistance(center, radius, angle);
+    }   
+    v_limp = limp;
+    gl_Position = mercatorXYTo2DPoint(limp);
+    
+}`;
+
+const fragmentShader = `#version 300 es
+precision highp float;` +
+    shaderfunctions.POLE + `
+
+in vec4 v_color;
+in vec2 v_limp;
+out vec4 outColor;
+void main() {
+    if ( v_limp.x < -POLE || v_limp.x > POLE || v_limp.y < -POLE || v_limp.y > POLE ){ discard; }
+    outColor = v_color;
+}`;
+
+class Logic {
+    constructor(globe,) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this.program = createProgram(this.gl, vertexShader, fragmentShader);
+        { // bind positions so bufferManager can use them
+            this.gl.bindAttribLocation(this.program, 0, "center");
+            this.gl.bindAttribLocation(this.program, 1, "radius");
+            this.gl.bindAttribLocation(this.program, 2, "color");
+            this.gl.bindAttribLocation(this.program, 3, "flag");
+        }
+        this.cameraBlockBindingPoint = 0;
+        this.cameraBlockTotem = globeProgramCache.getProgram(globe, CameraUniformBlockTotem);
+        const cameraBlockIndex = this.gl.getUniformBlockIndex(this.program, "CameraUniformBlock");
+        this.gl.uniformBlockBinding(this.program, cameraBlockIndex, this.cameraBlockBindingPoint);
+
+        this._compassLocation = this.gl.getUniformLocation(this.program, "compass");
+        this._circleEdgeCountLocation = this.gl.getUniformLocation(this.program, "circle_edge_count");
+        this._circle_edge_count = CIRCLE_EDGE_COUNT;
+        this._compassmode = 1;
+        {
+            const currentProgram = this.gl.getParameter(this.gl.CURRENT_PROGRAM);
+            this.gl.useProgram(this.program);
+            this.gl.uniform1i(this._compassLocation, 1);
+            this.gl.uniform1f(this._circleEdgeCountLocation, CIRCLE_EDGE_COUNT);
+            this.gl.useProgram(currentProgram);
+        }
+
+    }
+
+
+    draw(attrBufferManager, compass, circle_edge_count) {
+        const { gl, program, cameraBlockTotem, cameraBlockBindingPoint } = this;
+        gl.useProgram(program);
+        cameraBlockTotem.bind(cameraBlockBindingPoint);
+        attrBufferManager.bindCircleVAO();
+
+        if (compass !== this._compassLocation) {
+            gl.uniform1i(this._compassLocation, compass);
+            this._compassmode = compass;
+        }
+        if (circle_edge_count !== this._circleEdgeCountLocation) {
+            gl.uniform1f(this._circleEdgeCountLocation, circle_edge_count);
+            this._circle_edge_count = circle_edge_count;
+        }
+        gl.drawArraysInstanced(gl.LINE_LOOP, 0, CIRCLE_EDGE_COUNT, attrBufferManager.length);
+        gl.bindVertexArray(null);
+        cameraBlockTotem.unbind(cameraBlockBindingPoint);
+    }
+
+    free() {
+        this.gl.deleteProgram(this.program);
+        globeProgramCache.releaseProgram(this.globe, CameraUniformBlockTotem);
+
+    }
+}
+
+
+export default class {
+    constructor(globe, gl) {
+        this.gl = gl;
+        this.globe = globe;
+        this.logic = noRegisterGlobeProgramCache.getProgram(globe, Logic);
+    }
+
+    draw(attrBufferManager, compass, circle_edge_count) {
+        this.logic.draw(attrBufferManager, compass, circle_edge_count);
+    }
+
+    free() {
+        noRegisterGlobeProgramCache.releaseProgram(this.gl, Logic);
+    }
+}