@pirireis/webglobeplugins 0.16.0 → 0.16.1

package/dist/util/interpolation/timetrack/timetrack-interpolator.js

@@ -1,79 +0,0 @@
-import { findFirstIndexInRange } from '../../algorithms/search-binary';
-import { sphericalLinearInterpolation_Cartesian3d, sphericalLinearInterpolation_Mercator, } from '../../../Math/methods';
-/**
- * @typedef {Array<number>} vec3 [x, y, z]
- * @typedef {Array<number>} vec2 [x, y]
- * @typedef {Array<number>} vec4 [x, y, z, w]
- * @typedef {number} fraction a number between 0 and 1
- * @typedef {Array<number>} wgs84 [long, lat]
- */
-const _0vec3 = [0, 0, 0];
-const GEOMETRY = Object.freeze({
-    CARTESIAN3D: 0,
-    MERCATOR: 1,
-});
-class TimeTrackInterpolator {
-    /**
-     * @typedef Timetrack
-     * @property {Array<vec4>}} coordinates [x,y,z, length]
-     * @property {Array<Number>} times
-     * @param {Array<Timetrack>} timeTracks
-     */
-    constructor({ timeTracks, bbox = null, geometry = GEOMETRY.CARTESIAN3D } = {}) {
-        this.timeTracks = null;
-        this.timeTracksStartTimes = null;
-        this.geometry = geometry;
-        if (timeTracks)
-            this.setTimetracks(timeTracks);
-        if (bbox)
-            this.setBbox(bbox);
-    }
-    setGeometry(geometry) {
-        if (geometry !== GEOMETRY.CARTESIAN3D && geometry !== GEOMETRY.MERCATOR) {
-            throw new Error('Invalid geometry');
-        }
-        this.geometry = geometry;
-    }
-    setTimetracks(timeTracks) {
-        this.timeTracks = timeTracks;
-    }
-    interpolate(time) {
-        const { timeTracks, geometry } = this;
-        if (!timeTracks) {
-            return null;
-        }
-        const resultArray = [];
-        const info = {
-            outOfRange: 0,
-            processed: 0,
-        };
-        for (let i = 0; i < timeTracks.length; i++) {
-            const { times, coordinates } = timeTracks[i];
-            if (times[times.length - 1] < time)
-                continue;
-            info.processed++;
-            const timeIndex = findFirstIndexInRange(times, time);
-            if (timeIndex === null) {
-                info.outOfRange++;
-                continue;
-            }
-            const timeFraction = (time - times[timeIndex]) / (times[timeIndex + 1] - times[timeIndex]);
-            if (geometry === GEOMETRY.CARTESIAN3D) {
-                sphericalLinearInterpolation_Cartesian3d(_0vec3, coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction);
-            }
-            else {
-                sphericalLinearInterpolation_Mercator(_0vec3, coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction);
-            }
-            resultArray.push(..._0vec3);
-        }
-        return new Float32Array(resultArray);
-    }
-    // implicit methods
-    _orderTimeTracks() {
-        this.timeTracks.sort((a, b) => a.times[0] - b.times[0]);
-    }
-    _setStartTimes() {
-        this.timeTracksStartTimes = this.timeTracks.map(tt => tt.times[0]);
-    }
-}
-export { TimeTrackInterpolator, GEOMETRY };

package/dist/util/interpolation/timetrack/web-worker.js

@@ -1,46 +0,0 @@
-import { TimeTrackInterpolator, GEOMETRY } from './timetrack-interpolator';
-const interpolator = new TimeTrackInterpolator({ geometry: GEOMETRY.CARTESIAN3D });
-/* eslint-disable-next-line no-restricted-globals */
-self.onmessage = function (e) {
-    const { geometry = null, timeTracks = null, time = null } = e.data;
-    if (geometry !== null) {
-        try {
-            interpolator.setGeometry(geometry);
-        }
-        catch (error) {
-            /* eslint-disable-next-line no-restricted-globals */
-            self.postMessage({ error: error.message });
-            return;
-        }
-    }
-    if (timeTracks !== null) {
-        try {
-            interpolator.setTimetracks(timeTracks);
-        }
-        catch (error) {
-            /* eslint-disable-next-line no-restricted-globals */
-            self.postMessage({ error: error.message });
-            return;
-        }
-    }
-    if (time !== null) {
-        try {
-            const result = interpolator.interpolate(time);
-            if (result === null) {
-                /* eslint-disable-next-line no-restricted-globals */
-                self.postMessage({ error: 'No TimeTracks Data' });
-                return;
-            }
-            /* eslint-disable-next-line no-restricted-globals */
-            self.postMessage(result, [result.buffer]);
-            return;
-        }
-        catch (error) {
-            /* eslint-disable-next-line no-restricted-globals */
-            self.postMessage({ error: error.message });
-            return;
-        }
-    }
-    /* eslint-disable-next-line no-restricted-globals */
-    self.postMessage(true);
-};

package/dist/util/jshelpers/data-filler.js

@@ -1,17 +0,0 @@
-const populateFloat32Array = Object.freeze({
-    fillFloat32Array: (length, data) => {
-        const result = new Float32Array(length);
-        result.fill(data);
-        return result;
-    },
-    fillWithListData: (length, listdata) => {
-        const result = new Float32Array(length * listdata.length);
-        let offset = 0;
-        for (let i = 0; i < length; i++) {
-            result.set(listdata, offset);
-            offset += listdata.length;
-        }
-        return result;
-    }
-});
-export { populateFloat32Array };

package/dist/util/jshelpers/equality.js

@@ -1,18 +0,0 @@
-function arraysEqual(a, b) {
-    if (a === b)
-        return true;
-    if (a == null || b == null)
-        return false;
-    if (a.length !== b.length)
-        return false;
-    // If you don't care about the order of the elements inside
-    // the array, you should sort both arrays here.
-    // Please note that calling sort on an array will modify that array.
-    // you might want to clone your array first.
-    for (var i = 0; i < a.length; ++i) {
-        if (a[i] !== b[i])
-            return false;
-    }
-    return true;
-}
-export { arraysEqual };

package/dist/util/jshelpers/index.js

@@ -1,2 +0,0 @@
-import * as timefilters_1 from './timefilters';
-export { timefilters_1 as timefilters };

package/dist/util/jshelpers/timefilters.js

@@ -1,30 +0,0 @@
-// TODO: fix logic error in instantDebounce
-function instantDebounce(func, delay) {
-    let timeout = null;
-    let lastArgs = null;
-    let runAtEnd = false;
-    const timeoutMethod = () => {
-        setTimeout(() => {
-            if (runAtEnd) {
-                func(...lastArgs);
-                lastArgs = null;
-                // console.log("processed with delay")
-                runAtEnd = false;
-            }
-            timeout = null;
-        }, delay);
-    };
-    return function () {
-        if (timeout) {
-            lastArgs = arguments;
-            runAtEnd = true;
-            return;
-        }
-        else {
-            func(...args);
-            // console.log("processed instantly")
-            timeout = timeoutMethod();
-        }
-    };
-}
-export { instantDebounce };

package/dist/util/picking/fence.js

@@ -1,43 +0,0 @@
-const fence = (gl) => new Promise((resolve, reject) => {
-    // This will create a fence. If this follows a `readPixels()` call, then it
-    // will signal to WebGL that the read instruction should be asynchronous. 
-    // This means JS can continue to work on other tasks while the read instruction
-    // completes.
-    const sync = gl.fenceSync(gl.SYNC_GPU_COMMANDS_COMPLETE, 0);
-    gl.flush();
-    // There are TWO possible ways to check on the status of a WebGLSync object.
-    // 1. This will check it using clientWaitSync()
-    const checkStatus_v1 = () => {
-        const status = gl.clientWaitSync(sync, 0, 0);
-        // There are four possible values for status:
-        // a. ALREADY_SIGNALED and CONDITION_SATISFIED (done)
-        // b. TIMEOUT_EXPIRED (check again later)
-        // c. WAIT_FAILED (there was an error)
-        if (status === gl.TIMEOUT_EXPIRED) {
-            setTimeout(checkStatus_v1, 1);
-        }
-        else if (status === gl.ALREADY_SIGNALED || status === gl.CONDITION_SATISFIED) {
-            gl.deleteSync(sync);
-            resolve();
-        }
-        else {
-            gl.deleteSync(sync);
-            reject(new Error('Fence did not resolve normally for some reason'));
-        }
-    };
-    // 2. This will check with getSyncParameter(s, gl.SYNC_STATUS)
-    const checkStatus_v2 = () => {
-        const status = gl.getSyncParameter(sync, gl.SYNC_STATUS);
-        // There are only two possible values for status: SIGNALED and UNSIGNALED
-        // Note that there is no `error` signal, so there is no reason to use `reject()` here
-        if (status === gl.SIGNALED) {
-            gl.deleteSync(sync);
-            resolve();
-        }
-        else {
-            setTimeout(checkStatus_v2, 1);
-        }
-    };
-    setTimeout(checkStatus_v2, 1);
-});
-export { fence };

package/dist/util/picking/picker-displayer.js

@@ -1,136 +0,0 @@
-/**
- * add implicit texture display program for color
- * add fence on query return and return id.
-*/
-import { textureOnCanvasProgramCache } from "../programs/draw-texture-on-canvas";
-import { fence } from "./fence";
-const ESCAPE_VALUE = -1;
-class PickerDisplayer {
-    constructor(globe) {
-        this.globe = globe;
-        this.gl = globe.gl;
-        const gl = this.gl;
-        this.colorTexture = gl.createTexture(); // bind to color attachment 0
-        this.indexTexture = gl.createTexture(); // bind to color attachment 1
-        this.fbo = gl.createFramebuffer();
-        this._pbo = undefined;
-        this._pboSize = 0;
-        this.resize();
-        this.displayer = textureOnCanvasProgramCache.get(this.gl);
-    }
-    resize(width = null, height = null) {
-        if (width === null || height === null) {
-            width = this.globe.api_ScrW();
-            height = this.globe.api_ScrH();
-        }
-        const { gl, colorTexture, indexTexture } = this;
-        gl.deleteTexture(colorTexture);
-        gl.deleteTexture(indexTexture);
-        const colorTextureNew = gl.createTexture();
-        gl.bindTexture(gl.TEXTURE_2D, colorTextureNew);
-        gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA8, width, height);
-        const indexTextureNew = gl.createTexture();
-        gl.bindTexture(gl.TEXTURE_2D, indexTextureNew);
-        // gl.texStorage2D(gl.TEXTURE_2D, 1, gl.R16I, width, height);
-        gl.texStorage2D(gl.TEXTURE_2D, 1, gl.R32I, width, height);
-        gl.bindTexture(gl.TEXTURE_2D, null);
-        this.colorTexture = colorTextureNew;
-        this.indexTexture = indexTextureNew;
-    }
-    clearTextures() {
-        const { gl, colorTexture, indexTexture } = this;
-        gl.activeTexture(gl.TEXTURE1);
-        gl.bindTexture(gl.TEXTURE_2D, indexTexture);
-        gl.clearBufferiv(gl.COLOR, 1, new Int32Array([-1, -1, -1, -1]));
-        gl.activeTexture(gl.TEXTURE0);
-        gl.bindTexture(gl.TEXTURE_2D, colorTexture);
-        gl.clearBufferfv(gl.COLOR, 0, new Float32Array([0, 0, 0, 0]));
-    }
-    // call before drawing the scene with gl picker shader
-    bindFBO() {
-        const { gl, colorTexture, indexTexture, fbo } = this;
-        gl.activeTexture(gl.TEXTURE1);
-        gl.bindTexture(gl.TEXTURE_2D, indexTexture);
-        gl.activeTexture(gl.TEXTURE0);
-        gl.bindTexture(gl.TEXTURE_2D, colorTexture);
-        { // bind framebuffer
-            gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
-            gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this.colorTexture, 0);
-            gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.TEXTURE_2D, this.indexTexture, 0);
-            gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1]);
-        }
-    }
-    // call after drawing the scene with gl picker shader
-    drawColorTexture() {
-        const { colorTexture } = this;
-        this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, null);
-        this.displayer.draw(colorTexture);
-    }
-    pickXY(x, y, selectionPointFilling = 1, callback = () => { }) {
-        const size = Math.pow(1 + 2 * selectionPointFilling, 2);
-        this._pick(size, x - selectionPointFilling, y - selectionPointFilling, 1 + 2 * selectionPointFilling, 1 + 2 * selectionPointFilling, callback);
-    }
-    pickBbox(left, top, right, bottom, callback) {
-        const size = (right - left) * (bottom - top) * 4;
-        this._pick(size, left, top, right - left, bottom - top, callback);
-    }
-    _pick(size, startX, startY, lengthX, lengthY, callback) {
-        if (this._inProgress)
-            return false;
-        this._inProgress = true;
-        this._initHoldBuffer(size * 4);
-        const { gl, _pbo } = this;
-        gl.bindBuffer(gl.PIXEL_PACK_BUFFER, _pbo);
-        this.bindFBO();
-        gl.readBuffer(gl.COLOR_ATTACHMENT1); // This is the attachment we want to read
-        gl.readPixels(// This will read the pixels to the buffer asynchronously
-        startX, startY, lengthX, lengthY, gl.RED_INTEGER, gl.INT, 0);
-        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-        gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);
-        fence(this.gl).then(() => {
-            gl.bindBuffer(gl.PIXEL_PACK_BUFFER, _pbo);
-            // const data = new Int16Array(size);
-            const data = new Int32Array(size);
-            gl.getBufferSubData(gl.PIXEL_PACK_BUFFER, 0, data);
-            gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);
-            const result = this._pickFromBuffer(data, size);
-            callback(result);
-            // gl.deleteBuffer(pbo);
-            this._inProgress = false;
-        });
-        return true;
-    }
-    _pickFromBuffer(array, size) {
-        const selectedObjects = new Set();
-        for (let i = 0; i < size; i += 1) {
-            const id = array[i];
-            if (id !== ESCAPE_VALUE) {
-                selectedObjects.add(id);
-            }
-        }
-        return selectedObjects;
-    }
-    _initHoldBuffer(size) {
-        if (this._pbo && this._pboSize >= size) {
-            return;
-        }
-        const { gl } = this;
-        const pbo = gl.createBuffer();
-        gl.bindBuffer(gl.PIXEL_PACK_BUFFER, pbo);
-        gl.bufferData(gl.PIXEL_PACK_BUFFER, size, gl.STREAM_READ);
-        gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);
-        this._pboSize = size;
-        if (this._pbo !== undefined) {
-            gl.deleteBuffer(this._pbo);
-        }
-        this._pbo = pbo;
-    }
-    free() {
-        const { gl, colorTexture, indexTexture, fbo } = this;
-        gl.deleteTexture(colorTexture);
-        gl.deleteTexture(indexTexture);
-        gl.deleteFramebuffer(fbo);
-        textureOnCanvasProgramCache.release(this.gl);
-    }
-}
-export { PickerDisplayer };

package/dist/util/programs/draw-texture-on-canvas.js

@@ -1,86 +0,0 @@
-import { createProgram } from "../webglobjectbuilders";
-import { glProgramCache } from "../../programs";
-// import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../../programs/totems";
-const vs = `#version 300 es
-precision highp float;
-
-in vec2 a_position;
-out vec2 v_texcoord;
-
-void main() {
-    gl_Position = vec4(a_position, 0.0, 1.0);
-    v_texcoord = a_position * 0.5 + 0.5;
-}`;
-const fs = `#version 300 es
-precision highp float;
-
-uniform sampler2D u_texture;
-uniform float u_opacity;    
-in vec2 v_texcoord;
-out vec4 fragColor;
-
-void main() {
-    fragColor = texture(u_texture, v_texcoord);
-    fragColor.a *= u_opacity;
-}`;
-class TextureOnCanvasProgram {
-    constructor(gl) {
-        this.gl = gl;
-        this.vao = this.gl.createVertexArray();
-        this.buffer = this.gl.createBuffer();
-        this.gl.bindVertexArray(this.vao);
-        this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.buffer);
-        this.gl.bufferData(this.gl.ARRAY_BUFFER, new Float32Array([
-            -1, -1,
-            1, -1,
-            1, 1,
-            -1, 1
-        ]), this.gl.STATIC_DRAW);
-        this.gl.enableVertexAttribArray(0);
-        this.gl.vertexAttribPointer(0, 2, this.gl.FLOAT, false, 0, 0);
-        this.gl.bindVertexArray(null);
-        this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null);
-        this.program = createProgram(this.gl, vs, fs);
-        {
-            const { gl, program } = this;
-            this.uniforms = {
-                texture: gl.getUniformLocation(program, "u_texture"),
-                opacity: gl.getUniformLocation(program, "u_opacity"),
-            };
-        }
-        {
-            this._lastOpacity = 1.0;
-            const currentProgram = this.gl.getParameter(this.gl.CURRENT_PROGRAM);
-            this.gl.useProgram(this.program);
-            this.gl.uniform1f(this.uniforms.opacity, this._lastOpacity);
-            this.gl.useProgram(currentProgram);
-        }
-    }
-    draw(texture, { opacity = 1.0 } = {}) {
-        const { gl, program, uniforms, vao } = this;
-        gl.useProgram(program);
-        gl.bindVertexArray(vao);
-        gl.activeTexture(gl.TEXTURE0);
-        gl.bindTexture(gl.TEXTURE_2D, texture);
-        gl.uniform1i(uniforms.texture, 0);
-        if (this._lastOpacity !== opacity) {
-            gl.uniform1f(uniforms.opacity, opacity);
-            this._lastOpacity = opacity;
-        }
-        gl.drawArrays(gl.TRIANGLE_FAN, 0, 4);
-        gl.bindVertexArray(null);
-    }
-    free() {
-        if (this._isFreed)
-            return;
-        this.gl.deleteVertexArray(this.vao);
-        this.gl.deleteBuffer(this.buffer);
-        this.gl.deleteProgram(this.program);
-        this._isFreed = true;
-    }
-}
-const textureOnCanvasProgramCache = Object.freeze({
-    get: (gl) => glProgramCache.getProgram(gl, TextureOnCanvasProgram),
-    release: (gl) => glProgramCache.releaseProgram(gl, TextureOnCanvasProgram)
-});
-export { textureOnCanvasProgramCache };

package/dist/util/programs/index.js

@@ -1 +0,0 @@
-export * from "./shapesonglobe";

package/dist/util/programs/shapesonglobe.js

@@ -1,210 +0,0 @@
-import { createProgram } from "../webglobjectbuilders";
-import { CameraUniformBlockString, CameraUniformBlockTotemCache } from "../../programs/totems/camerauniformblock";
-import { shaderfunctions } from "..";
-/** TODO:
- * 3d icin calistir
- */
-const drawModeFunc = (gl) => {
-    return (mode) => {
-        return {
-            "point": gl.POINTS,
-            "line": gl.LINES,
-            "line_strip": gl.LINE_STRIP,
-            "line_loop": gl.LINE_LOOP,
-            "triangle": gl.TRIANGLES,
-            "triangle_strip": gl.TRIANGLE_STRIP,
-            "triangle_fan": gl.TRIANGLE_FAN
-        }[mode];
-    };
-};
-export class ShapesOnGlobeProgram {
-    constructor(gl, globe, drawMode = 'point') {
-        this.globe = globe;
-        this.gl = gl;
-        this._getDraw = drawModeFunc(gl);
-        this._drawMode = this._getDraw(drawMode);
-        this._is3D = true;
-        this._inBuffer = gl.createBuffer();
-        this._programWrapper = this._createProgramWrapper();
-        this._initUniforms();
-        this.setScreenWH();
-    }
-    _initUniforms() {
-        const { gl, _programWrapper } = this;
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-        this._getDrawMode = drawModeFunc(gl);
-        gl.useProgram(_programWrapper.program);
-        gl.uniform1f(_programWrapper.u_opacity, 1.0);
-        gl.uniform1f(_programWrapper.u_is3D, 1.0);
-        gl.uniform1f(_programWrapper.height, 0.0);
-        gl.uniform1f(_programWrapper.u_point_size, 1.0);
-        gl.useProgram(currentProgram);
-    }
-    _createProgramWrapper() {
-        const { gl, globe } = this;
-        const vertexSource = `#version 300 es
-            precision highp float;
-            ${CameraUniformBlockString}
-
-            in vec2 a_position;
-            in vec4 a_color;
-
-
-            uniform bool u_is3D;
-            uniform float height; 
-
-            uniform float u_point_size;
-
-            out vec4 v_color;
-
-            ` + shaderfunctions.pixelXYToCartesian3DPoint + `
-            ` + shaderfunctions.pixelXYToCartesian2DPoint + `
-
-
-            void main() {
-                vec3 pos = vec3(a_position, height);
-                if(is3D){
-                    pos = pixelXYToCartesian3DPoint(pos);
-                    gl_Position = projection * view * vec4(pos - translate, 1.0);
-                } else {
-                    vec2 xy = pixelXYToCartesian2DPoint(pos.xy, translate.xy, mapWH, screenWH);
-                    gl_Position = projection * vec4(xy.x, xy.y, 0.0, 1.0);
-                }
-                gl_PointSize = u_point_size;
-                v_color = a_color;
-            }
-            `;
-        const fragmentSource = `#version 300 es
-            precision highp float;
-
-            uniform float u_opacity;
-
-            in vec4 v_color;
-            out vec4 outColor;
-
-            void main() {
-                outColor = v_color;
-                outColor.a = u_opacity;
-            }   
-            `;
-        const program = createProgram(gl, vertexSource, fragmentSource);
-        const a_position = gl.getAttribLocation(program, 'a_position');
-        const a_color = gl.getAttribLocation(program, 'a_color');
-        // vao and buffer. 
-        const vao = gl.createVertexArray();
-        gl.bindVertexArray(vao);
-        gl.bindBuffer(gl.ARRAY_BUFFER, this._inBuffer);
-        gl.enableVertexAttribArray(a_position);
-        gl.vertexAttribPointer(a_position, 2, gl.FLOAT, false, 6 * 4, 0);
-        gl.enableVertexAttribArray(a_color);
-        gl.vertexAttribPointer(a_color, 4, gl.FLOAT, false, 6 * 4, 2 * 4);
-        gl.bindVertexArray(null);
-        const cm = CameraUniformBlockTotemCache.get(globe);
-        const bindingPoint = 0;
-        const cmIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
-        gl.uniformBlockBinding(program, cmIndex, bindingPoint);
-        return {
-            program: program,
-            vao: vao,
-            u_point_size: gl.getUniformLocation(program, 'u_point_size'),
-            u_opacity: gl.getUniformLocation(program, 'u_opacity'),
-            bindCamera: () => cm.bind(bindingPoint),
-            unbindCamera: () => cm.unbind(bindingPoint)
-        };
-    }
-    draw(uProjectionMatrix, uModelViewMatrix, uTranslate, drawRanges) {
-        const { gl, _programWrapper, _is3D } = this;
-        const deepTest = gl.isEnabled(gl.DEPTH_TEST);
-        gl.disable(gl.DEPTH_TEST);
-        gl.useProgram(_programWrapper.program);
-        gl.bindVertexArray(_programWrapper.vao);
-        gl.uniformMatrix4fv(_programWrapper.u_model_view_matrix, false, uModelViewMatrix);
-        gl.uniformMatrix4fv(_programWrapper.u_proj_matrix, false, uProjectionMatrix);
-        gl.uniform3f(_programWrapper.u_transpos, uTranslate.x, uTranslate.y, uTranslate.z);
-        gl.bindVertexArray(_programWrapper.vao);
-        _programWrapper.bindCamera();
-        if (!_is3D) {
-            const mapWH = this.globe.api_GetCurrentWorldWH();
-            gl.uniform2f(_programWrapper.u_mapWH, mapWH.width, mapWH.height);
-        }
-        for (const drawRange of drawRanges) {
-            gl.drawArrays(this._drawMode, drawRange[0], drawRange[1]);
-            // gl.drawArrays(gl.POINTS, drawRange[0], 1);
-        }
-        _programWrapper.unbindCamera();
-        gl.bindVertexArray(null);
-        if (deepTest) {
-            gl.enable(gl.DEPTH_TEST);
-        }
-    }
-    setOpacity(opacity) {
-        if (opacity < 0 || opacity > 1) {
-            throw new Error('Invalid opacity value');
-        }
-        ;
-        const { gl, _programWrapper } = this;
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-        gl.useProgram(_programWrapper.program);
-        gl.uniform1f(_programWrapper.u_opacity, opacity);
-        gl.useProgram(currentProgram);
-        this.globe.DrawRender();
-    }
-    setPointSize(size) {
-        const { gl, _programWrapper } = this;
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-        gl.useProgram(_programWrapper.program);
-        gl.uniform1f(_programWrapper.u_point_size, size);
-        gl.useProgram(currentProgram);
-        this.globe.DrawRender();
-    }
-    setDrawMode(mode) {
-        const modegl = this._getDraw(mode);
-        if (modegl) {
-            this._drawMode = modegl;
-        }
-        else {
-            throw new Error('Invalid draw mode ' + mode);
-        }
-    }
-    setScreenWH() {
-        const { gl, _programWrapper, globe } = this;
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-        gl.useProgram(_programWrapper.program);
-        gl.uniform2f(_programWrapper.u_scrWH, globe.api_ScrW(), globe.api_ScrH());
-        gl.useProgram(currentProgram);
-    }
-    resize(width, height) {
-        const { gl, _programWrapper, globe } = this;
-        width = width || globe.api_ScrW();
-        height = height || globe.api_ScrH();
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-        gl.useProgram(_programWrapper.program);
-        gl.uniform2f(_programWrapper.u_scrWH, width, height);
-        gl.useProgram(currentProgram);
-    }
-    setGeometry() {
-        const { gl, globe, _programWrapper } = this;
-        this._is3D = globe.api_GetCurrentGeometry() === 0;
-        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-        gl.useProgram(_programWrapper.program);
-        gl.uniform1f(_programWrapper.u_is3D, this._is3D ? 1.0 : 0.0);
-        gl.useProgram(currentProgram);
-        this.resize();
-    }
-    free() {
-        const { gl, _programWrapper } = this;
-        gl.deleteProgram(_programWrapper.program);
-        gl.deleteVertexArray(_programWrapper.vao);
-        gl.deleteBuffer(this._inBuffer);
-    }
-    /**
-     *
-     * @param {Float32Array} data
-     * @format [x, y, r, g, b, a, x, y, r, g, b, a, x, y, r, g, b, a, x, y, r, g, b, a]
-     */
-    setBufferData(data) {
-        const { gl } = this;
-        gl.bindBuffer(gl.ARRAY_BUFFER, this._inBuffer);
-        gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
-    }
-}