@pirireis/webglobeplugins 0.8.6 → 0.8.7

package/programs/picking/pickable-renderer.js

@@ -0,0 +1,216 @@
+import { createProgram } from "../../util";
+import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../totems";
+import { mercatorXYToGLPosition, cartesian3DToGLPosition, R_3D, R } from "../../util/shaderfunctions/geometrytransformations";
+import { noRegisterGlobeProgramCache } from "../programcache";
+import "../../util/gl-util/draw-options/types";
+import { drawArrays } from "../../util/gl-util/draw-options/methods";
+import { attributeLoader } from "../../util/gl-util/buffer/integrate-buffer";
+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 };

package/programs/point-on-globe/element-globe-surface-glow.js

@@ -0,0 +1,168 @@
+/**
+ *        *
+ *      *   *
+ *    *   *   *
+ *      *   *
+ *        *
+ */
+
+
+
+import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../totems";
+import { PI, mercatorXYToGLPosition, cartesian3DToGLPosition, circleLimpFromLongLatRadCenterCartesian3D_accurate } from "../../util/shaderfunctions/geometrytransformations";
+import { createProgram } from "../../util";
+import { noRegisterGlobeProgramCache } from "../programcache";
+import { attributeLoader } from "../../util/gl-util/buffer/integrate-buffer";
+import { drawInstanced } from "../../util/gl-util/draw-options/methods";
+import { UniformBlockManager } from "../../util/gl-util/uniform-block/manager";
+
+
+const uboBlockManager = new UniformBlockManager(
+    "FlexibleBlock",
+    [
+        { name: "u_color", type: "vec4" },
+        { name: "u_radius", type: "float" }
+    ],
+    1
+);
+
+const vs = `#version 300 es
+${PI}
+${CameraUniformBlockString}
+${cartesian3DToGLPosition}
+${circleLimpFromLongLatRadCenterCartesian3D_accurate}
+
+uniform float edge_count;
+
+in vec3 pos3D;
+in float radius;
+in vec4 color;
+
+${uboBlockManager.glslCode()}
+
+out vec4 vColor;
+
+void main() {
+
+    float radius_ = ( radius == -1.0 ) ? u_radius : radius;
+    vec4 color = ( color.r == -1.0 ) ? u_color : color;
+
+    if ( gl_VertexID == 0 ) {
+        gl_Position = cartesian3DToGLPosition(pos3D);
+        vColor = vColor;
+    } else {
+        float angle = PI * 2.0 * float( gl_VertexID - 1 ) / edge_count;
+        vec3 position = circleLimpFromLongLatRadCenterCartesian3D_accurate(pos3D, radius, angle);
+        gl_Position = cartesian3DToGLPosition(position);
+        float distance = distance(position, pos3D);
+
+        
+
+        vColor = vec4(color.rgb, color.a * (1.0 - distance / radius));
+    }
+}`;
+
+
+const fs = `#version 300 es
+precision highp float;
+
+uniform float opacity;
+in vec4 vColor;
+
+out vec4 fragColor;
+
+void main() {
+    fragColor = vColor;
+    fragColor.a *= opacity;
+}`;
+
+
+class Logic {
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+
+        this._vaoCache = [];
+
+        this.program = createProgram(this.gl, vs, fs);
+
+        const { gl, program } = this;
+
+        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(program);
+        // set uniform locations
+        this._uniforms = {
+            edge_count_loc: gl.getUniformLocation(program, "edge_count"),
+            edge_count: 40,
+            opacity_loc: gl.getUniformLocation(program, "opacity"),
+            opacity: 1.0
+        };
+        // last values
+        gl.uniform1f(this._uniforms.edge_count_loc, this._uniforms.edge_count);
+        gl.uniform1f(this._uniforms.opacity_loc, this._uniforms.opacity);
+
+        gl.useProgram(currentProgram);
+        // assign attribute locations
+        gl.bindAttribLocation(program, 0, "pos3D");
+        gl.bindAttribLocation(program, 1, "radius");
+        gl.bindAttribLocation(program, 2, "color");
+        // camera uniform block
+        this.cameraUniformBlockTotem = CameraUniformBlockTotemCache.get(globe);
+        this.cameraBlockBindingPoint = 0;
+        const cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+        gl.uniformBlockBinding(program, cameraBlockIndex, this.cameraBlockBindingPoint);
+
+        uboBlockManager.assignBindingPoint(this.gl, this.program);
+        this._defaultUBO = uboBlockManager.createUBO(this.gl);
+    }
+
+
+    createVAO(pos3DObj, radiusObj, colorObj) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        const divisor = 1;
+        gl.bindVertexArray(vao);
+
+        // TODO constants to escape values
+        attributeLoader(gl, pos3DObj, 0, 3, { divisor });
+        attributeLoader(gl, radiusObj, 1, 1, { divisor, escapeValues: [-1] });
+        attributeLoader(gl, colorObj, 2, 4, { divisor, escapeValues: [-1, -1, -1, -1] });
+
+        gl.bindVertexArray(null);
+        this._vaoCache.push(vao);
+        return vao;
+    }
+
+
+    draw(vao, drawOptions, opacity = 1.0, ubo = null) {
+        const { gl, program } = this;
+        gl.useProgram(program);
+        gl.bindVertexArray(vao);
+        if (opacity !== this._uniforms.opacity) {
+            gl.uniform1f(this._uniforms.opacity_loc, opacity);
+            this._uniforms.opacity = opacity;
+        }
+        ubo = ubo || this._defaultUBO;
+        ubo.bind();
+        drawInstanced(gl, gl.TRIANGLE_FAN, drawOptions);
+        ubo.unbind();
+        gl.bindVertexArray(null);
+    }
+
+
+    free() {
+        if (this._isFreed) return;
+        CameraUniformBlockTotemCache.release(this.globe);
+        this.gl.deleteProgram(this.program);
+        for (const vao of this._vaoCache) this.gl.deleteVertexArray(vao);
+        this._isFreed = true;
+    }
+}
+
+
+const ElementGlobeSufaceGlowCache = Object.freeze({
+    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, Logic),
+    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe)
+})
+
+export { ElementGlobeSufaceGlowCache };

package/programs/point-on-globe/element-point-glow.js

@@ -0,0 +1,184 @@
+import { createProgram } from "../../util";
+import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../totems";
+import { mercatorXYToGLPosition, cartesian3DToGLPosition } from "../../util/shaderfunctions/geometrytransformations";
+import { noRegisterGlobeProgramCache } from "../programcache";
+import { attributeLoader } from "../../util/gl-util/buffer/integrate-buffer";
+import { drawArrays } from "../../util/gl-util/draw-options/methods";
+import { UniformBlockManager } from "../../util/gl-util/uniform-block/manager";
+import { singularity } from "../../shaders/fragment-toy/singularity";
+import { firework } from "../../shaders/fragment-toy/firework";
+
+
+const cameraBlockBindingPoint = 0;
+const flexibleBlockBindingPoint = 1;
+
+const uniformBlockManager = new UniformBlockManager(
+    "FlexibleBlock",
+    [
+        { name: "u_rgba", type: "vec4", value: new Float32Array([1, 1, 1, 1]) },
+        { name: "u_size_multiplier", type: "float", value: new Float32Array([1.0]) },
+        { name: "u_opacity", type: "float", value: new Float32Array([1.0]) },
+        { name: "u_size", type: "float", value: new Float32Array([1.0]) },
+        { name: "u_minimumSize", type: "float", value: new Float32Array([25.0]) },
+        { name: "u_phase", type: "float", value: new Float32Array([1.0]) },
+    ], flexibleBlockBindingPoint);
+
+const vs = `#version 300 es
+precision highp float;
+
+${CameraUniformBlockString}
+${mercatorXYToGLPosition}
+${cartesian3DToGLPosition}
+
+${uniformBlockManager.glslCode()}
+
+
+in vec3 pos3D;
+in vec2 pos2D;
+in vec4 color;
+in float size;
+
+out vec4 vColor;
+flat out float v_size;
+
+
+
+void main() {
+
+    if(is3D){
+        gl_Position = cartesian3DToGLPosition(pos3D);
+    }
+    else {
+        gl_Position = mercatorXYToGLPosition(pos2D);
+    }
+
+    gl_PointSize = max(
+        ((size == -1.0) ? u_size  : size ) * u_size_multiplier,
+        u_minimumSize);
+    v_size = gl_PointSize;
+    vColor = (color.r == -1.0) ? u_rgba : color;
+    vColor.a *= u_opacity;
+
+}`;
+
+
+const fs = `#version 300 es
+precision highp float;
+
+${uniformBlockManager.glslCode()}
+
+in vec4 vColor;
+out vec4 fragColor;
+
+flat in float v_size;
+
+${firework}
+${singularity} 
+
+void main() {
+    fragColor = vColor;
+
+    float dist = distance(gl_PointCoord, vec2(0.5, 0.5)) * 2.0;
+    if ( dist > 1.0) discard;
+
+    // center glow
+    float center_alpha = smoothstep(0.5, 0.0, dist) * 0.3;
+    // center_alpha = smoothstep(0.0, 1.0, center_alpha);
+
+    // circle pattern
+    float threshold = fract(( - dist + u_phase - 0.5));
+    float circle_alpha = sin( threshold * 1.57 );
+    circle_alpha = smoothstep((v_size / (v_size + .5)), 1.0, circle_alpha);
+
+    float outer_circle_alpha = sin(dist * 1.57 );
+    outer_circle_alpha = smoothstep((v_size / (v_size + .5)), 1.0, outer_circle_alpha);
+
+    // fragColor = singularity(gl_PointCoord, u_phase);
+
+    fragColor.a *= smoothstep(0.0, 1.1, ( 0.4 * u_opacity + center_alpha +  circle_alpha+ outer_circle_alpha)); 
+}`;
+
+class Logic {
+
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+
+        this.program = createProgram(this.gl, vs, fs);
+
+        const { gl, program } = this;
+
+
+        gl.bindAttribLocation(program, 0, "pos3D");
+        gl.bindAttribLocation(program, 1, "pos2D");
+        gl.bindAttribLocation(program, 2, "color");
+        gl.bindAttribLocation(program, 3, "size");
+        // assign uniform block
+
+        this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
+        this.cameraBlockTotem.assignBindingPoint(program, cameraBlockBindingPoint);
+
+        uniformBlockManager.assignBindingPoint(this.gl, this.program);
+        this._defaultUBO = uniformBlockManager.createUBO(this.gl);
+    }
+
+
+    createVAO(pos3DBuffer, pos2DBuffer, colorBuffer, sizeBuffer) {
+
+        const { gl } = this;
+
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+
+        attributeLoader(gl, pos3DBuffer, 0, 3);
+        attributeLoader(gl, pos2DBuffer, 1, 2);
+        attributeLoader(gl, colorBuffer, 2, 4, { escapeValues: [-1, -1, -1, -1] });
+        attributeLoader(gl, sizeBuffer, 3, 1, { escapeValues: [-1] });
+
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+
+        return vao;
+    }
+
+
+    createUBO() {
+        const ubo = uniformBlockManager.createUBO(this.gl);
+        return ubo;
+    }
+
+    draw(vao, drawOptions, ubo = null) {
+        const { gl, program, cameraBlockTotem } = this;
+        gl.useProgram(program);
+        gl.bindVertexArray(vao);
+        cameraBlockTotem.bind(cameraBlockBindingPoint);
+
+        ubo = ubo || this._defaultUBO;
+
+        ubo.bind();
+        drawArrays(gl, gl.POINTS, drawOptions);
+        ubo.unbind();
+
+        gl.bindVertexArray(null);
+        cameraBlockTotem.unbind(cameraBlockBindingPoint);
+        this.globe.DrawRender();
+    }
+
+
+
+    // for singleton cache interation
+
+    free() {
+        if (this._isFreed) return;
+        CameraUniformBlockTotemCache.release(this.globe);
+        this.gl.deleteProgram(this.program);
+        this._isFreed = true;
+    }
+}
+
+const ElementPointGlowProgramCache = Object.freeze({
+    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, Logic),
+    release: globe => noRegisterGlobeProgramCache.releaseProgram(globe, Logic)
+});
+
+export { ElementPointGlowProgramCache };

package/programs/point-on-globe/square-pixel-point.js

@@ -171,8 +171,6 @@ class PointOnGlobeProgram {
         gl.bindVertexArray(null);
     }
 
-
-
     free() {
         if (this._isFreed) return;
         const { gl, globe } = this;
@@ -183,9 +181,9 @@ class PointOnGlobeProgram {
 }
 
 
-const pointOnGlobeProgramCache = Object.freeze({
+const PointOnGlobeProgramCache = Object.freeze({
     get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, PointOnGlobeProgram),
     release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, PointOnGlobeProgram)
 });
 
-export { pointOnGlobeProgramCache };
+export { PointOnGlobeProgramCache };

package/programs/programcache.js

@@ -33,6 +33,9 @@ const globeProgramCache = (function () {
 
     function releaseProgram(globe, ProgramClass) {
         if (cache.has(globe) && cache.get(globe).has(ProgramClass)) {
+            if (cache.get(globe).get(ProgramClass).count === 0) {
+                throw new Error("The program counter is already 0, cannot release program");
+            }
             cache.get(globe).get(ProgramClass).count--;
             if (cache.get(globe).get(ProgramClass).count === 0) {
                 globe.api_UnRegisterPlugin(cache.get(globe).get(ProgramClass).program.id); // it calls program.free()
@@ -68,6 +71,9 @@ const glProgramCache = (function () {
 
     function releaseProgram(gl, ProgramClass) {
         if (cache.has(gl) && cache.get(gl).has(ProgramClass)) {
+            if (cache.get(gl).get(ProgramClass).count === 0) {
+                throw new Error("The program counter is already 0, cannot release program");
+            }
             cache.get(gl).get(ProgramClass).count--;
             if (cache.get(gl).get(ProgramClass).count === 0) {
                 cache.get(gl).get(ProgramClass).program.free();
@@ -103,6 +109,9 @@ const noRegisterGlobeProgramCache = (function () {
 
     function releaseProgram(globe, ProgramClass) {
         if (cache.has(globe) && cache.get(globe).has(ProgramClass)) {
+            if (cache.get(globe).get(ProgramClass).count === 0) {
+                throw new Error("The program counter is already 0, cannot release program");
+            }
             cache.get(globe).get(ProgramClass).count--;
             if (cache.get(globe).get(ProgramClass).count === 0) {
                 cache.get(globe).get(ProgramClass).program.free();

package/programs/rings/partial-ring/piece-of-pie.js

@@ -309,7 +309,7 @@ export class Logic {
 
 }
 
-export const pieceOfPieProgramCache = Object.freeze({
+export const PieceOfPieProgramCache = Object.freeze({
     get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, Logic),
     release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, Logic)
 });

package/programs/totems/camerauniformblock.js

@@ -30,6 +30,10 @@ export default class
         this.gl = null;
         this.globe = null;
         this.ubo = null;
+        this._isMovedParams = {
+            lastLod: null,
+            isMoved: false,
+        }
     }
 
 
@@ -75,7 +79,7 @@ export default class
 
         const { gl, traslateFloat32, ubo, mapWHFloat32, globe } = this;
         gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
-        {   // view, projection, translate
+        {   // view, projection, translat
             gl.bufferSubData(gl.UNIFORM_BUFFER, 0, modelView);
             gl.bufferSubData(gl.UNIFORM_BUFFER, 64, projection);
             traslateFloat32.set([translate.x, translate.y, translate.z], 0);
@@ -101,12 +105,24 @@ export default class
             gl.bufferSubData(gl.UNIFORM_BUFFER, 164, new Float32Array([
                 Distance, Radian * Tilt, Radian * NorthAng, Radian * CenterLong, Radian * CenterLat
             ]));
-
         }
+
         gl.bindBuffer(gl.UNIFORM_BUFFER, null);
 
+        {   // isMoved
+            const currentLOD = globe.api_GetCurrentLODWithDecimal()
+            this._isMovedParams.isMoved = this._isMovedParams.lastLod !== currentLOD || globe.api_IsScreenMoving();
+            this._isMovedParams.lastLod = currentLOD;
+        }
     }
 
+    assignBindingPoint(program, bindingPoint) {
+        const { gl } = this;
+        const cameraBlockIndex = gl.getUniformBlockIndex(program, "CameraUniformBlock");
+        gl.uniformBlockBinding(program, cameraBlockIndex, bindingPoint);
+    }
+
+
     getUBO() {
         return this.ubo;
     }
@@ -124,6 +140,11 @@ export default class
     }
 
 
+    isMoved() {
+        return this._isMovedParams.isMoved;
+    }
+
+
     free() {
         const { gl, ubo } = this;
         gl.deleteBuffer(ubo);