@pirireis/webglobeplugins 1.0.2 → 1.0.3

package/programs/line-on-globe/linestrip/{linestrip.ts → linestrip.js}

@@ -1,40 +1,19 @@
-import { createProgram } from "../../../util/webglobjectbuilders";
-import { ProgramInterface, DrawRangeIndexParams, UBOHandler, BufferInfo } from "../../../types";
-import { CameraUniformBlockString, CameraUniformBlockTotemCache, CameraUniformBlockTotem } from "../../totems/index"
-
-import {
-    cartesian3DToGLPosition,
-    mercatorXYToGLPosition,
-} from "../../../util/shaderfunctions/geometrytransformations";
-
-import { noRegisterGlobeProgramCache } from "../../programcache";
-import { attributeLoader } from "../../../util/gl-util/buffer/attribute-loader";
-
-import { UniformBlockManager } from "../../../util/gl-util/uniform-block/manager";
-
-import { drawArrays } from "../../../util/gl-util/draw-options/methods";
-
-
-
-const ESCAPE_VALUE = -1;
-
-const uniformBindingPoints = {
-    camera: 0,
-    flexible: 1,
-}
-
-// const one = new Float32Array([1]);
-const flexibleBlockManager = new UniformBlockManager(
-    'FlexibleAttributes',
-    [
-        { name: "u_color", type: "vec4", value: new Float32Array([0.12, 1, 0.1, 1]) },
-    ],
-    uniformBindingPoints.flexible,
-);
-
-
-
-
+import { createProgram } from "../../../util/webglobjectbuilders";
+import { CameraUniformBlockString, CameraUniformBlockTotemCache } from "../../totems/index";
+import { cartesian3DToGLPosition, mercatorXYToGLPosition, } from "../../../util/shaderfunctions/geometrytransformations";
+import { noRegisterGlobeProgramCache } from "../../programcache";
+import { attributeLoader } from "../../../util/gl-util/buffer/attribute-loader";
+import { UniformBlockManager } from "../../../util/gl-util/uniform-block/manager";
+import { drawArrays } from "../../../util/gl-util/draw-options/methods";
+const ESCAPE_VALUE = -1;
+const uniformBindingPoints = {
+    camera: 0,
+    flexible: 1,
+};
+// const one = new Float32Array([1]);
+const flexibleBlockManager = new UniformBlockManager('FlexibleAttributes', [
+    { name: "u_color", type: "vec4", value: new Float32Array([0.12, 1, 0.1, 1]) },
+], uniformBindingPoints.flexible);
 const vertexShaderSource = `#version 300 es
 precision highp float;
 
@@ -67,9 +46,7 @@ void main() {
         v_flat_position = vec3( position2d, 0.0 );
     }
     gl_PointSize = 6.0;
-}`;
-
-
+}`;
 const fragmentShaderSource = `#version 300 es
 precision highp float;
 
@@ -87,115 +64,79 @@ out vec4 outColor;
 void main() {
     outColor = vec4( v_color.rgb, v_color.a );
 
-}`;
-
-
-
-export class LineProgram implements ProgramInterface {
-
-    _vaosPublished: object[] = [];
-    _ubosPublished: UBOHandler[] = [];
-    program: WebGLProgram;
-    gl: WebGL2RenderingContext;
-    globe: any;
-    cameraBlockTotem: CameraUniformBlockTotem;
-    _defaultFlexibleUBO: UBOHandler;
-    _opacity: {
-        value: number,
-        location: WebGLUniformLocation | null
-    } = {
-            value: 1,
-            location: null
-        };
-
-    constructor(globe: any) {
-        this.gl = globe.gl;
-
-        this.globe = globe;
-        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource) as WebGLProgram;
-        const currentProgram = this.gl.getParameter(this.gl.CURRENT_PROGRAM);
-        this.gl.useProgram(this.program);
-        this._opacity.location = this.gl.getUniformLocation(this.program, "u_opacity");
-        this.gl.uniform1f(this._opacity.location, this._opacity.value);
-
-
-        // bind attribute locations
-        this.gl.bindAttribLocation(this.program, 0, "position3d");
-        this.gl.bindAttribLocation(this.program, 1, "position2d");
-        this.gl.bindAttribLocation(this.program, 2, "color");
-
-
-
-        this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
-        this.cameraBlockTotem.assignBindingPoint(this.program, uniformBindingPoints.camera);
-
-        flexibleBlockManager.assignBindingPoint(this.gl, this.program);
-        this._defaultFlexibleUBO = flexibleBlockManager.createUBO(this.gl);
-
-        this.gl.useProgram(currentProgram);
-    }
-
-
-
-    createUBO(bufferReadType: "STATIC_DRAW" | "DYNAMIC_DRAW" | "STREAM_DRAW" = "STATIC_DRAW"): UBOHandler {
-        const ubo = flexibleBlockManager.createUBO(this.gl, bufferReadType);
-        this._ubosPublished.push(ubo);
-        return ubo;
-    }
-
-
-
-    createVAO(
-        position3D: BufferInfo, position2D: BufferInfo, color: BufferInfo
-    ): WebGLVertexArrayObject {
-        const { gl } = this;
-        const vao = gl.createVertexArray();
-        gl.bindVertexArray(vao);
-        attributeLoader(gl, position3D, 0, 3);
-        attributeLoader(gl, position2D, 1, 2);
-        attributeLoader(gl, color, 2, 4, { escapeValues: [ESCAPE_VALUE, ESCAPE_VALUE, ESCAPE_VALUE, ESCAPE_VALUE] });
-
-        gl.bindVertexArray(null);
-        return vao;
-    }
-
-
-
-    draw(vao: WebGLVertexArrayObject, drawOptions: DrawRangeIndexParams, opacity: number = 1, flexibleUBO: UBOHandler | null = null) {
-
-        const { gl, program, cameraBlockTotem } = this;
-
-        gl.useProgram(program);
-        if (opacity !== this._opacity.value) {
-            this._opacity.value = opacity;
-            this.gl.uniform1f(this._opacity.location, this._opacity.value);
-        }
-        const ubo = flexibleUBO || this._defaultFlexibleUBO;
-        cameraBlockTotem.bind(uniformBindingPoints.camera);
-        ubo.bind();
-        gl.bindVertexArray(vao);
-        // drawArrays(gl, gl.POINTS, drawOptions);
-        drawArrays(gl, gl.LINE_STRIP, drawOptions);
-        gl.bindVertexArray(null);
-        ubo.unbind();
-        cameraBlockTotem.unbind(uniformBindingPoints.camera);
-    }
-
-
-
-    free() {
-        this._vaosPublished.forEach((vao: WebGLVertexArrayObject) => this.gl.deleteVertexArray(vao));
-        this._ubosPublished.forEach((ubo: UBOHandler) => ubo.free());
-        this.gl.deleteProgram(this.program);
-        this._defaultFlexibleUBO.free();
-        CameraUniformBlockTotemCache.release(this.globe);
-        this.gl.deleteProgram(this.program);
-
-    }
-}
-
-export const LineStripProgramCache = Object.freeze({
-    get: (globe: any): LineProgram => noRegisterGlobeProgramCache.getProgram(globe, LineProgram),
-    release: (globe: any) => noRegisterGlobeProgramCache.releaseProgram(globe, LineProgram),
-});
-
+}`;
+export class LineProgram {
+    _vaosPublished = [];
+    _ubosPublished = [];
+    program;
+    gl;
+    globe;
+    cameraBlockTotem;
+    _defaultFlexibleUBO;
+    _opacity = {
+        value: 1,
+        location: null
+    };
+    constructor(globe) {
+        this.gl = globe.gl;
+        this.globe = globe;
+        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
+        const currentProgram = this.gl.getParameter(this.gl.CURRENT_PROGRAM);
+        this.gl.useProgram(this.program);
+        this._opacity.location = this.gl.getUniformLocation(this.program, "u_opacity");
+        this.gl.uniform1f(this._opacity.location, this._opacity.value);
+        // bind attribute locations
+        this.gl.bindAttribLocation(this.program, 0, "position3d");
+        this.gl.bindAttribLocation(this.program, 1, "position2d");
+        this.gl.bindAttribLocation(this.program, 2, "color");
+        this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
+        this.cameraBlockTotem.assignBindingPoint(this.program, uniformBindingPoints.camera);
+        flexibleBlockManager.assignBindingPoint(this.gl, this.program);
+        this._defaultFlexibleUBO = flexibleBlockManager.createUBO(this.gl);
+        this.gl.useProgram(currentProgram);
+    }
+    createUBO(bufferReadType = "STATIC_DRAW") {
+        const ubo = flexibleBlockManager.createUBO(this.gl, bufferReadType);
+        this._ubosPublished.push(ubo);
+        return ubo;
+    }
+    createVAO(position3D, position2D, color) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        attributeLoader(gl, position3D, 0, 3);
+        attributeLoader(gl, position2D, 1, 2);
+        attributeLoader(gl, color, 2, 4, { escapeValues: [ESCAPE_VALUE, ESCAPE_VALUE, ESCAPE_VALUE, ESCAPE_VALUE] });
+        gl.bindVertexArray(null);
+        return vao;
+    }
+    draw(vao, drawOptions, opacity = 1, flexibleUBO = null) {
+        const { gl, program, cameraBlockTotem } = this;
+        gl.useProgram(program);
+        if (opacity !== this._opacity.value) {
+            this._opacity.value = opacity;
+            this.gl.uniform1f(this._opacity.location, this._opacity.value);
+        }
+        const ubo = flexibleUBO || this._defaultFlexibleUBO;
+        cameraBlockTotem.bind(uniformBindingPoints.camera);
+        ubo.bind();
+        gl.bindVertexArray(vao);
+        // drawArrays(gl, gl.POINTS, drawOptions);
+        drawArrays(gl, gl.LINE_STRIP, drawOptions);
+        gl.bindVertexArray(null);
+        ubo.unbind();
+        cameraBlockTotem.unbind(uniformBindingPoints.camera);
+    }
+    free() {
+        this._vaosPublished.forEach((vao) => this.gl.deleteVertexArray(vao));
+        this._ubosPublished.forEach((ubo) => ubo.free());
+        this.gl.deleteProgram(this.program);
+        this._defaultFlexibleUBO.free();
+        CameraUniformBlockTotemCache.release(this.globe);
+        this.gl.deleteProgram(this.program);
+    }
+}
+export const LineStripProgramCache = Object.freeze({
+    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, LineProgram),
+    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, LineProgram),
+});

package/programs/line-on-globe/{naive-accurate-flexible.ts → naive-accurate-flexible.js}

@@ -1,39 +1,22 @@
-import { CameraUniformBlockString, CameraUniformBlockTotemCache, CameraUniformBlockTotem } from "../totems/camerauniformblock";
-import { slerp, POLE, R_3D, mercatorXYToGLPosition, cartesian3DToGLPosition } from "../../util/shaderfunctions/geometrytransformations";
-import { createProgram } from "../../util/webglobjectbuilders";
-import { noRegisterGlobeProgramCache } from "../programcache";
-import { attributeLoader } from "../../util/gl-util/buffer/attribute-loader";
-import { UniformBlockManager } from "../../util/gl-util/uniform-block/manager";
-
-import { drawInstanced } from "../../util/gl-util/draw-options/methods";
-import { UBOHandler, Globe, BufferAndReadInfo, DrawRangeIndexParams } from "../../types";
-
-
-interface UniformBindingPoints {
-    camera: number;
-    flexible: number;
-}
-
-const GLOBE_MIDPOINT_COUNT: number = 30;
-
-const escapeValue: number = -1.0;
-
-const uniformBindingPoints: UniformBindingPoints = {
-    camera: 0,
-    flexible: 1
-}
-
-const uniformBlockManager = new UniformBlockManager(
-    'FlexibleAttibutes',
-    [
-        { name: 'u_color', type: 'vec4', value: null },
-        { name: 'u_dash_ratio', type: 'float', value: null },
-        { name: 'u_dash_opacity', type: 'float', value: null }
-    ],
-    uniformBindingPoints.flexible
-)
-
-const vertexShader: string = `#version 300 es
+import { CameraUniformBlockString, CameraUniformBlockTotemCache } from "../totems/camerauniformblock";
+import { slerp, POLE, R_3D, mercatorXYToGLPosition, cartesian3DToGLPosition } from "../../util/shaderfunctions/geometrytransformations";
+import { createProgram } from "../../util/webglobjectbuilders";
+import { noRegisterGlobeProgramCache } from "../programcache";
+import { attributeLoader } from "../../util/gl-util/buffer/attribute-loader";
+import { UniformBlockManager } from "../../util/gl-util/uniform-block/manager";
+import { drawInstanced } from "../../util/gl-util/draw-options/methods";
+const GLOBE_MIDPOINT_COUNT = 30;
+const escapeValue = -1.0;
+const uniformBindingPoints = {
+    camera: 0,
+    flexible: 1
+};
+const uniformBlockManager = new UniformBlockManager('FlexibleAttibutes', [
+    { name: 'u_color', type: 'vec4', value: null },
+    { name: 'u_dash_ratio', type: 'float', value: null },
+    { name: 'u_dash_opacity', type: 'float', value: null }
+], uniformBindingPoints.flexible);
+const vertexShader = `#version 300 es
 precision highp float;
 
 ${R_3D}
@@ -84,9 +67,8 @@ void main() {
         gl_Position = mercatorXYToGLPosition(longLat);
     }
 }
-`;
-
-const fragmentShader: string = `#version 300 es
+`;
+const fragmentShader = `#version 300 es
 ${POLE}
 precision highp float;
 
@@ -109,139 +91,108 @@ void main() {
     if (fract(interpolation / (2.0 * v_dash_ratio)) < 0.5) { color.a *= v_dash_opacity; }
 
 }
-`;
-
-class Logic {
-    public vaosPublished: WebGLVertexArrayObject[] = [];
-    public isFreed: boolean = false;
-
-    private globe: Globe;
-    private gl: WebGL2RenderingContext;
-    private program: WebGLProgram;
-    private _lastOpacity: number;
-    private _opacityLocation: WebGLUniformLocation | null;
-    private cameraBlockTotem: CameraUniformBlockTotem;
-    private _ubosPublished: UBOHandler[];
-    private _defaultFlexibleUBO: UBOHandler;
-
-    constructor(globe: Globe) {
-        this.globe = globe;
-        this.gl = globe.gl;
-        this.program = createProgram(this.gl, vertexShader, fragmentShader);
-        this._lastOpacity = 1.0;
-        const { gl, program } = this;
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-        gl.useProgram(program);
-
-        // assign attribute locations
-        gl.bindAttribLocation(program, 0, "start_position");
-        gl.bindAttribLocation(program, 1, "start_position3d");
-        gl.bindAttribLocation(program, 2, "end_position");
-        gl.bindAttribLocation(program, 3, "end_position3d");
-        gl.bindAttribLocation(program, 4, "dash_ratio");
-        gl.bindAttribLocation(program, 5, "dash_opacity");
-        gl.bindAttribLocation(program, 6, "color");
-        this._opacityLocation = gl.getUniformLocation(program, "opacity");
-
-        gl.uniform1f(this._opacityLocation, this._lastOpacity);
-
-        gl.useProgram(currentProgram);
-
-        this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
-        this.cameraBlockTotem.assignBindingPoint(program, uniformBindingPoints.camera);
-
-        this._ubosPublished = [];
-        uniformBlockManager.assignBindingPoint(this.gl, this.program);
-        this._defaultFlexibleUBO = this.createUBO();
-    }
-
-    /**
-     * Draw method for rendering lines on globe
-     * @param vao - WebGL Vertex Array Object
-     * @param drawOptions - Draw range index parameters
-     * @param opacity - Opacity value (0-1)
-     * @param flexibleUBO - Optional flexible uniform buffer object
-     */
-    draw(
-        vao: WebGLVertexArrayObject,
-        drawOptions: DrawRangeIndexParams,
-        opacity: number,
-        flexibleUBO: UBOHandler | null = null
-    ): void {
-        const { gl, program, globe, cameraBlockTotem, _defaultFlexibleUBO } = this;
-        gl.useProgram(program);
-        cameraBlockTotem.bind(uniformBindingPoints.camera);
-        gl.bindVertexArray(vao);
-        if (opacity !== this._lastOpacity) {
-            gl.uniform1f(this._opacityLocation, opacity);
-            this._lastOpacity = opacity;
-        }
-        const vertexCount: number = globe.api_GetCurrentGeometry() === 0 ? GLOBE_MIDPOINT_COUNT : 2;
-        const ubo: UBOHandler = flexibleUBO || _defaultFlexibleUBO;
-        ubo.bind();
-        drawInstanced(gl, gl.LINE_STRIP, drawOptions, vertexCount);
-        ubo.unbind();
-        gl.bindVertexArray(null);
-        cameraBlockTotem.unbind(uniformBindingPoints.camera);
-    }
-
-    createUBO(bufferReadType: string = "STATIC_DRAW"): UBOHandler {
-        const ubo: UBOHandler = uniformBlockManager.createUBO(this.gl, bufferReadType);
-        this._ubosPublished.push(ubo);
-        ubo.update(
-            new Map([
-                ["u_color", [1, 1, 1, 1]],
-                ["u_dash_ratio", [1]],
-                ["u_dash_opacity", [1]]
-            ])
-        );
-        return ubo;
-    }
-
-    createVAO(
-        startPotision2DBufferObj: BufferAndReadInfo | null,
-        startPotision3DBufferObj: BufferAndReadInfo | null,
-        endPosition2DBufferObj: BufferAndReadInfo | null,
-        endPosition3DBufferObj: BufferAndReadInfo | null,
-        dashRatioBufferObj: BufferAndReadInfo | null,
-        dashOpacityBufferObj: BufferAndReadInfo | null,
-        colorBufferObj: BufferAndReadInfo | null
-    ): WebGLVertexArrayObject {
-        const { gl } = this;
-        const vao: WebGLVertexArrayObject | null = gl.createVertexArray();
-        if (!vao) {
-            throw new Error("Failed to create vertex array object");
-        }
-
-        gl.bindVertexArray(vao);
-
-        const divisor: number = 1;
-
-        attributeLoader(gl, startPotision2DBufferObj, 0, 2, { divisor });
-        attributeLoader(gl, startPotision3DBufferObj, 1, 3, { divisor });
-        attributeLoader(gl, endPosition2DBufferObj, 2, 2, { divisor });
-        attributeLoader(gl, endPosition3DBufferObj, 3, 3, { divisor });
-        attributeLoader(gl, dashRatioBufferObj, 4, 1, { divisor, escapeValues: [escapeValue] });
-        attributeLoader(gl, dashOpacityBufferObj, 5, 1, { divisor, escapeValues: [escapeValue] });
-        attributeLoader(gl, colorBufferObj, 6, 4, { divisor, escapeValues: [escapeValue, escapeValue, escapeValue, escapeValue] });
-
-        gl.bindVertexArray(null);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-        this.vaosPublished.push(vao);
-        return vao;
-    }
-
-    free(): void {
-        if (this.isFreed) return;
-        CameraUniformBlockTotemCache.release(this.globe);
-        this.gl.deleteProgram(this.program);
-        this.vaosPublished.forEach((vao: WebGLVertexArrayObject) => this.gl.deleteVertexArray(vao));
-        this._ubosPublished.forEach((ubo: UBOHandler) => ubo.free());
-        this.isFreed = true;
-    }
-}
-
-export const LineOnGlobeCache = Object.freeze({
-    get: (globe: Globe): Logic => { return noRegisterGlobeProgramCache.getProgram(globe, Logic) },
-    release: (globe: Globe): void => { return noRegisterGlobeProgramCache.releaseProgram(globe, Logic) }
-});
+`;
+class Logic {
+    vaosPublished = [];
+    isFreed = false;
+    globe;
+    gl;
+    program;
+    _lastOpacity;
+    _opacityLocation;
+    cameraBlockTotem;
+    _ubosPublished;
+    _defaultFlexibleUBO;
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this.program = createProgram(this.gl, vertexShader, fragmentShader);
+        this._lastOpacity = 1.0;
+        const { gl, program } = this;
+        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(program);
+        // assign attribute locations
+        gl.bindAttribLocation(program, 0, "start_position");
+        gl.bindAttribLocation(program, 1, "start_position3d");
+        gl.bindAttribLocation(program, 2, "end_position");
+        gl.bindAttribLocation(program, 3, "end_position3d");
+        gl.bindAttribLocation(program, 4, "dash_ratio");
+        gl.bindAttribLocation(program, 5, "dash_opacity");
+        gl.bindAttribLocation(program, 6, "color");
+        this._opacityLocation = gl.getUniformLocation(program, "opacity");
+        gl.uniform1f(this._opacityLocation, this._lastOpacity);
+        gl.useProgram(currentProgram);
+        this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
+        this.cameraBlockTotem.assignBindingPoint(program, uniformBindingPoints.camera);
+        this._ubosPublished = [];
+        uniformBlockManager.assignBindingPoint(this.gl, this.program);
+        this._defaultFlexibleUBO = this.createUBO();
+    }
+    /**
+     * Draw method for rendering lines on globe
+     * @param vao - WebGL Vertex Array Object
+     * @param drawOptions - Draw range index parameters
+     * @param opacity - Opacity value (0-1)
+     * @param flexibleUBO - Optional flexible uniform buffer object
+     */
+    draw(vao, drawOptions, opacity, flexibleUBO = null) {
+        const { gl, program, globe, cameraBlockTotem, _defaultFlexibleUBO } = this;
+        gl.useProgram(program);
+        cameraBlockTotem.bind(uniformBindingPoints.camera);
+        gl.bindVertexArray(vao);
+        if (opacity !== this._lastOpacity) {
+            gl.uniform1f(this._opacityLocation, opacity);
+            this._lastOpacity = opacity;
+        }
+        const vertexCount = globe.api_GetCurrentGeometry() === 0 ? GLOBE_MIDPOINT_COUNT : 2;
+        const ubo = flexibleUBO || _defaultFlexibleUBO;
+        ubo.bind();
+        drawInstanced(gl, gl.LINE_STRIP, drawOptions, vertexCount);
+        ubo.unbind();
+        gl.bindVertexArray(null);
+        cameraBlockTotem.unbind(uniformBindingPoints.camera);
+    }
+    createUBO(bufferReadType = "STATIC_DRAW") {
+        const ubo = uniformBlockManager.createUBO(this.gl, bufferReadType);
+        this._ubosPublished.push(ubo);
+        ubo.update(new Map([
+            ["u_color", [1, 1, 1, 1]],
+            ["u_dash_ratio", [1]],
+            ["u_dash_opacity", [1]]
+        ]));
+        return ubo;
+    }
+    createVAO(startPotision2DBufferObj, startPotision3DBufferObj, endPosition2DBufferObj, endPosition3DBufferObj, dashRatioBufferObj, dashOpacityBufferObj, colorBufferObj) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        if (!vao) {
+            throw new Error("Failed to create vertex array object");
+        }
+        gl.bindVertexArray(vao);
+        const divisor = 1;
+        attributeLoader(gl, startPotision2DBufferObj, 0, 2, { divisor });
+        attributeLoader(gl, startPotision3DBufferObj, 1, 3, { divisor });
+        attributeLoader(gl, endPosition2DBufferObj, 2, 2, { divisor });
+        attributeLoader(gl, endPosition3DBufferObj, 3, 3, { divisor });
+        attributeLoader(gl, dashRatioBufferObj, 4, 1, { divisor, escapeValues: [escapeValue] });
+        attributeLoader(gl, dashOpacityBufferObj, 5, 1, { divisor, escapeValues: [escapeValue] });
+        attributeLoader(gl, colorBufferObj, 6, 4, { divisor, escapeValues: [escapeValue, escapeValue, escapeValue, escapeValue] });
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        this.vaosPublished.push(vao);
+        return vao;
+    }
+    free() {
+        if (this.isFreed)
+            return;
+        CameraUniformBlockTotemCache.release(this.globe);
+        this.gl.deleteProgram(this.program);
+        this.vaosPublished.forEach((vao) => this.gl.deleteVertexArray(vao));
+        this._ubosPublished.forEach((ubo) => ubo.free());
+        this.isFreed = true;
+    }
+}
+export const LineOnGlobeCache = Object.freeze({
+    get: (globe) => { return noRegisterGlobeProgramCache.getProgram(globe, Logic); },
+    release: (globe) => { return noRegisterGlobeProgramCache.releaseProgram(globe, Logic); }
+});

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

@@ -1,8 +1,5 @@
-
-const Z_ALPHA_MODE = Object.freeze({
-    ON: 1,
-    OFF: 0
-});
-
-
-export { Z_ALPHA_MODE }
+const Z_ALPHA_MODE = Object.freeze({
+    ON: 1,
+    OFF: 0
+});
+export { Z_ALPHA_MODE };