@pirireis/webglobeplugins 0.15.35 → 0.16.0

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

@@ -0,0 +1,201 @@
+import { createProgram } from "../../../util/webglobjectbuilders";
+import { ProgramInterface, DrawRangeIndexParams, UBOHandler, BufferAndReadInfo } 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,
+);
+
+
+
+
+const vertexShaderSource = `#version 300 es
+precision highp float;
+
+${CameraUniformBlockString}
+${cartesian3DToGLPosition}
+${mercatorXYToGLPosition}
+
+${flexibleBlockManager.glslCode()}
+
+uniform float u_opacity;
+
+in vec3 position3d;
+in vec2 position2d;
+in vec4 color; 
+out vec4 v_color;
+
+flat out vec3 v_flat_position;
+out vec3 v_position;
+
+void main() {
+    v_color = ( color.r == -1.0 ) ? u_color : color;
+    v_color.a *= u_opacity;
+    if ( is3D ) {
+        gl_Position = cartesian3DToGLPosition( position3d );
+        v_position = position3d;
+        v_flat_position = position3d;
+    } else {
+        gl_Position = mercatorXYToGLPosition( position2d );
+        v_position = vec3( position2d, 0.0 );
+        v_flat_position = vec3( position2d, 0.0 );
+    }
+    gl_PointSize = 6.0;
+}`;
+
+
+const fragmentShaderSource = `#version 300 es
+precision highp float;
+
+uniform float opacity;
+
+in vec4 v_color;
+in float v_dash_length;
+in float v_dash_opacity;
+
+flat in vec3 v_flat_position;
+in vec3 v_position;
+
+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: BufferAndReadInfo, position2D: BufferAndReadInfo, color: BufferAndReadInfo
+    ): 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),
+});
+

package/programs/line-on-globe/naive-accurate-flexible.ts

@@ -0,0 +1,258 @@
+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, createBufferAndReadInfo } 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";
+
+// Type definitions
+interface FlexibleOptions {
+    color?: [number, number, number, number]; // 0-1
+    dash_opacity?: number;
+    dash_ratio?: number;
+}
+
+
+
+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
+precision highp float;
+
+${R_3D}
+${CameraUniformBlockString}
+${slerp}
+${mercatorXYToGLPosition}
+${cartesian3DToGLPosition}
+
+${uniformBlockManager.glslCode()}
+
+in vec2 start_position;
+in vec3 start_position3d;
+in vec2 end_position;
+in vec3 end_position3d;
+
+in float dash_ratio;
+in float dash_opacity;
+in vec4 color;
+
+out float v_dash_ratio;
+out float v_dash_opacity;
+out vec4 v_color;
+
+out vec2 v_limp;
+out float interpolation;
+
+void main() {
+    vec2 longLat;
+
+    v_color = (color.r == -1.0) ? u_color: color;
+    v_dash_ratio = (dash_ratio == -1.0) ? u_dash_ratio : dash_ratio;
+    v_dash_opacity = (dash_opacity == -1.0) ? u_dash_opacity : dash_opacity;
+
+    if (is3D) {
+        interpolation = float(gl_VertexID) / ${GLOBE_MIDPOINT_COUNT - 1}.0;
+        vec3 cartesian = slerp(start_position3d, end_position3d, interpolation);
+        gl_Position = cartesian3DToGLPosition(cartesian);
+        v_limp = vec2(0.0, 0.0);
+    } else {
+        if ( distance( start_position, end_position) > 30000000.0) { return; }
+        interpolation = float(gl_VertexID);
+        if (gl_VertexID % 2 == 0) {
+            longLat = start_position;
+        } else {
+            longLat = end_position;
+        }
+        v_limp = longLat;
+        gl_Position = mercatorXYToGLPosition(longLat);
+    }
+}
+`;
+
+const fragmentShader: string = `#version 300 es
+${POLE}
+precision highp float;
+
+uniform float opacity;
+
+in float interpolation;
+in vec2 v_limp;
+in vec4 v_color;
+in float v_dash_ratio;
+in float v_dash_opacity;
+
+out vec4 color;
+
+void main() {
+    if (v_limp.x < -POLE || v_limp.x > POLE || v_limp.y < -POLE || v_limp.y > POLE) { discard; }
+    color = v_color;
+    color.a *= opacity;
+    if ( v_dash_ratio >= 1.0 ) { return; }
+    if (interpolation > 0.95) { return; }
+    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;
+        }
+        // this._setFlexibleUniforms(flexibleOptions);
+        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) }
+});

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

@@ -1,5 +1,8 @@
-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 }

package/programs/picking/pickable-polygon-renderer.js

@@ -0,0 +1,215 @@
+import { createProgram } from "../../util";
+import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../totems";
+import { mercatorXYToGLPosition, cartesian3DToGLPosition, R_3D, R } from "../../util/shaderfunctions/geometrytransformations";
+import { noRegisterGlobeProgramCache } from "../programcache";
+import { drawArrays, DrawRangeIndexParams } from "../../util/gl-util/draw-options/methods";
+import { attributeLoader } from "../../util/gl-util/buffer/attribute-loader";
+import { UniformBlockManager } from "../../util/gl-util/uniform-block/manager";
+
+
+const uniformBindingPoints = {
+    camera: 0,
+    flexible: 1
+};
+
+const uniformBlockManager = new UniformBlockManager(
+    "FlexibleBlock",
+    [
+        { name: "u_rgba", type: "vec4", value: new Float32Array([1, 1, 1, 1]) },
+        { name: "u_opacity", type: "float", value: new Float32Array([1.0]) },
+        { name: "u_size_multiplier", type: "float", value: new Float32Array([1.0]) },
+        { name: "u_size", type: "float", value: new Float32Array([1.0]) },
+        { name: "u_minimum_size", type: "float", value: new Float32Array([1.0]) },
+        { name: "u_draw_mode", type: "int", value: new Int32Array([0]) }, // 0.0 for point, 1.0 for line
+        { name: "u_is_circle", type: "bool", value: new Float32Array([1.0]) },
+        { name: "u_dash_count", type: "float", value: new Float32Array([1.0]) },
+        { name: "u_dash_opacity_multiplier", type: "float", value: new Float32Array([1.0]) },
+        { name: "u_dash_phase", type: "float", value: new Float32Array([0.0]) },
+    ], uniformBindingPoints.flexible);
+
+
+const vs = `#version 300 es
+${R}
+${R_3D}
+${CameraUniformBlockString}
+${mercatorXYToGLPosition}
+${cartesian3DToGLPosition}
+
+${uniformBlockManager.glslCode()}
+
+precision highp float;
+precision highp int;
+
+in vec3 pos3D;
+in vec2 pos2D;
+in vec4 rgba;
+in float size;
+
+
+flat out highp int vVertexID;
+
+out vec4 v_rgba;
+
+out float v_length;
+
+void main() {
+    
+    v_rgba =  (rgba.r == -1.0) ? u_rgba : rgba;
+    v_rgba.a *= u_opacity;
+    gl_PointSize = max(((size == -1.0) ? u_size : size) * u_size_multiplier, u_minimum_size);
+    
+    float size_fixer; 
+    if(is3D){
+        gl_Position = cartesian3DToGLPosition(pos3D);
+        size_fixer = smoothstep(0.15, 1.0, 0.5 * R_3D / gl_Position.w) ;
+    } else {
+        gl_Position = mercatorXYToGLPosition(pos2D);
+        size_fixer = smoothstep(2.0, 5.2, z_level);
+    }
+    gl_PointSize *= size_fixer;
+    switch (u_draw_mode) {
+        case 0:
+            vVertexID = gl_VertexID;
+            break;
+        case 1:
+            v_length = float(gl_VertexID % 2);
+            vVertexID = (gl_VertexID - gl_VertexID % 2) / 2; // a line takes two points
+            break;
+        default:
+            break;
+    }
+}`;
+
+const fs = `#version 300 es
+precision highp float;
+precision highp int;
+
+${uniformBlockManager.glslCode()}
+
+flat in highp int vVertexID;
+
+in vec4 v_rgba;
+in float v_length;
+
+layout(location = 0) out vec4 fragColor;
+layout(location = 1) out int vertexID;
+
+void main() {
+    vertexID = vVertexID; 
+    fragColor = v_rgba;
+
+    switch (u_draw_mode) {
+        case 0:
+            float d = distance(gl_PointCoord, vec2(0.5, 0.5));
+            if (u_is_circle) {
+                if (d > 0.5) discard;
+                fragColor.a *= smoothstep(0.5, 0.45, d);
+            }
+            if (u_dash_opacity_multiplier < 1.0) {
+                float dash = sin(d * 3.14159 * 2.0 * u_dash_count + u_dash_phase) * (1.0 - u_dash_opacity_multiplier) + u_dash_opacity_multiplier;
+                fragColor.a *= dash;
+            }
+            break;
+        case 1:
+            if (u_dash_opacity_multiplier < 1.0 && fract((v_length + u_dash_phase) * u_dash_count) < 0.5) {
+                fragColor.a *= u_dash_opacity_multiplier;
+            }
+            break;
+    }
+}`;
+
+
+class PointOnGlobeProgram {
+
+    constructor(globe) {
+
+        this.globe = globe;
+        this.gl = globe.gl;
+        this._isFreed = false;
+        this.program = createProgram(this.gl, vs, fs);
+
+        const { gl, program } = this;
+
+        // assign opacity
+
+
+        // assign attribute locations
+        gl.bindAttribLocation(program, 0, "pos3D");
+        gl.bindAttribLocation(program, 1, "pos2D");
+        gl.bindAttribLocation(program, 2, "rgba");
+        gl.bindAttribLocation(program, 3, "size");
+        // arrange camera uniform block
+
+
+        this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
+        this.cameraBlockTotem.assignBindingPoint(program, uniformBindingPoints.camera);
+        uniformBlockManager.assignBindingPoint(this.gl, this.program);
+        this._defaultUBO = uniformBlockManager.createUBO(this.gl);
+
+        this._defaultUBO.update(new Map([
+            ["u_rgba", [1, 1, 1, 1]],
+            ["u_opacity", [1.0]],
+            ["u_size_multiplier", [1.0]],
+            ["u_size", [1.0]],
+            ["u_is_circle", [1.0]],
+        ]));
+    }
+
+
+    createUBO() {
+        const ubo = uniformBlockManager.createUBO(this.gl);
+        return ubo;
+    }
+
+    createVAO(pos3DBufferObj, pos2DBufferObj, rgbaBufferObj, sizeBufferObj) {
+
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+
+        attributeLoader(gl, pos3DBufferObj, 0, 3);
+        attributeLoader(gl, pos2DBufferObj, 1, 2);
+        attributeLoader(gl, rgbaBufferObj, 2, 4, { escapeValues: [-1, -1, -1, -1] });
+        attributeLoader(gl, sizeBufferObj, 3, 1, { escapeValues: [-1] });
+
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return vao;
+    }
+
+
+    /**
+     * 
+     * @param {vertexArrayObject} vao 
+     * @param {DrawRangeIndexParams} drawOptions
+     */
+    draw(vao, drawOptions, ubo = null) {
+        const { gl, program } = this;
+        gl.useProgram(program);
+        gl.bindVertexArray(vao);
+        this.cameraBlockTotem.bind(uniformBindingPoints.camera);
+        ubo = ubo || this._defaultUBO;
+        ubo.bind();
+
+        drawArrays(gl, gl.POINTS, drawOptions);
+        ubo.unbind();
+        this.cameraBlockTotem.unbind(uniformBindingPoints.camera);
+        gl.bindVertexArray(null);
+    }
+
+    free() {
+        if (this._isFreed) return;
+        const { gl, globe } = this;
+        CameraUniformBlockTotemCache.release(globe);
+        gl.deleteProgram(this.program);
+        this._isFreed = true;
+    }
+}
+
+
+const PickableRendererProgramCache = Object.freeze({
+    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, PointOnGlobeProgram),
+    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, PointOnGlobeProgram)
+});
+
+export { PickableRendererProgramCache };