@pirireis/webglobeplugins 0.16.0 → 0.16.2

package/programs/two-d/pixel-padding-for-compass.js

@@ -1,7 +1,7 @@
-import { createProgram } from "../../util";
-import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../totems";
-import { noRegisterGlobeProgramCache } from "../programcache";
-const vertexCount = 720;
+import { createProgram } from "../../util";
+import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../totems";
+import { noRegisterGlobeProgramCache } from "../programcache";
+const vertexCount = 720;
 const vertexShaderSource = `#version 300 es
 ${CameraUniformBlockString}
 
@@ -57,8 +57,7 @@ void main(){
     v_rgba.a *= plugin_opacity;
     gl_PointSize = 10.0;
 }
-`
-
+`;
 const fragmentShaderSource = `#version 300 es
 precision highp float;
 in vec4 v_rgba;
@@ -66,109 +65,95 @@ out vec4 color;
 void main(){
     color = v_rgba;
 }
-`
-
-
-class Logic {
-    constructor(globe) {
-        this.globe = globe;
-        this.gl = globe.gl;
-        this._lastOpacity = 1;
-        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
-        const { gl, program } = this;
-        { // assign attribute locations
-            //             in vec2 screen_coordinate;
-            // in float pixel_radius_small_ratio;
-            // in float pixel_radius_big_ratio;
-            // in vec4 rgba;
-
-            gl.bindAttribLocation(program, 0, "screen_coordinate");
-            gl.bindAttribLocation(program, 1, "pixel_radius_small_ratio");
-            gl.bindAttribLocation(program, 2, "pixel_radius_big_ratio");
-            gl.bindAttribLocation(program, 3, "rgba");
-        }
-        {
-            this._opacityLocation = gl.getUniformLocation(program, "plugin_opacity");
-            const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-            gl.useProgram(program);
-            gl.uniform1f(this._opacityLocation, this._lastOpacity);
-            gl.useProgram(currentProgram);
-        }
-        {
-            this.cameraBlockBindingPoint = 0;
-            const cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
-            this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
-            gl.uniformBlockBinding(program, cameraBlockIndex, this.cameraBlockBindingPoint);
-        }
-    }
-
-
-    draw(vao, length, opacity) {
-        const { globe, gl, program, cameraBlockTotem, cameraBlockBindingPoint, _opacityLocation } = this;
-        if (globe.api_GetCurrentGeometry() === 0) return;
-        gl.useProgram(program);
-        cameraBlockTotem.bind(cameraBlockBindingPoint);
-        if (opacity !== this._lastOpacity) {
-            this._lastOpacity = opacity;
-            gl.uniform1f(_opacityLocation, opacity);
-        }
-        gl.bindVertexArray(vao);
-        gl.drawArraysInstanced(gl.LINES, 0, vertexCount, length);
-        gl.bindVertexArray(null);
-        cameraBlockTotem.unbind(cameraBlockBindingPoint);
-    }
-
-    createVAO(screenCoordsBufferObj, pixelRadiusRatioSmallBufferObj, pixelRadiusRatioBigBufferObj, rgbaBufferObj) {
-        const { gl } = this;
-        const vao = gl.createVertexArray();
-        gl.bindVertexArray(vao);
-        {
-            const { buffer, stride = 0, offset = 0 } = screenCoordsBufferObj;
-            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 = 0, offset = 0 } = pixelRadiusRatioSmallBufferObj;
-            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-            gl.enableVertexAttribArray(1);
-            gl.vertexAttribPointer(1, 1, gl.FLOAT, false, stride, offset);
-            gl.vertexAttribDivisor(1, 1);
-        }
-        {
-            const { buffer, stride = 0, offset = 0 } = pixelRadiusRatioBigBufferObj;
-            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 = 0, offset = 0 } = rgbaBufferObj;
-            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-            gl.enableVertexAttribArray(3);
-            gl.vertexAttribPointer(3, 4, gl.FLOAT, false, stride, offset);
-            gl.vertexAttribDivisor(3, 1);
-        }
-
-        gl.bindVertexArray(null);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-        return vao;
-
-    }
-
-
-
-
-    free() {
-        const { globe } = this;
-        CameraUniformBlockTotemCache.release(globe);
-    }
-}
-
-
-
-export const PixelPaddingForFlatCompassCache = Object.freeze({
-    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, Logic),
-    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, Logic)
-})
+`;
+class Logic {
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this._lastOpacity = 1;
+        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
+        const { gl, program } = this;
+        { // assign attribute locations
+            //             in vec2 screen_coordinate;
+            // in float pixel_radius_small_ratio;
+            // in float pixel_radius_big_ratio;
+            // in vec4 rgba;
+            gl.bindAttribLocation(program, 0, "screen_coordinate");
+            gl.bindAttribLocation(program, 1, "pixel_radius_small_ratio");
+            gl.bindAttribLocation(program, 2, "pixel_radius_big_ratio");
+            gl.bindAttribLocation(program, 3, "rgba");
+        }
+        {
+            this._opacityLocation = gl.getUniformLocation(program, "plugin_opacity");
+            const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+            gl.useProgram(program);
+            gl.uniform1f(this._opacityLocation, this._lastOpacity);
+            gl.useProgram(currentProgram);
+        }
+        {
+            this.cameraBlockBindingPoint = 0;
+            const cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+            this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
+            gl.uniformBlockBinding(program, cameraBlockIndex, this.cameraBlockBindingPoint);
+        }
+    }
+    draw(vao, length, opacity) {
+        const { globe, gl, program, cameraBlockTotem, cameraBlockBindingPoint, _opacityLocation } = this;
+        if (globe.api_GetCurrentGeometry() === 0)
+            return;
+        gl.useProgram(program);
+        cameraBlockTotem.bind(cameraBlockBindingPoint);
+        if (opacity !== this._lastOpacity) {
+            this._lastOpacity = opacity;
+            gl.uniform1f(_opacityLocation, opacity);
+        }
+        gl.bindVertexArray(vao);
+        gl.drawArraysInstanced(gl.LINES, 0, vertexCount, length);
+        gl.bindVertexArray(null);
+        cameraBlockTotem.unbind(cameraBlockBindingPoint);
+    }
+    createVAO(screenCoordsBufferObj, pixelRadiusRatioSmallBufferObj, pixelRadiusRatioBigBufferObj, rgbaBufferObj) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        {
+            const { buffer, stride = 0, offset = 0 } = screenCoordsBufferObj;
+            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 = 0, offset = 0 } = pixelRadiusRatioSmallBufferObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(1);
+            gl.vertexAttribPointer(1, 1, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(1, 1);
+        }
+        {
+            const { buffer, stride = 0, offset = 0 } = pixelRadiusRatioBigBufferObj;
+            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 = 0, offset = 0 } = rgbaBufferObj;
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.enableVertexAttribArray(3);
+            gl.vertexAttribPointer(3, 4, gl.FLOAT, false, stride, offset);
+            gl.vertexAttribDivisor(3, 1);
+        }
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return vao;
+    }
+    free() {
+        const { globe } = this;
+        CameraUniformBlockTotemCache.release(globe);
+    }
+}
+export const PixelPaddingForFlatCompassCache = Object.freeze({
+    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, Logic),
+    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, Logic)
+});

package/programs/util.js

@@ -1,19 +1,14 @@
-
-
-function longlatbbox2normalbbox({ minLon = -180, maxLon = 180, minLat = -90, maxLat = 90 } = {}) {
-    // x
-    const horOffset = (minLon) * Math.PI / 180;
-    const horSize = (maxLon - minLon) * Math.PI / 180;
-    // y
-    const vertOffset = (90 - maxLat) * Math.PI / 180;
-    const vertSize = (maxLat - minLat) * Math.PI / 180;
-
-    const result = {
-        bboxOffsetRad: new Float32Array([horOffset, vertOffset]),
-        bboxSizeRad: new Float32Array([horSize, vertSize])
-    };
-    return result;
-}
-
-
-export { longlatbbox2normalbbox }
+function longlatbbox2normalbbox({ minLon = -180, maxLon = 180, minLat = -90, maxLat = 90 } = {}) {
+    // x
+    const horOffset = (minLon) * Math.PI / 180;
+    const horSize = (maxLon - minLon) * Math.PI / 180;
+    // y
+    const vertOffset = (90 - maxLat) * Math.PI / 180;
+    const vertSize = (maxLat - minLat) * Math.PI / 180;
+    const result = {
+        bboxOffsetRad: new Float32Array([horOffset, vertOffset]),
+        bboxSizeRad: new Float32Array([horSize, vertSize])
+    };
+    return result;
+}
+export { longlatbbox2normalbbox };

package/programs/vectorfields/index.js

@@ -1,3 +1,3 @@
-import PingPongBufferManager from './pingpongbuffermanager';
-export * from './logics';
-export { PingPongBufferManager };
+import PingPongBufferManager from './pingpongbuffermanager';
+export * from './logics';
+export { PingPongBufferManager };

package/programs/vectorfields/logics/drawrectangleparticles.js

@@ -1,14 +1,13 @@
-import { createProgram } from "../../../util";
-import { UBO_BINDING_POINT, shaderUboSource } from "./ubo.js";
-import { glProgramCache } from "../../programcache";
-import { SeaWaveUbo } from "./ubo-new";
-/**
- * [+] ubo 
- */
-
+import { createProgram } from "../../../util";
+import { UBO_BINDING_POINT, shaderUboSource } from "./ubo.js";
+import { glProgramCache } from "../../programcache";
+import { SeaWaveUbo } from "./ubo-new";
+/**
+ * [+] ubo
+ */
 const vertexShaderSource = `#version 300 es
 precision highp float;
-`+ SeaWaveUbo.glslCode() + `
+` + SeaWaveUbo.glslCode() + `
 uniform sampler2D u_vector_field;
 in vec2 in_position;
 out vec3 base_color;
@@ -56,78 +55,59 @@ void main(){
     vec2 pos = in_position * 2.0 - 1.0;
     gl_Position = vec4(pos + limp, 0.0, 1.0);
     base_color = color;
-}`;
-
-
+}`;
 const fragmentShaderSource = `#version 300 es
 precision highp float;
 out vec4 outColor;
 in vec3 base_color;
 void main(){
     outColor = vec4(base_color, 1.0);
-}`;
-
-
-class Logic {
-
-    constructor(gl) {
-        this.gl = gl;
-        [this.program,
-        this._vector_field_location] = this._createProgram();
-        // this.decoyBuffer = new DecoyBufferManager(gl);
-    }
-
-    _createProgram() {
-        const gl = this.gl;
-        const program = createProgram(gl, vertexShaderSource, fragmentShaderSource);
-        // ubo point
-        // const ubo_location = gl.getUniformBlockIndex(program, 'UBO');
-        // gl.uniformBlockBinding(program, ubo_location, UBO_BINDING_POINT);
-        SeaWaveUbo.assignBindingPoint(gl, program, 0);
-        return [program, gl.getUniformLocation(program, 'u_vector_field')];
-    }
-
-
-
-    /**
-     * @param {*} bufferManager | PingPongBufferManager
-     * @param {*} vectorTexture | RG32F texture R: x, G: y
-     * @param {*} uboManager | WaveParticalUboManager under ubo.js
-     */
-    draw(bufferManager, vectorTexture, uboManager) {
-        const { gl, program } = this;
-        gl.useProgram(program);
-        gl.bindVertexArray(bufferManager.getSourceVao());
-        // gl.bindVertexArray(this.decoyBuffer.getSourceVao());
-
-        uboManager.bind();
-
-        gl.activeTexture(gl.TEXTURE0);
-        gl.uniform1i(this._vector_field_location, 0);
-        gl.bindTexture(
-            gl.TEXTURE_2D,
-            vectorTexture
-        );
-        gl.drawArraysInstanced(gl.TRIANGLE_FAN, 0, 4, bufferManager.length);
-        gl.drawArraysInstanced(gl.POINTS, 0, 4, bufferManager.length);
-        gl.bindVertexArray(null);
-        uboManager.unbind();
-    }
-
-    free() {
-        this.gl.deleteProgram(this.program);
-        this.program = null;
-    }
-
-}
-
-
-
-export const drawRectangleParticlesProgramCache = Object.freeze({
-    getProgram: (gl) => {
-        return glProgramCache.getProgram(gl, Logic);
-    },
-    releaseProgram: (gl) => {
-        glProgramCache.releaseProgram(gl, Logic);
-    }
-});
+}`;
+class Logic {
+    constructor(gl) {
+        this.gl = gl;
+        [this.program,
+            this._vector_field_location] = this._createProgram();
+        // this.decoyBuffer = new DecoyBufferManager(gl);
+    }
+    _createProgram() {
+        const gl = this.gl;
+        const program = createProgram(gl, vertexShaderSource, fragmentShaderSource);
+        // ubo point
+        // const ubo_location = gl.getUniformBlockIndex(program, 'UBO');
+        // gl.uniformBlockBinding(program, ubo_location, UBO_BINDING_POINT);
+        SeaWaveUbo.assignBindingPoint(gl, program, 0);
+        return [program, gl.getUniformLocation(program, 'u_vector_field')];
+    }
+    /**
+     * @param {*} bufferManager | PingPongBufferManager
+     * @param {*} vectorTexture | RG32F texture R: x, G: y
+     * @param {*} uboManager | WaveParticalUboManager under ubo.js
+     */
+    draw(bufferManager, vectorTexture, uboManager) {
+        const { gl, program } = this;
+        gl.useProgram(program);
+        gl.bindVertexArray(bufferManager.getSourceVao());
+        // gl.bindVertexArray(this.decoyBuffer.getSourceVao());
+        uboManager.bind();
+        gl.activeTexture(gl.TEXTURE0);
+        gl.uniform1i(this._vector_field_location, 0);
+        gl.bindTexture(gl.TEXTURE_2D, vectorTexture);
+        gl.drawArraysInstanced(gl.TRIANGLE_FAN, 0, 4, bufferManager.length);
+        gl.drawArraysInstanced(gl.POINTS, 0, 4, bufferManager.length);
+        gl.bindVertexArray(null);
+        uboManager.unbind();
+    }
+    free() {
+        this.gl.deleteProgram(this.program);
+        this.program = null;
+    }
+}
+export const drawRectangleParticlesProgramCache = Object.freeze({
+    getProgram: (gl) => {
+        return glProgramCache.getProgram(gl, Logic);
+    },
+    releaseProgram: (gl) => {
+        glProgramCache.releaseProgram(gl, Logic);
+    }
+});

package/programs/vectorfields/logics/index.js

@@ -1,4 +1,2 @@
-
-import { WaveParticalUboManager } from './ubo';
-
-export { WaveParticalUboManager };
+import { WaveParticalUboManager } from './ubo';
+export { WaveParticalUboManager };

package/programs/vectorfields/logics/pixelbased.js

@@ -1,14 +1,11 @@
-import { createShader } from "../../../util";
-import { UBO_SIZE, UBO_BINDING_POINT, shaderUboSource } from "./ubo.js";
-import { glProgramCache } from "../../programcache";
-
-import { SeaWaveUbo } from "./ubo-new";
-
-// program output is buffer
-// TODO: Mechanism for randomness
-//  drop out mechanism
-//  random particle position mechanism
-
+import { createShader } from "../../../util";
+import { UBO_SIZE, UBO_BINDING_POINT, shaderUboSource } from "./ubo.js";
+import { glProgramCache } from "../../programcache";
+import { SeaWaveUbo } from "./ubo-new";
+// program output is buffer
+// TODO: Mechanism for randomness
+//  drop out mechanism
+//  random particle position mechanism
 const vertexShaderSource = `#version 300 es
 ` + SeaWaveUbo.glslCode() + `
 
@@ -73,87 +70,71 @@ void main(){
     }
     out_position = in_position + (vec / draw_texture_size)  * range;
 }
-`;
-
+`;
 const fragmentShaderSource = `#version 300 es
 precision highp float;
 void main(){
-}`;
-
-
-class Logic {
-    constructor(gl) {
-        this.gl = gl;
-        [this.program, this._vector_field_location] = this._createProgram();
-
-    }
-
-    /**
-     * @param {*} bufferManager | PingPongBufferManager
-     * @param {*} vectorTexture RG32F texture R: x, G: y
-     * @param {*} uboManager | WaveParticalUboManager under ubo.js
-     */
-    move(bufferManager, vectorTexture, uboManager) {
-        const { gl, program, _vector_field_location } = this;
-        gl.useProgram(program);
-        gl.enable(gl.RASTERIZER_DISCARD);
-        gl.bindVertexArray(bufferManager.getSourceVao());
-        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, bufferManager.getTargetTF());
-        gl.beginTransformFeedback(gl.POINTS);
-        uboManager.bind();
-        gl.activeTexture(gl.TEXTURE0);
-        gl.bindTexture(gl.TEXTURE_2D, vectorTexture);
-        gl.uniform1i(_vector_field_location, 0);
-        gl.drawArraysInstanced(gl.POINTS, 0, 1, bufferManager.length);
-        gl.endTransformFeedback();
-        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);
-        gl.bindVertexArray(null);
-        uboManager.unbind();
-        gl.disable(gl.RASTERIZER_DISCARD);
-    }
-
-
-    // -- private methods
-
-    _createProgram() {
-        const gl = this.gl;
-        const vertexShader = createShader(gl, gl.VERTEX_SHADER, vertexShaderSource);
-        const fragmentShader = createShader(gl, gl.FRAGMENT_SHADER, fragmentShaderSource);
-        const program = gl.createProgram();
-        gl.attachShader(program, vertexShader);
-        gl.attachShader(program, fragmentShader);
-        gl.transformFeedbackVaryings(
-            program,
-            ["out_position"],
-            gl.SEPARATE_ATTRIBS
-        );
-        gl.linkProgram(program);
-        if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-            throw new Error(gl.getProgramParameter(program));
-        }
-        // const ubo_location = gl.getUniformBlockIndex(program, 'UBO');
-        // gl.uniformBlockBinding(program, ubo_location, UBO_BINDING_POINT);
-        SeaWaveUbo.assignBindingPoint(gl, program, 0);
-        return [program, gl.getUniformLocation(program, 'vector_field')];;
-    }
-
-    free() {
-        this.gl.deleteProgram(this.program);
-        this.program = null;
-    }
-
-    getInPositionLocation() {
-        return this.gl.getAttribLocation(this.program, 'in_position');
-    }
-}
-
-
-
-export const pixelBasedMoveProgramCache = Object.freeze({
-    getProgram: (gl) => {
-        return glProgramCache.getProgram(gl, Logic);
-    },
-    releaseProgram: (gl) => {
-        glProgramCache.releaseProgram(gl, Logic);
-    }
-});
+}`;
+class Logic {
+    constructor(gl) {
+        this.gl = gl;
+        [this.program, this._vector_field_location] = this._createProgram();
+    }
+    /**
+     * @param {*} bufferManager | PingPongBufferManager
+     * @param {*} vectorTexture RG32F texture R: x, G: y
+     * @param {*} uboManager | WaveParticalUboManager under ubo.js
+     */
+    move(bufferManager, vectorTexture, uboManager) {
+        const { gl, program, _vector_field_location } = this;
+        gl.useProgram(program);
+        gl.enable(gl.RASTERIZER_DISCARD);
+        gl.bindVertexArray(bufferManager.getSourceVao());
+        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, bufferManager.getTargetTF());
+        gl.beginTransformFeedback(gl.POINTS);
+        uboManager.bind();
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, vectorTexture);
+        gl.uniform1i(_vector_field_location, 0);
+        gl.drawArraysInstanced(gl.POINTS, 0, 1, bufferManager.length);
+        gl.endTransformFeedback();
+        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);
+        gl.bindVertexArray(null);
+        uboManager.unbind();
+        gl.disable(gl.RASTERIZER_DISCARD);
+    }
+    // -- private methods
+    _createProgram() {
+        const gl = this.gl;
+        const vertexShader = createShader(gl, gl.VERTEX_SHADER, vertexShaderSource);
+        const fragmentShader = createShader(gl, gl.FRAGMENT_SHADER, fragmentShaderSource);
+        const program = gl.createProgram();
+        gl.attachShader(program, vertexShader);
+        gl.attachShader(program, fragmentShader);
+        gl.transformFeedbackVaryings(program, ["out_position"], gl.SEPARATE_ATTRIBS);
+        gl.linkProgram(program);
+        if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+            throw new Error(gl.getProgramParameter(program));
+        }
+        // const ubo_location = gl.getUniformBlockIndex(program, 'UBO');
+        // gl.uniformBlockBinding(program, ubo_location, UBO_BINDING_POINT);
+        SeaWaveUbo.assignBindingPoint(gl, program, 0);
+        return [program, gl.getUniformLocation(program, 'vector_field')];
+        ;
+    }
+    free() {
+        this.gl.deleteProgram(this.program);
+        this.program = null;
+    }
+    getInPositionLocation() {
+        return this.gl.getAttribLocation(this.program, 'in_position');
+    }
+}
+export const pixelBasedMoveProgramCache = Object.freeze({
+    getProgram: (gl) => {
+        return glProgramCache.getProgram(gl, Logic);
+    },
+    releaseProgram: (gl) => {
+        glProgramCache.releaseProgram(gl, Logic);
+    }
+});