@pirireis/webglobeplugins 0.15.35 → 0.16.0

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

@@ -1,5 +1,7 @@
-import { createProgram } from "../../util/";
-import { noRegisterGlobeProgramCache } from "../programcache";
+import { createProgram } from "../../util/";
+import { noRegisterGlobeProgramCache } from "../programcache";
+
+
 const vs = `#version 300 es
 precision highp float;
 
@@ -11,7 +13,9 @@ 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;
 
@@ -26,73 +30,86 @@ 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 };
+}`;
+
+
+
+
+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,7 +1,9 @@
-import { createProgram } from "../../util/";
-import { noRegisterGlobeProgramCache } from "../programcache";
-import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../totems/camerauniformblock";
-import { mercatorXYToGLPosition, cartesian3DToGLPosition } from "../../util/shaderfunctions/geometrytransformations";
+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;
 
@@ -20,7 +22,9 @@ void main() {
     }
     gl_PointSize = pointSize;
 }
-`;
+`;
+
+
 const fs = `#version 300 es
 precision highp float;
 out vec4 fragColor;
@@ -30,68 +34,81 @@ void main() {
     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 };
+}`;
+
+
+
+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,2 +1,3 @@
-import Float2LegendWithRatio from './object';
-export { Float2LegendWithRatio };
+import Float2LegendWithRatio from './object';
+
+export { Float2LegendWithRatio };

package/programs/float2legendwithratio/logic.js

@@ -1,13 +1,19 @@
-import { createProgram } from "../../util";
-export default class {
-    constructor(gl) {
-        this.gl = gl;
-        this._width = 1;
-        this._height = 1;
-        this._blendRatio = 0.0;
-        this.programWrapper = this._createProgramWrapper();
-    }
-    _createProgramWrapper() {
+import { createProgram } from "../../util";
+
+export default class {
+
+
+    constructor(gl) {
+        this.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;
 
@@ -19,7 +25,8 @@ export default class {
             v_texcoord = a_position * 0.5 + 0.5;
             v_texcoord.y = 1.0 - v_texcoord.y;
         }
-        `;
+        `;
+
         const fragmentShaderSource = `#version 300 es
         precision highp float;
 
@@ -58,110 +65,129 @@ export default class {
             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);
-    }
-}
+        `;
+
+        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);
+    }
+
+}