@pirireis/webglobeplugins 0.15.34 → 0.16.0

package/programs/line-on-globe/degree-padding-around-circle-3d.js

@@ -1,19 +1,27 @@
-import { createProgram } from "../../util/index";
-import { CameraUniformBlockString, CameraUniformBlockTotemCache } from "../totems/camerauniformblock";
-import { noRegisterGlobeProgramCache } from "../programcache";
-// import { vaoAttributeLoader } from "../../util/account/util";
-import { attributeLoader } from "../../util/gl-util/buffer/attribute-loader";
-import { Z_ALPHA_MODE } from "./util";
-import { cartesian3DToGLPosition, circleLimpFromLongLatRadCenterCartesian3D_accurate, POLE, } from "../../util/shaderfunctions/geometrytransformations";
-/**
- * TODO:
- * 1. integrate geometry functions for radius angle and center
- * 2. integrate attributes
- *
- * TODO:
- * center_position is too small or doenst loaded as expected.
- */
-const INITIAL_EDGE_COUNT = 720;
+import { createProgram } from "../../util/index";
+import { CameraUniformBlockString, CameraUniformBlockTotemCache } from "../totems/camerauniformblock";
+import { noRegisterGlobeProgramCache } from "../programcache";
+// import { vaoAttributeLoader } from "../../util/account/util";
+import { attributeLoader } from "../../util/gl-util/buffer/attribute-loader";
+import { Z_ALPHA_MODE } from "./util";
+import {
+    cartesian3DToGLPosition,
+    circleLimpFromLongLatRadCenterCartesian3D_accurate,
+    POLE,
+} from "../../util/shaderfunctions/geometrytransformations";
+
+
+/**
+ * TODO: 
+ * 1. integrate geometry functions for radius angle and center
+ * 2. integrate attributes
+ * 
+ * TODO:
+ * center_position is too small or doenst loaded as expected.
+ */
+
+const INITIAL_EDGE_COUNT = 720;
+
 const vertexShaderSource = `#version 300 es
 precision highp float;
 ${CameraUniformBlockString}
@@ -54,7 +62,8 @@ void main() {
     gl_Position = cartesian3DToGLPosition(position);
 
     gl_PointSize = 5.0;
-}`;
+}`
+
 const fragmentShaderSource = `#version 300 es
 ${POLE}
 precision highp float;
@@ -67,90 +76,113 @@ void main() {
     color = v_color;
     color.a *= opacity;
 }
-`;
-class Logic {
-    constructor(globe) {
-        this.globe = globe;
-        this.gl = globe.gl;
-        this._lastOpacity = 1.0;
-        this._lastEdgeCount = INITIAL_EDGE_COUNT;
-        this._lastStepAngle = 720 / INITIAL_EDGE_COUNT;
-        this._lastZAlphaMode = Z_ALPHA_MODE.ON;
-        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
-        const { gl, program } = this;
-        this.program.uniforms = {
-            opacity: gl.getUniformLocation(program, "opacity"),
-            edgeCount: gl.getUniformLocation(program, "edge_count"),
-            stepAngle: gl.getUniformLocation(program, "step_angle"),
-            zAlphaMode: gl.getUniformLocation(program, "z_alpha_on")
-        };
-        { // initial uniform values
-            const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-            gl.useProgram(program);
-            gl.uniform1f(program.uniforms.opacity, 1.0);
-            gl.uniform1f(program.uniforms.edgeCount, INITIAL_EDGE_COUNT * 2);
-            gl.uniform1f(program.uniforms.stepAngle, this._lastStepAngle * Math.PI / 360);
-            gl.uniform1i(program.uniforms.zAlphaMode, Z_ALPHA_MODE.ON);
-            gl.useProgram(currentProgram);
-        }
-        { // assign attribute locations
-            gl.bindAttribLocation(program, 0, "center_position3d");
-            gl.bindAttribLocation(program, 1, "big_radius");
-            gl.bindAttribLocation(program, 2, "small_radius");
-            gl.bindAttribLocation(program, 3, "color");
-        }
-        this.cameraBindingPoint = 0;
-        this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
-        const cameraBlockLocation = gl.getUniformBlockIndex(program, "CameraUniformBlock");
-        gl.uniformBlockBinding(program, cameraBlockLocation, this.cameraBindingPoint);
-    }
-    createVAO(center3dObj, bigRadiusObj, smallRadiusObj, colorObj) {
-        const { gl } = this;
-        const vao = gl.createVertexArray();
-        const divisor = 1;
-        gl.bindVertexArray(vao);
-        attributeLoader(gl, center3dObj, 0, 3, { divisor });
-        attributeLoader(gl, bigRadiusObj, 1, 1, { divisor });
-        attributeLoader(gl, smallRadiusObj, 2, 1, { divisor });
-        attributeLoader(gl, colorObj, 3, 4, { divisor });
-        gl.bindVertexArray(null);
-        return vao;
-    }
-    draw(vao, length, edgeCount, stepAngle, opacity, zAlphaMode = Z_ALPHA_MODE.ON) {
-        const { gl, program, cameraBlockTotem, cameraBindingPoint } = this;
-        gl.useProgram(program);
-        if (this._lastOpacity !== opacity) {
-            gl.uniform1f(program.uniforms.opacity, opacity);
-            this._lastOpacity = opacity;
-        }
-        if (this._lastEdgeCount !== edgeCount) {
-            gl.uniform1f(program.uniforms.edgeCount, 2 * edgeCount);
-            this._lastEdgeCount = edgeCount;
-        }
-        if (this._lastStepAngle !== stepAngle) {
-            gl.uniform1f(program.uniforms.stepAngle, stepAngle * Math.PI / 360);
-            this._lastStepAngle = stepAngle;
-        }
-        if (this._lastZAlphaMode !== zAlphaMode) {
-            gl.uniform1i(program.uniforms.zAlphaMode, zAlphaMode);
-            this._lastZAlphaMode = zAlphaMode;
-        }
-        gl.bindVertexArray(vao);
-        cameraBlockTotem.bind(cameraBindingPoint);
-        gl.drawArraysInstanced(gl.LINES, 0, edgeCount * 2, length);
-        // gl.drawArraysInstanced(gl.POINTS, 0, edgeCount, length);
-        cameraBlockTotem.unbind(cameraBindingPoint);
-        gl.bindVertexArray(null);
-    }
-    free() {
-        if (this.isFreed)
-            return;
-        CameraUniformBlockTotemCache.release(this.globe);
-        this.gl.deleteProgram(this.program);
-        this.isFreed = true;
-    }
-}
-export const CirclePadding3DCache = 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.0;
+        this._lastEdgeCount = INITIAL_EDGE_COUNT;
+        this._lastStepAngle = 720 / INITIAL_EDGE_COUNT;
+        this._lastZAlphaMode = Z_ALPHA_MODE.ON;
+        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
+
+        const { gl, program } = this;
+        this.program.uniforms = {
+            opacity: gl.getUniformLocation(program, "opacity"),
+            edgeCount: gl.getUniformLocation(program, "edge_count"),
+            stepAngle: gl.getUniformLocation(program, "step_angle"),
+            zAlphaMode: gl.getUniformLocation(program, "z_alpha_on")
+        };
+
+        { // initial uniform values
+            const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+            gl.useProgram(program);
+            gl.uniform1f(program.uniforms.opacity, 1.0);
+            gl.uniform1f(program.uniforms.edgeCount, INITIAL_EDGE_COUNT * 2);
+            gl.uniform1f(program.uniforms.stepAngle, this._lastStepAngle * Math.PI / 360);
+            gl.uniform1i(program.uniforms.zAlphaMode, Z_ALPHA_MODE.ON);
+            gl.useProgram(currentProgram);
+        }
+
+        {   // assign attribute locations
+            gl.bindAttribLocation(program, 0, "center_position3d");
+            gl.bindAttribLocation(program, 1, "big_radius");
+            gl.bindAttribLocation(program, 2, "small_radius");
+            gl.bindAttribLocation(program, 3, "color");
+
+        }
+
+        this.cameraBindingPoint = 0;
+        this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
+        const cameraBlockLocation = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+        gl.uniformBlockBinding(program, cameraBlockLocation, this.cameraBindingPoint);
+    }
+
+    createVAO(center3dObj, bigRadiusObj, smallRadiusObj, colorObj) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        const divisor = 1;
+        gl.bindVertexArray(vao);
+
+
+        attributeLoader(gl, center3dObj, 0, 3, { divisor });
+
+        attributeLoader(gl, bigRadiusObj, 1, 1, { divisor });
+
+        attributeLoader(gl, smallRadiusObj, 2, 1, { divisor });
+
+        attributeLoader(gl, colorObj, 3, 4, { divisor });
+
+        gl.bindVertexArray(null);
+        return vao;
+    }
+
+    draw(vao, length, edgeCount, stepAngle, opacity, zAlphaMode = Z_ALPHA_MODE.ON) {
+        const { gl, program, cameraBlockTotem, cameraBindingPoint } = this;
+        gl.useProgram(program);
+
+        if (this._lastOpacity !== opacity) {
+            gl.uniform1f(program.uniforms.opacity, opacity);
+            this._lastOpacity = opacity;
+        }
+        if (this._lastEdgeCount !== edgeCount) {
+            gl.uniform1f(program.uniforms.edgeCount, 2 * edgeCount);
+            this._lastEdgeCount = edgeCount;
+        }
+        if (this._lastStepAngle !== stepAngle) {
+            gl.uniform1f(program.uniforms.stepAngle, stepAngle * Math.PI / 360);
+            this._lastStepAngle = stepAngle;
+        }
+        if (this._lastZAlphaMode !== zAlphaMode) {
+            gl.uniform1i(program.uniforms.zAlphaMode, zAlphaMode);
+            this._lastZAlphaMode = zAlphaMode;
+        }
+        gl.bindVertexArray(vao);
+        cameraBlockTotem.bind(cameraBindingPoint);
+        gl.drawArraysInstanced(gl.LINES, 0, edgeCount * 2, length);
+        // gl.drawArraysInstanced(gl.POINTS, 0, edgeCount, length);
+        cameraBlockTotem.unbind(cameraBindingPoint);
+        gl.bindVertexArray(null);
+    }
+
+
+
+    free() {
+        if (this.isFreed) return;
+        CameraUniformBlockTotemCache.release(this.globe);
+        this.gl.deleteProgram(this.program);
+        this.isFreed = true;
+    }
+}
+
+
+
+export const CirclePadding3DCache = Object.freeze({
+    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, Logic),
+    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, Logic)
+});

package/programs/line-on-globe/index.js

@@ -1 +0,0 @@
-"use strict";

package/programs/line-on-globe/lines-color-instanced-flat.js

@@ -1,13 +1,16 @@
-import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../totems";
-import { mercatorXYToGLPosition, POLE } from "../../util/shaderfunctions/geometrytransformations";
-import { noRegisterGlobeProgramCache } from "../programcache";
-import { createProgram } from "../../util";
-import { Z_ALPHA_MODE } from "./util";
-import { attributeLoader } from "../../util/gl-util/buffer/attribute-loader";
-/**
- * This program draws line between points provided from the first and second buffer.
- * draw method gl.drawArraysInstanced( gl.POINTS, 0,2, lineCount);
- * */
+import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../totems";
+import { mercatorXYToGLPosition, POLE } from "../../util/shaderfunctions/geometrytransformations";
+import { noRegisterGlobeProgramCache } from "../programcache";
+import { createProgram } from "../../util";
+import { Z_ALPHA_MODE } from "./util";
+import { attributeLoader } from "../../util/gl-util/buffer/attribute-loader";
+
+/**
+ * This program draws line between points provided from the first and second buffer.
+ * draw method gl.drawArraysInstanced( gl.POINTS, 0,2, lineCount);
+ * */
+
+
 const vertexShaderSource = `#version 300 es
 precision highp float;
 ${CameraUniformBlockString}
@@ -47,7 +50,9 @@ void main() {
     v_color = color;
     v_color.a *= z_alpha * opacity;
     gl_PointSize = 4.0;
-}`;
+}`;
+
+
 const fragmentShaderSource = `#version 300 es
 ${POLE}
 precision highp float;
@@ -57,75 +62,89 @@ out vec4 outColor;
 void main() {
     if ( v_frame.x < -POLE || v_frame.x > POLE || v_frame.y < -POLE || v_frame.y > POLE ){ discard; }
     outColor = v_color;
-}`;
-class Logic {
-    constructor(globe) {
-        this.globe = globe;
-        this.gl = globe.gl;
-        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
-        this._lastOpicity = 1.0;
-        this._lastZAlphaOn = Z_ALPHA_MODE.OFF;
-        const { gl, program } = this;
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-        gl.useProgram(program);
-        { // assign attribute locations
-            gl.bindAttribLocation(program, 0, 'posA');
-            gl.bindAttribLocation(program, 1, 'posB');
-            gl.bindAttribLocation(program, 2, 'color');
-        }
-        { // uniform locations
-            this._opacityLocation = gl.getUniformLocation(program, 'opacity');
-            this._zAlphaOnLocation = gl.getUniformLocation(program, 'z_alpha_on');
-            gl.uniform1i(this._zAlphaOnLocation, this._lastZAlphaOn);
-            gl.uniform1f(this._opacityLocation, this._lastOpicity);
-        }
-        { // uniform block
-            this._cameraUniformBlock = CameraUniformBlockTotemCache.get(globe);
-            this._cameraBindingPoint = 0;
-            const cameraBlockBindingIndex = gl.getUniformBlockIndex(program, 'CameraUniformBlock');
-            gl.uniformBlockBinding(program, cameraBlockBindingIndex, this._cameraBindingPoint);
-        }
-        gl.useProgram(currentProgram);
-    }
-    createVAO(posAObj, posBObj, colorObj) {
-        const { gl } = this;
-        const vao = gl.createVertexArray();
-        const divisor = 1;
-        gl.bindVertexArray(vao);
-        attributeLoader(gl, posAObj, 0, 2, { divisor });
-        attributeLoader(gl, posBObj, 1, 2, { divisor });
-        attributeLoader(gl, colorObj, 2, 4, { divisor });
-        gl.bindVertexArray(null);
-        return vao;
-    }
-    draw(vao, lineCount, opacity = 1.0, zAlphaOn = Z_ALPHA_MODE.ON) {
-        const { gl, program, _cameraBindingPoint, _cameraUniformBlock } = this;
-        gl.useProgram(program);
-        _cameraUniformBlock.bind(_cameraBindingPoint);
-        gl.bindVertexArray(vao);
-        if (this._lastOpicity !== opacity) {
-            this._lastOpicity = opacity;
-            gl.uniform1f(this._opacityLocation, opacity);
-        }
-        if (this._lastZAlphaOn !== zAlphaOn) {
-            this._lastZAlphaOn = zAlphaOn;
-            gl.uniform1i(this._zAlphaOnLocation, zAlphaOn);
-        }
-        gl.drawArraysInstanced(gl.LINES, 0, 2, lineCount);
-        _cameraUniformBlock.unbind(_cameraBindingPoint);
-        gl.bindVertexArray(null);
-    }
-    free() {
-        if (this.isFreed)
-            return;
-        const { gl, program, globe } = this;
-        CameraUniformBlockTotemCache.release(globe);
-        gl.deleteProgram(program);
-        this.isFreed = true;
-    }
-}
-const LinesColorInstancedFlatCache = Object.freeze({
-    get: (globe) => { return noRegisterGlobeProgramCache.getProgram(globe, Logic); },
-    release: (globe) => { noRegisterGlobeProgramCache.releaseProgram(globe, Logic); }
-});
-export { LinesColorInstancedFlatCache, Z_ALPHA_MODE };
+}`;
+
+
+class Logic {
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
+        this._lastOpicity = 1.0;
+        this._lastZAlphaOn = Z_ALPHA_MODE.OFF;
+
+        const { gl, program } = this;
+        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(program);
+        { // assign attribute locations
+            gl.bindAttribLocation(program, 0, 'posA');
+            gl.bindAttribLocation(program, 1, 'posB');
+            gl.bindAttribLocation(program, 2, 'color');
+        }
+
+        {   // uniform locations
+            this._opacityLocation = gl.getUniformLocation(program, 'opacity');
+            this._zAlphaOnLocation = gl.getUniformLocation(program, 'z_alpha_on');
+            gl.uniform1i(this._zAlphaOnLocation, this._lastZAlphaOn);
+            gl.uniform1f(this._opacityLocation, this._lastOpicity);
+        }
+        {   // uniform block
+            this._cameraUniformBlock = CameraUniformBlockTotemCache.get(globe);
+            this._cameraBindingPoint = 0;
+            const cameraBlockBindingIndex = gl.getUniformBlockIndex(program, 'CameraUniformBlock');
+            gl.uniformBlockBinding(program, cameraBlockBindingIndex, this._cameraBindingPoint);
+        }
+        gl.useProgram(currentProgram);
+    }
+
+
+    createVAO(posAObj, posBObj, colorObj) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        const divisor = 1;
+        gl.bindVertexArray(vao);
+        attributeLoader(gl, posAObj, 0, 2, { divisor });
+        attributeLoader(gl, posBObj, 1, 2, { divisor });
+        attributeLoader(gl, colorObj, 2, 4, { divisor });
+        gl.bindVertexArray(null);
+        return vao;
+    }
+
+
+    draw(vao, lineCount, opacity = 1.0, zAlphaOn = Z_ALPHA_MODE.ON) {
+        const { gl, program, _cameraBindingPoint, _cameraUniformBlock } = this;
+        gl.useProgram(program);
+        _cameraUniformBlock.bind(_cameraBindingPoint);
+        gl.bindVertexArray(vao);
+        if (this._lastOpicity !== opacity) {
+            this._lastOpicity = opacity;
+            gl.uniform1f(this._opacityLocation, opacity);
+        }
+        if (this._lastZAlphaOn !== zAlphaOn) {
+            this._lastZAlphaOn = zAlphaOn;
+            gl.uniform1i(this._zAlphaOnLocation, zAlphaOn);
+        }
+        gl.drawArraysInstanced(gl.LINES, 0, 2, lineCount);
+        _cameraUniformBlock.unbind(_cameraBindingPoint);
+        gl.bindVertexArray(null);
+    }
+
+
+    free() {
+        if (this.isFreed) return;
+        const { gl, program, globe } = this;
+        CameraUniformBlockTotemCache.release(globe);
+        gl.deleteProgram(program);
+        this.isFreed = true;
+    }
+}
+
+
+const LinesColorInstancedFlatCache = Object.freeze({
+    get: (globe) => { return noRegisterGlobeProgramCache.getProgram(globe, Logic) },
+    release: (globe) => { noRegisterGlobeProgramCache.releaseProgram(globe, Logic) }
+});
+
+export { LinesColorInstancedFlatCache, Z_ALPHA_MODE };
+
+

package/programs/line-on-globe/linestrip/data.ts

@@ -0,0 +1,29 @@
+import { Color, Globe, UBOHandler } from "../../../types";
+import { BufferManagersMap, BufferManager, BufferOrchestrator } from "../../../util/account/single-attribute-buffer-management/index";
+import { LineProgram } from "./linestrip";
+import { globe3Dcoordinates, globe2Dcoordinates } from "../../../Math/methods"
+
+export type DrawStyleOptions = {
+    variativeColorsOn?: boolean; // If true, the color will be variative based on the circle's radius.
+    defaultColor: Color;
+    defaultHeightFromGroundIn3D?: number; // Default height from ground in 3D mode.|
+}
+
+
+export function createLineStripData(
+    program: LineProgram,
+    globe: Globe,
+    gl: WebGL2RenderingContext,
+    DrawStyleOptions: DrawStyleOptions,
+): {
+    bufferManagerMap: BufferManagersMap;
+    bufferOrchestrator: BufferOrchestrator;
+    uboHandler: UBOHandler
+    free(): void;
+} {
+
+
+
+    // @ts-ignore
+    return;
+}