@pirireis/webglobeplugins 0.9.6 → 0.9.7

package/programs/arrowfield/object.js

@@ -1,89 +0,0 @@
-// this contains vao, drawCount, ArrowBufferBlock, vao,
-// how to, where to set instanced parameters
-// the vectorfield buffer should be managed outside, since it can be static or dynamic.
-
-import Logic from './logic';
-import { globeProgramCache } from '../programcache';
-import { longlatbbox2normalbbox } from "../util";
-
-export default class ArrowField {
-    constructor(gl, globe, {
-        minLon = -180,
-        maxLon = 180,
-        minLat = -90,
-        maxLat = 90,
-        height = 0,
-        opacity = 1,
-        color = [0.04, 0.2, 0.8],
-        targetWidth = 100,
-        targetHeight = 100,
-        dataWidth = null,
-        dataHeight = null,
-        tailLengthRatio = 1,
-        wingLengthRatio = 0.5,
-        noDataValue = null,
-        // maxMagnitude = null
-    } = {}) {
-        this.gl = gl;
-        this.globe = globe;
-
-        this.program = globeProgramCache.getProgram(globe, Logic);
-        this.arrowBlockManager = this.program.getArrowBlockBufferManager();
-        this.instanceCount = targetWidth * targetHeight;
-        this.arrowBlockManager.update({ resolution: [targetWidth, targetHeight] });
-        this.textureManager = this.program.getTextureManager(dataWidth, dataHeight);
-        this.setBBox({ minLon, maxLon, minLat, maxLat });
-        this.update({ height, opacity, color, tailLengthRatio, wingLengthRatio, noDataValue });
-    }
-
-
-    setBBox({ minLon = -180, maxLon = 180, minLat = -90, maxLat = 90 } = {}) {
-        this.bbox = { minLon, maxLon, minLat, maxLat };
-        const { bboxSizeRad, bboxOffsetRad } = longlatbbox2normalbbox(this.bbox);
-        this.arrowBlockManager.update({ bboxSizeRad, bboxOffsetRad });
-        this.globe.DrawRender();
-    }
-
-
-    update({ height, opacity, color, resolution, tailLengthRatio, wingLengthRatio, noDataValue } = {}) {
-        if (resolution) {
-            this.instanceCount = resolution[0] * resolution[1];
-        }
-        this.arrowBlockManager.update({
-            color,
-            resolution,
-            height,
-            opacity,
-            tailLengthRatio,
-            wingLengthRatio,
-            noDataValue,
-        });
-        this.globe.DrawRender();
-    }
-
-    setTargetResolution(width, height) {
-        this.instanceCount = width * height;
-        this.arrowBlockManager.update({ resolution: [width, height] });
-
-        this.globe.DrawRender();
-    }
-
-    draw() {
-        const { program, arrowBlockManager, textureManager, instanceCount } = this;
-        program.draw(arrowBlockManager, textureManager, instanceCount);
-    }
-
-
-    setData(rotation) {
-        this.textureManager.setData(rotation);
-        this.globe.DrawRender();
-    }
-
-
-    free() {
-        this.arrowBlockManager.free();
-        this.textureManager.free();
-        globeProgramCache.releaseProgram(this.gl, Logic);
-    }
-}
-

package/programs/data2legend/density-to-legend.js

@@ -1,115 +0,0 @@
-import { createProgram } from "../../util/";
-import { noRegisterGlobeProgramCache } from "../programcache";
-
-
-const vs = `#version 300 es
-precision highp float;
-
-uniform sampler2D u_density_texture;
-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_legend_texture;
-uniform sampler2D u_density_texture;
-
-uniform float u_opacity;
-in vec2 v_texcoord;
-out vec4 fragColor;
-
-void main() {
-    float density = texture(u_density_texture, v_texcoord).r;
-    fragColor = texture(u_legend_texture, vec2(density, 0.5));
-    fragColor.a *= u_opacity * sqrt(density);
-}`;
-
-
-
-
-class DensityToLegendProgram {
-    constructor(globe) {
-        this.globe = globe;
-        this.gl = globe.gl;
-        this.program = createProgram(globe.gl, vs, fs);
-        const { gl, program } = this;
-        this.uniforms = {
-            densityTexture: gl.getUniformLocation(program, "u_density_texture"),
-            legendTexture: gl.getUniformLocation(program, "u_legend_texture"),
-            opacity: gl.getUniformLocation(program, "u_opacity"),
-        }
-        { // assign attribute locations
-            gl.bindAttribLocation(program, 0, "a_position");
-        }
-        {
-            this.vao = gl.createVertexArray();
-            const a_positionLocation = gl.getAttribLocation(program, "a_position");
-            gl.bindVertexArray(this.vao);
-
-            const buffer = gl.createBuffer();
-            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-            gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
-                -1, -1,
-                1, -1,
-                1, 1,
-                -1, 1,
-            ]), gl.STATIC_DRAW);
-            gl.enableVertexAttribArray(a_positionLocation);
-            gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
-            gl.bindVertexArray(null);
-            // gl.bindBuffer(gl.ARRAY_BUFFER, null);
-            this._buffer = buffer;
-        }
-
-        {
-            this._lastOpacity = 1;
-            const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-            gl.useProgram(program);
-            gl.uniform1f(this.uniforms.opacity, this._lastOpacity);
-            gl.useProgram(currentProgram);
-        }
-    }
-
-
-    draw(densityTexture, legendTexture, opacity) {
-        const { gl, program, uniforms } = this;
-        gl.useProgram(program);
-        gl.bindVertexArray(this.vao);
-        gl.activeTexture(gl.TEXTURE1);
-        gl.bindTexture(gl.TEXTURE_2D, legendTexture);
-        gl.uniform1i(uniforms.legendTexture, 1);
-        gl.activeTexture(gl.TEXTURE0);
-        gl.bindTexture(gl.TEXTURE_2D, densityTexture);
-        gl.uniform1i(uniforms.densityTexture, 0);
-        if (this._lastOpacity !== opacity) {
-            gl.uniform1f(uniforms.opacity, opacity);
-            this._lastOpacity = opacity;
-        }
-        gl.drawArrays(gl.TRIANGLE_FAN, 0, 4);
-        gl.bindVertexArray(null);
-    }
-
-
-    free() {
-        const gl = this.gl;
-        gl.deleteVertexArray(this.vao);
-        gl.deleteBuffer(this._buffer);
-        gl.deleteProgram(this.program);
-    }
-}
-
-
-const densityToLegendProgramCache = {
-    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, DensityToLegendProgram),
-    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, DensityToLegendProgram)
-}
-
-export { densityToLegendProgramCache };

package/programs/data2legend/point-to-density-texture.js

@@ -1,114 +0,0 @@
-import { createProgram } from "../../util/";
-import { noRegisterGlobeProgramCache } from "../programcache";
-import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../totems/camerauniformblock";
-import { mercatorXYToGLPosition, cartesian3DToGLPosition } from "../../util/shaderfunctions/geometrytransformations";
-
-
-const vs = `#version 300 es
-precision highp float;
-
-${CameraUniformBlockString}
-${mercatorXYToGLPosition}
-${cartesian3DToGLPosition}
-
-in vec3 position;
-uniform float pointSize;
-
-void main() {
-    if (is3D) {
-        gl_Position = cartesian3DToGLPosition(position);
-    } else {
-        gl_Position = mercatorXYToGLPosition(position.xy);
-    }
-    gl_PointSize = pointSize;
-}
-`;
-
-
-const fs = `#version 300 es
-precision highp float;
-out vec4 fragColor;
-
-void main() {
-    float r = length(gl_PointCoord - 0.5) * 2.0;
-    if (r > 1.0) discard;
-    // float density = smoothstep(0.1, 1.0, 1.0 - r);
-    fragColor = vec4((15.0/16.0)*sqrt(1.0-sqrt(r)));
-}`;
-
-
-
-class PointHeatmapProgram {
-
-    constructor(globe) {
-        this.globe = globe;
-        this.gl = globe.gl;
-        this._isFreed = false;
-        this.program = createProgram(globe.gl, vs, fs);
-
-        const { gl, program } = this;
-        this.uniforms = {
-            pointSize: gl.getUniformLocation(this.program, "pointSize"),
-        }
-        { // assign attribute locations 
-            gl.bindAttribLocation(program, 0, "position");
-        }
-
-        { // arrange camera uniform block
-            this.cameraBlockBingingPoint = 0;
-            this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
-            const cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
-            gl.uniformBlockBinding(program, cameraBlockIndex, this.cameraBlockBingingPoint);
-        }
-
-        { // last values
-            this._lastPointSize = 0;
-
-            const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
-            gl.useProgram(program);
-            gl.uniform1f(this.uniforms.pointSize, this._lastPointSize);
-            gl.useProgram(currentProgram);
-        }
-    }
-
-
-    createVAO(positionBuffer, vectorSize) {
-        const gl = this.gl;
-        const vao = gl.createVertexArray();
-        gl.bindVertexArray(vao);
-        gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);
-        gl.enableVertexAttribArray(0);
-        gl.vertexAttribPointer(0, vectorSize, gl.FLOAT, false, 0, 0);
-        gl.bindVertexArray(null);
-        return vao;
-    }
-
-    draw(vao, length, pointSize = 5.0) {
-        const gl = this.gl;
-        gl.useProgram(this.program);
-        if (pointSize !== this._lastPointSize) {
-            gl.uniform1f(this.uniforms.pointSize, pointSize);
-            this._lastPointSize = pointSize;
-        }
-        gl.bindVertexArray(vao);
-        this.cameraBlockTotem.bind(this.cameraBlockBingingPoint);
-        gl.drawArrays(gl.POINTS, 0, length);
-        this.cameraBlockTotem.unbind(this.cameraBlockBingingPoint);
-        gl.bindVertexArray(null);
-    }
-
-    free() {
-        if (this._isFreed) return;
-        const { gl, globe } = this;
-        CameraUniformBlockTotemCache.release(globe);
-        gl.deleteProgram(this.program);
-        this._isFreed = true;
-    }
-}
-
-const pointToDensityTextureCache = {
-    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, PointHeatmapProgram),
-    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, PointHeatmapProgram)
-}
-
-export { pointToDensityTextureCache }; 

package/programs/float2legendwithratio/index.js

@@ -1,3 +0,0 @@
-import Float2LegendWithRatio from './object';
-
-export { Float2LegendWithRatio };

package/programs/float2legendwithratio/logic.js

@@ -1,194 +0,0 @@
-import { createProgram } from "../../util";
-
-export default class {
-
-
-    constructor(gl) {
-        this.gl = gl;
-        // console.log("Float2LegendWithRatioProgram gl:", gl);
-        this._width = 1;
-        this._height = 1;
-
-        this._blendRatio = 0.0;
-        this.programWrapper = this._createProgramWrapper();
-    }
-
-
-    _createProgramWrapper() {
-        const vertexShaderSource = `#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;
-            v_texcoord.y = 1.0 - v_texcoord.y;
-        }
-        `;
-
-        const fragmentShaderSource = `#version 300 es
-        precision highp float;
-
-        in vec2 v_texcoord;
-        uniform sampler2D u_float_texture0;
-        uniform sampler2D u_float_texture1;
-        uniform sampler2D u_color_texture;
-        
-        layout(std140) uniform HeatParametersBlock {
-            vec2 u_color_ramp_range; // x is min, y is range ( max - min)
-            vec2 u_min_max;
-            float u_escape_value;
-            float u_blend_ratio;
-        };
-
-        out vec4 outColor;
-
-        void main() {
-            if ( u_blend_ratio < 0.0) {
-                outColor = vec4(0.0, 0.0, 0.0, 0.0);
-                return;
-            }
-            float f0 = texture(u_float_texture0, v_texcoord).r;
-            float f1 = texture(u_float_texture1, v_texcoord).r;
-            // outColor = vec4(
-
-            if (f0 == u_escape_value || f1 == u_escape_value) {   
-                outColor = vec4(0.0, 0.0, 0.0, 0.0);
-                return;
-            }
-            float x  = mix(f0, f1, u_blend_ratio);
-            if ( x < u_min_max.x || x > u_min_max.y) {
-                outColor = vec4(0.0, 0.0, 0.0, 0.0);
-                return;    
-            }
-            x = (x - u_color_ramp_range.x) / u_color_ramp_range.y;            
-            outColor = texture(u_color_texture, vec2(x, 0.5));
-        }
-        `;
-
-        const gl = this.gl;
-        const program = createProgram(gl, vertexShaderSource, fragmentShaderSource);
-        const vao = gl.createVertexArray();
-        gl.bindVertexArray(vao);
-        const buffer = gl.createBuffer();
-        this._buffer = buffer;
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
-            -1, -1,
-            1, -1,
-            1, 1,
-            -1, 1
-        ]), gl.STATIC_DRAW);
-        const positionLocation = gl.getAttribLocation(program, "a_position");
-        gl.enableVertexAttribArray(positionLocation);
-        gl.vertexAttribPointer(positionLocation, 2, gl.FLOAT, false, 0, 0);
-        gl.bindVertexArray(null);
-
-        this.heatParametersBlockBindingPoint = 0;
-
-        const heatParametersBlockIndex = gl.getUniformBlockIndex(program, "HeatParametersBlock");
-        gl.uniformBlockBinding(program, heatParametersBlockIndex, this.heatParametersBlockBindingPoint);
-
-
-        return {
-            program,
-            vao,
-            u_float_texture0: gl.getUniformLocation(program, "u_float_texture0"),
-            u_float_texture1: gl.getUniformLocation(program, "u_float_texture1"),
-            u_color_texture: gl.getUniformLocation(program, "u_color_texture"),
-            u_blend_ratio: gl.getUniformLocation(program, "u_blend_ratio"),
-            u_color_ramp_range: gl.getUniformLocation(program, "u_color_ramp_range"),
-            u_min_max: gl.getUniformLocation(program, "u_min_max"),
-            u_escape_value: gl.getUniformLocation(program, "u_escape_value")
-        };
-    }
-
-
-    getUniformBlockManager() {
-        return new HeatParametersBlockManager(this.gl);
-    }
-    draw(texture0, texture1, colorRampTexture, heatParametersBlockManager) {
-        const { gl, programWrapper } = this;
-        const { program, u_float_texture0, u_float_texture1, u_color_texture } = programWrapper;
-
-        gl.useProgram(program);
-        gl.bindVertexArray(programWrapper.vao);
-        gl.activeTexture(gl.TEXTURE1);
-        gl.bindTexture(gl.TEXTURE_2D, texture1);
-        gl.uniform1i(u_float_texture1, 1);
-        gl.activeTexture(gl.TEXTURE2);
-        gl.bindTexture(gl.TEXTURE_2D, colorRampTexture);
-        gl.uniform1i(u_color_texture, 2);
-        gl.activeTexture(gl.TEXTURE0);
-        gl.bindTexture(gl.TEXTURE_2D, texture0);
-        gl.uniform1i(u_float_texture0, 0);
-        heatParametersBlockManager.bind();
-        // clear output texture
-        gl.clearColor(0, 0, 0, 0);
-        gl.drawArrays(gl.TRIANGLE_FAN, 0, 4);
-        gl.bindVertexArray(null);
-        heatParametersBlockManager.unbind();
-    }
-
-
-    free() {
-        const gl = this.gl;
-        gl.deleteBuffer(this._buffer);
-        gl.deleteProgram(this.programWrapper.program);
-        gl.deleteVertexArray(this.programWrapper.vao);
-    }
-
-}
-
-
-class HeatParametersBlockManager {
-    constructor(gl) {
-        this.gl = gl;
-        this.buffer = gl.createBuffer();
-        gl.bindBuffer(gl.UNIFORM_BUFFER, this.buffer);
-        gl.bufferData(gl.UNIFORM_BUFFER, 24, gl.DYNAMIC_DRAW);
-        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-    }
-
-
-    /*
-    * @param {Array<number>} color_ramp_range  [minValue,( maxValue - minValue)]
-    * @param {Array<number>} min_max [minEdge, maxEdge]
-    * @param {number} escape_value // value that will be ignored
-    * @param {number} blend_ratio // ratio of blending between two textures
-    * */
-    update({ color_ramp_range = null, min_max = null, escape_value = null, blend_ratio = null }) {
-        const { gl, buffer } = this;
-        gl.bindBuffer(gl.UNIFORM_BUFFER, buffer);
-        if (color_ramp_range) {
-            gl.bufferSubData(gl.UNIFORM_BUFFER, 0, new Float32Array(color_ramp_range));
-        }
-        if (min_max) {
-            gl.bufferSubData(gl.UNIFORM_BUFFER, 8, new Float32Array(min_max));
-        }
-        if (escape_value) {
-            gl.bufferSubData(gl.UNIFORM_BUFFER, 16, new Float32Array([escape_value]));
-        }
-        if (blend_ratio) {
-            gl.bufferSubData(gl.UNIFORM_BUFFER, 20, new Float32Array([blend_ratio]));
-        }
-        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-    }
-
-    bind() {
-        const { gl, buffer } = this;
-        gl.bindBufferBase(gl.UNIFORM_BUFFER, this.heatParametersBlockBindingPoint, buffer);
-    }
-
-    free() {
-        this.gl.deleteBuffer(this.buffer);
-    }
-
-    unbind() {
-        const { gl } = this;
-        gl.bindBufferBase(gl.UNIFORM_BUFFER, this.heatParametersBlockBindingPoint, null);
-    }
-
-}

package/programs/float2legendwithratio/object.js

@@ -1,141 +0,0 @@
-import Float2LegentWithRatioProgram from './logic';
-import { glProgramCache } from '../programcache';
-
-// Uniform Buffer Objects use this 
-
-export default class DataObject {
-    constructor(gl, {
-        width = 1,
-        height = 1,
-        texture0 = null,
-        texture1 = null,
-        colorRampTexture = null,
-        colorRampRange = null,
-        escapeValue = 99999,
-        blendRatio = 0.0,
-        minMaxEdges = null,
-    } = {}) {
-        this.gl = gl;
-        this.programlogic = glProgramCache.getProgram(gl, Float2LegentWithRatioProgram);
-        this.heatParametersBlockManager = this.programlogic.getUniformBlockManager();
-        this.width = width;
-        this.height = height;
-        this.texture0 = texture0 || this._createColorRampTexture(width, height);
-        this.texture1 = texture1 || this._createColorRampTexture(width, height);
-        this.colorRampTexture = colorRampTexture || this._createColorRampTexture();
-        this.minMaxEdges = minMaxEdges || new Float32Array([-99999, 99999]);
-        this.heatParametersBlockManager.update({
-            escape_value: escapeValue,
-            blend_ratio: blendRatio,
-            min_max: minMaxEdges,
-            color_ramp_range: colorRampRange
-
-        });
-
-    }
-
-
-    _bindBlock() {
-        const gl = this.gl;
-        const program = this.programlogic.programWrapper.program;
-        gl.uniformBlockBinding(program, gl.getUniformBlockIndex(program, 'Block'), 0);
-
-    }
-
-
-    _createColorRampTexture() {
-        const { gl } = this;
-        const texture = gl.createTexture();
-        gl.bindTexture(gl.TEXTURE_2D, texture);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-        gl.bindTexture(gl.TEXTURE_2D, null);
-        return texture;
-    }
-
-    setBlendRatio(ratio) {
-        if (ratio < 0 || ratio > 1) {
-            console.warn('Invalid blend ratio');
-            return;
-        }
-        this.heatParametersBlockManager.update({ blend_ratio: ratio });
-    }
-
-    setEscapeValue(value) {
-        this.heatParametersBlockManager.update({ escape_value: value });
-    }
-
-
-    setTexture0(texture) {
-        this.texture0 = texture;
-    }
-
-    setTexture1(texture) {
-        this.texture1 = texture;
-    }
-
-    setColorRampTexture(texture) {
-        this.colorRampTexture = texture;
-    }
-
-
-    setDataWidthHeight(width, height) {
-        this.width = width;
-        this.height = height;
-    }
-
-
-    setFloatTextureData(data0, data1, width, height, yFlip = false) {
-        const { texture0, texture1, gl } = this;
-
-        gl.bindTexture(gl.TEXTURE_2D, texture0);
-        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, yFlip);
-        gl.texImage2D(gl.TEXTURE_2D, 0, gl.R16F, width, height, 0, gl.RED, gl.FLOAT, data0);
-        gl.bindTexture(gl.TEXTURE_2D, texture1);
-        gl.texImage2D(gl.TEXTURE_2D, 0, gl.R16F, width, height, 0, gl.RED, gl.FLOAT, data1);
-        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
-    }
-
-
-    discard() {
-        this.heatParametersBlockManager.update({ blend_ratio: -1 });
-    }
-
-
-    setColorRampTextureData(data, size) {
-        const { gl, colorRampTexture } = this;
-        gl.bindTexture(gl.TEXTURE_2D, colorRampTexture);
-        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
-    }
-
-    setColorRampRange(min, max) {
-        if (min > max) {
-            console.warn('Invalid min max values');
-            return;
-        }
-        const range = max - min;
-        this.heatParametersBlockManager.update({ color_ramp_range: new Float32Array([min, range]) });
-    }
-
-    setMinMaxEdges(min, max) {
-        if (min) this.minMaxEdges[0] = min;
-        if (max) this.minMaxEdges[1] = max;
-        this.heatParametersBlockManager.update({ min_max: this.minMaxEdges });
-    }
-
-    draw() {
-        this.programlogic.draw(this.texture0, this.texture1, this.colorRampTexture, this.heatParametersBlockManager);
-    }
-
-    free() {
-        const { gl, texture0, texture1, colorRampTexture } = this;
-        gl.deleteTexture(texture0);
-        gl.deleteTexture(texture1);
-        gl.deleteTexture(colorRampTexture);
-        glProgramCache.releaseProgram(this.gl, Float2LegentWithRatioProgram);
-        this.heatParametersBlockManager.free();
-
-    }
-}

package/programs/globe-util/is-globe-moved.js

@@ -1,27 +0,0 @@
-import { noRegisterGlobeProgramCache } from "../programcache";
-
-class IsGlobeMoved {
-    constructor(globe) {
-        this.globe = globe;
-
-        this._lastLOD = globe.api_GetCurrentLODWithDecimal();
-    }
-
-    isMoved() {
-        const globe = this.globe;
-        if (globe.api_IsScreenMoving() || this._lastLOD != globe.api_GetCurrentLODWithDecimal()) {
-            this._lastLOD = globe.api_GetCurrentLODWithDecimal();
-            return true;
-        }
-        return false;
-    }
-
-
-}
-
-
-
-const IsGlobeMovedCache = Object.freeze({
-    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, IsGlobeMoved),
-    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, IsGlobeMoved)
-});

package/programs/globeshell/index.js

@@ -1,2 +0,0 @@
-import GlobeShellWiggle from "./globeshell/wiggle";
-export { GlobeShellWiggle };

package/programs/globeshell/wiggle/index.js

@@ -1,6 +0,0 @@
-import GlobeShellWiggle from './object'
-
-export {
-    GlobeShellWiggle
-
-}