@pirireis/webglobeplugins 0.9.8 → 0.9.9

package/dist/programs/point-on-globe/square-pixel-point.js

@@ -1,174 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PointOnGlobeProgramCache = void 0;
-const util_1 = require("../../util");
-const totems_1 = require("../totems");
-const geometrytransformations_1 = require("../../util/shaderfunctions/geometrytransformations");
-const programcache_1 = require("../programcache");
-const vs = `#version 300 es
-${totems_1.CameraUniformBlockString}
-${geometrytransformations_1.mercatorXYToGLPosition}
-${geometrytransformations_1.cartesian3DToGLPosition}
-precision highp float;
-precision highp int;
-
-uniform int hovered_vertexID; // can be removed
-
-in vec3 pos3D;
-in vec2 pos2D;
-in vec4 rgba;
-
-uniform float pointSize;
-uniform float hoveredPointSize;
-
-flat out highp int vVertexID;
-
-
-out vec4 v_rgba;
-
-void main() {
-
-    if(is3D){
-        gl_Position = cartesian3DToGLPosition(pos3D);
-    }
-    else{
-        gl_Position = mercatorXYToGLPosition(pos2D);
-    }
-    if (hovered_vertexID == gl_VertexID) {
-        gl_PointSize = hoveredPointSize;
-    } else {
-        gl_PointSize = pointSize;
-    }
-    v_rgba = rgba;
-    vVertexID = gl_VertexID;
-}`;
-const fs = `#version 300 es
-precision highp float;
-
-uniform float opacity;
-
-flat in highp int vVertexID;
-in vec4 v_rgba;
-
-layout(location = 0) out vec4 fragColor;
-layout(location = 1) out int vertexID;
-
-void main() {
-    vertexID = vVertexID; 
-    fragColor = v_rgba;
-    fragColor.a *= opacity;
-}`;
-class PointOnGlobeProgram {
-    constructor(globe) {
-        this.globe = globe;
-        this.gl = globe.gl;
-        this.program = (0, util_1.createProgram)(this.gl, vs, fs);
-        const { gl, program } = this;
-        this.uniforms = {
-            opacity: gl.getUniformLocation(program, "opacity"),
-            hovered_vertexID: gl.getUniformLocation(program, "hovered_vertexID"),
-            hoveredPointSize: gl.getUniformLocation(program, "hoveredPointSize"),
-            pointSize: gl.getUniformLocation(program, "pointSize"),
-        };
-        // eslint-disable-next-line
-        { // assign opacity
-            this._lastOpacity = 1.0;
-            this._lastPointSize = 2.0;
-            this._lastHoveredPointSize = 4.0;
-            this._lastHoveredID = -1;
-            const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-            gl.useProgram(program);
-            gl.uniform1f(this.uniforms.opacity, this._lastOpacity);
-            gl.uniform1f(this.uniforms.pointSize, this._lastPointSize);
-            gl.uniform1f(this.uniforms.hoveredPointSize, this._lastHoveredPointSize);
-            gl.uniform1i(this.uniforms.hovered_vertexID, this._lastHoveredID);
-            gl.useProgram(currentProgram);
-        }
-        // eslint-disable-next-line
-        { // assign attribute locations
-            gl.bindAttribLocation(program, 0, "pos3D");
-            gl.bindAttribLocation(program, 1, "pos2D");
-            gl.bindAttribLocation(program, 2, "rgba");
-        }
-        // eslint-disable-next-line
-        { // arrange camera uniform block
-            this.cameraBlockBingingPoint = 0;
-            this.cameraBlockTotem = totems_1.CameraUniformBlockTotemCache.get(globe);
-            const cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
-            gl.uniformBlockBinding(program, cameraBlockIndex, this.cameraBlockBingingPoint);
-        }
-    }
-    createVAO(pos3DBuffer, pos2DBuffer, rgbaBuffer) {
-        const { gl } = this;
-        const vao = gl.createVertexArray();
-        gl.bindVertexArray(vao);
-        // eslint-disable-next-line
-        {
-            gl.bindBuffer(gl.ARRAY_BUFFER, pos3DBuffer);
-            gl.enableVertexAttribArray(0);
-            gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 0, 0);
-        }
-        // eslint-disable-next-line
-        {
-            gl.bindBuffer(gl.ARRAY_BUFFER, pos2DBuffer);
-            gl.enableVertexAttribArray(1);
-            gl.vertexAttribPointer(1, 2, gl.FLOAT, false, 0, 0);
-        }
-        // eslint-disable-next-line
-        {
-            gl.bindBuffer(gl.ARRAY_BUFFER, rgbaBuffer);
-            gl.enableVertexAttribArray(2);
-            gl.vertexAttribPointer(2, 4, gl.FLOAT, false, 0, 0);
-        }
-        gl.bindVertexArray(null);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-        return vao;
-    }
-    draw(vao, length, { opacity = 1.0, hoveredID = -1, pointSize = 2.0, hoveredPointSize = 4.0, elementBuffer = null } = {}) {
-        if (length === 0 || opacity === 0)
-            return;
-        const { gl, program, uniforms } = this;
-        gl.useProgram(program);
-        if (this._lastOpacity !== opacity) {
-            gl.uniform1f(uniforms.opacity, opacity);
-            this._lastOpacity = opacity;
-        }
-        if (this._lastPointSize !== pointSize) {
-            gl.uniform1f(uniforms.pointSize, pointSize);
-            this._lastPointSize = pointSize;
-        }
-        if (this._lastHoveredPointSize !== hoveredPointSize) {
-            gl.uniform1f(uniforms.hoveredPointSize, hoveredPointSize);
-            this._lastHoveredPointSize = hoveredPointSize;
-        }
-        if (this._lastHoveredID !== hoveredID) {
-            gl.uniform1i(uniforms.hovered_vertexID, hoveredID);
-            this._lastHoveredID = hoveredID;
-        }
-        gl.bindVertexArray(vao);
-        this.cameraBlockTotem.bind(this.cameraBlockBingingPoint);
-        if (elementBuffer) {
-            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, elementBuffer);
-            gl.drawElements(gl.POINTS, length, gl.UNSIGNED_INT, 0);
-            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
-        }
-        else {
-            gl.drawArrays(gl.POINTS, 0, length);
-        }
-        this.cameraBlockTotem.unbind(this.cameraBlockBingingPoint);
-        gl.bindVertexArray(null);
-    }
-    free() {
-        if (this._isFreed)
-            return;
-        const { gl, globe } = this;
-        totems_1.CameraUniformBlockTotemCache.release(globe);
-        gl.deleteProgram(this.program);
-        this._isFreed = true;
-    }
-}
-const PointOnGlobeProgramCache = Object.freeze({
-    get: (globe) => programcache_1.noRegisterGlobeProgramCache.getProgram(globe, PointOnGlobeProgram),
-    release: (globe) => programcache_1.noRegisterGlobeProgramCache.releaseProgram(globe, PointOnGlobeProgram)
-});
-exports.PointOnGlobeProgramCache = PointOnGlobeProgramCache;

package/dist/programs/programcache.js

@@ -1,131 +0,0 @@
-"use strict";
-/**
- * @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.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.noRegisterGlobeProgramCache = exports.glProgramCache = exports.globeProgramCache = void 0;
-const globeProgramCache = (function () {
-    const cache = new Map();
-    function getProgram(globe, ProgramClass) {
-        if (!cache.has(globe)) {
-            cache.set(globe, new Map());
-        }
-        ;
-        if (!cache.get(globe).has(ProgramClass)) {
-            cache.get(globe).set(ProgramClass, {
-                program: new ProgramClass(),
-                count: 1
-            });
-            const firstObject = globe.DrawOrder.GetObj(0);
-            globe.api_RegisterPlugin(cache.get(globe).get(ProgramClass).program, firstObject);
-        }
-        else {
-            cache.get(globe).get(ProgramClass).count++;
-        }
-        return cache.get(globe).get(ProgramClass).program;
-    }
-    ;
-    function releaseProgram(globe, ProgramClass) {
-        if (cache.has(globe) && cache.get(globe).has(ProgramClass)) {
-            if (cache.get(globe).get(ProgramClass).count === 0) {
-                throw new Error("The program counter is already 0, cannot release program");
-            }
-            cache.get(globe).get(ProgramClass).count--;
-            if (cache.get(globe).get(ProgramClass).count === 0) {
-                globe.api_UnRegisterPlugin(cache.get(globe).get(ProgramClass).program.id); // it calls program.free()
-                cache.get(globe).delete(ProgramClass);
-            }
-        }
-    }
-    ;
-    return Object.freeze({
-        getProgram,
-        releaseProgram
-    });
-})();
-exports.globeProgramCache = globeProgramCache;
-const glProgramCache = (function () {
-    const cache = new Map();
-    function getProgram(gl, ProgramClass) {
-        if (!cache.has(gl)) {
-            cache.set(gl, new Map());
-        }
-        ;
-        if (!cache.get(gl).has(ProgramClass)) {
-            cache.get(gl).set(ProgramClass, {
-                program: new ProgramClass(gl),
-                count: 1
-            });
-        }
-        else {
-            cache.get(gl).get(ProgramClass).count++;
-        }
-        return cache.get(gl).get(ProgramClass).program;
-    }
-    ;
-    function releaseProgram(gl, ProgramClass) {
-        if (cache.has(gl) && cache.get(gl).has(ProgramClass)) {
-            if (cache.get(gl).get(ProgramClass).count === 0) {
-                throw new Error("The program counter is already 0, cannot release program");
-            }
-            cache.get(gl).get(ProgramClass).count--;
-            if (cache.get(gl).get(ProgramClass).count === 0) {
-                cache.get(gl).get(ProgramClass).program.free();
-                cache.get(gl).delete(ProgramClass);
-            }
-        }
-    }
-    ;
-    return Object.freeze({
-        getProgram,
-        releaseProgram
-    });
-})();
-exports.glProgramCache = glProgramCache;
-const noRegisterGlobeProgramCache = (function () {
-    const cache = new Map();
-    function getProgram(globe, ProgramClass) {
-        if (!cache.has(globe)) {
-            cache.set(globe, new Map());
-        }
-        ;
-        if (!cache.get(globe).has(ProgramClass)) {
-            cache.get(globe).set(ProgramClass, {
-                program: new ProgramClass(globe),
-                count: 1
-            });
-        }
-        else {
-            cache.get(globe).get(ProgramClass).count++;
-        }
-        return cache.get(globe).get(ProgramClass).program;
-    }
-    ;
-    function releaseProgram(globe, ProgramClass) {
-        if (cache.has(globe) && cache.get(globe).has(ProgramClass)) {
-            if (cache.get(globe).get(ProgramClass).count === 0) {
-                throw new Error("The program counter is already 0, cannot release program");
-            }
-            cache.get(globe).get(ProgramClass).count--;
-            if (cache.get(globe).get(ProgramClass).count === 0) {
-                cache.get(globe).get(ProgramClass).program.free();
-                cache.get(globe).delete(ProgramClass);
-            }
-        }
-    }
-    return Object.freeze({
-        getProgram,
-        releaseProgram
-    });
-})();
-exports.noRegisterGlobeProgramCache = noRegisterGlobeProgramCache;

package/dist/programs/rings/distancering/circleflatprogram.js

@@ -1,156 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.programCache = void 0;
-const util_1 = require("../../../util");
-const camerauniformblock_1 = __importStar(require("../../totems/camerauniformblock"));
-const programcache_1 = require("../../programcache");
-const CIRCLE_EDGE_COUNT = 360;
-const vertexShader = `#version 300 es ` +
-    util_1.shaderfunctions.PI +
-    util_1.shaderfunctions.R +
-    util_1.shaderfunctions.POLE +
-    camerauniformblock_1.CameraUniformBlockString +
-    util_1.shaderfunctions.mercatorXYToGLPosition +
-    util_1.shaderfunctions.longLatRadToMercator +
-    util_1.shaderfunctions.longLatRadToCartesian3D +
-    util_1.shaderfunctions.circleLimpFromLongLatRadCenterCartesian3D +
-    util_1.shaderfunctions.circleLimpFromLongLatRadCenterMercatorCompass +
-    util_1.shaderfunctions.circleLimpFromLongLatRadCenterMercatorRealDistance + `
-
-uniform int compass;
-uniform float circle_edge_count;
-
-uniform float opacity;
-
-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; // flag 1.0 is hide
-    v_color = vec4(color.rgb, color.a * opacity);
-    if ( gl_VertexID == 270 ) v_color.rgb += 0.2;
-    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 = mercatorXYToGLPosition(limp);
-    
-}`;
-const fragmentShader = `#version 300 es
-precision highp float;` +
-    util_1.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 = (0, util_1.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 = programcache_1.globeProgramCache.getProgram(globe, camerauniformblock_1.default);
-        const cameraBlockIndex = this.gl.getUniformBlockIndex(this.program, "CameraUniformBlock");
-        this.gl.uniformBlockBinding(this.program, cameraBlockIndex, this.cameraBlockBindingPoint);
-        this._opacityLocation = this.gl.getUniformLocation(this.program, "opacity");
-        this._compassLocation = this.gl.getUniformLocation(this.program, "compass");
-        this._circleEdgeCountLocation = this.gl.getUniformLocation(this.program, "circle_edge_count");
-        this._circleEdgeCount = CIRCLE_EDGE_COUNT;
-        this._compassmode = 1;
-        this._opacity = 1.0;
-        {
-            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.uniform1f(this._opacityLocation, 1.0);
-            this.gl.useProgram(currentProgram);
-        }
-    }
-    draw(attrBufferManager, compass, circleEdgeCount, opacity) {
-        const { gl, program, cameraBlockTotem, cameraBlockBindingPoint } = this;
-        gl.useProgram(program);
-        cameraBlockTotem.bind(cameraBlockBindingPoint);
-        attrBufferManager.bindCircleVAO();
-        if (compass !== this._compassmode) {
-            gl.uniform1i(this._compassLocation, compass);
-            this._compassmode = compass;
-        }
-        if (opacity !== this._opacity) {
-            gl.uniform1f(this._opacityLocation, opacity);
-            this._opacity = opacity;
-        }
-        if (circleEdgeCount !== this._circleEdgeCount) {
-            gl.uniform1f(this._circleEdgeCountLocation, circleEdgeCount);
-            this._circleEdgeCount = circleEdgeCount;
-        }
-        gl.drawArraysInstanced(gl.LINE_LOOP, 0, circleEdgeCount, attrBufferManager.length);
-        gl.bindVertexArray(null);
-        cameraBlockTotem.unbind(cameraBlockBindingPoint);
-    }
-    free() {
-        this.gl.deleteProgram(this.program);
-        programcache_1.globeProgramCache.releaseProgram(this.globe, camerauniformblock_1.default);
-    }
-}
-exports.programCache = Object.freeze({
-    getProgram: (globe) => { return programcache_1.noRegisterGlobeProgramCache.getProgram(globe, Logic); },
-    releaseProgram: (globe) => { programcache_1.noRegisterGlobeProgramCache.releaseProgram(globe, Logic); }
-});