@pirireis/webglobeplugins 0.10.2-alpha → 0.10.3-alpha

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pirireis/webglobeplugins",
-    "version": "0.10.2-alpha",
+    "version": "0.10.3-alpha",
     "main": "index.js",
     "author": "Toprak Nihat Deniz Ozturk",
     "license": "MIT",

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

@@ -88,9 +88,6 @@ void main() {
         outColor = vec4( v_color.rgb,  v_color.a * opacity );
     }
 }`;
-console.log("LineStripProgram");
-console.log(vertexShaderSource);
-console.log(fragmentShaderSource);
 class Logic {
     _vaosPublished = [];
     _ubosPublished = [];
@@ -104,7 +101,6 @@ class Logic {
         location: null
     };
     constructor(globe) {
-        console.log("LineStripProgram globe", globe);
         this.gl = globe.gl;
         this.globe = globe;
         this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);

package/programs/util.js

@@ -9,7 +9,6 @@ function longlatbbox2normalbbox({ minLon = -180, maxLon = 180, minLat = -90, max
         bboxOffsetRad: new Float32Array([horOffset, vertOffset]),
         bboxSizeRad: new Float32Array([horSize, vertSize])
     };
-    console.log("longlatbbox2normalbbox", result);
     return result;
 }
 export { longlatbbox2normalbbox };

package/programs/vectorfields/logics/constants.js

@@ -0,0 +1,4 @@
+const UBO_BINDING_POINTS = {
+    SEAWAVE: 0,
+};
+export { UBO_BINDING_POINTS };

package/programs/vectorfields/logics/drawrectangleparticles.js

@@ -1,32 +1,49 @@
 import { createProgram } from "../../../util";
 import { UBO_BINDING_POINT, shaderUboSource } from "./ubo.js";
 import { glProgramCache } from "../../programcache";
+import { SeaWaveUbo } from "./ubo-new";
 /**
  * [+] ubo
  */
 const vertexShaderSource = `#version 300 es
 precision highp float;
-` + shaderUboSource + `
+` + SeaWaveUbo.glslCode() + `
 uniform sampler2D u_vector_field;
 in vec2 in_position;
 out vec3 base_color;
+
+
+vec2 read_value(const vec2 uv) {
+    vec2 value = texture(u_vector_field, uv).rg;
+    if ( value.x == escape_value || value.y == escape_value) {
+        return vec2(0.0);
+    }
+    return value;
+}
+    
+
 vec2 lookup_wind(const vec2 uv) { // gerek kalmayabilir. sampler linear methodu ayni isi yapiyor 
     // return texture(u_vector_field, uv).rg; // lower-res hardware filtering
     vec2 res = vec2(textureSize(u_vector_field, 0));
     vec2 px = 1.0 / res;
     vec2 vc = (floor(uv * res)) * px;
     vec2 f = fract(uv * res);
-    vec2 tl = texture(u_vector_field, vc).rg;
-    vec2 tr = texture(u_vector_field, vc + vec2(px.x, 0)).rg;
-    vec2 bl = texture(u_vector_field, vc + vec2(0, px.y)).rg;
-    vec2 br = texture(u_vector_field, vc + px).rg;
+    vec2 tl = read_value(vc).rg;
+    vec2 tr = read_value(vc + vec2(px.x, 0)).rg;
+    vec2 bl = read_value(vc + vec2(0, px.y)).rg;
+    vec2 br = read_value(vc + px).rg;
+    if (tl.x == 0.0 && tl.y == 0.0){ return vec2(0.0);}
+    if (tr.x == 0.0 && tr.y == 0.0){ return vec2(0.0);}
+    if (bl.x == 0.0 && bl.y == 0.0){ return vec2(0.0);}
+    if (br.x == 0.0 && br.y == 0.0){ return vec2(0.0);}
     return mix(mix(tl, tr, f.x), mix(bl, br, f.x), f.y);
 }
 
 
 void main(){
     vec2 direction_vector = lookup_wind(in_position);
-    if (direction_vector.r == 0.0 && direction_vector.g == 0.0){ return;}
+    if (direction_vector.r == 0.0 && direction_vector.g == 0.0) return;
+    
 
     vec2 limp;
     if ( 0 == gl_VertexID) { limp = -tail_wing_base_limp; }
@@ -60,8 +77,9 @@ class Logic {
         const gl = this.gl;
         const program = createProgram(gl, vertexShaderSource, fragmentShaderSource);
         // ubo point
-        const ubo_location = gl.getUniformBlockIndex(program, 'UBO');
-        gl.uniformBlockBinding(program, ubo_location, UBO_BINDING_POINT);
+        // const ubo_location = gl.getUniformBlockIndex(program, 'UBO');
+        // gl.uniformBlockBinding(program, ubo_location, UBO_BINDING_POINT);
+        SeaWaveUbo.assignBindingPoint(gl, program, 0);
         return [program, gl.getUniformLocation(program, 'u_vector_field')];
     }
     /**

package/programs/vectorfields/logics/pixelbased.js

@@ -1,12 +1,13 @@
 import { createShader } from "../../../util";
 import { UBO_SIZE, UBO_BINDING_POINT, shaderUboSource } from "./ubo.js";
 import { glProgramCache } from "../../programcache";
+import { SeaWaveUbo } from "./ubo-new";
 // program output is buffer
 // TODO: Mechanism for randomness
 //  drop out mechanism
 //  random particle position mechanism
 const vertexShaderSource = `#version 300 es
-` + shaderUboSource + `
+` + SeaWaveUbo.glslCode() + `
 
 uniform sampler2D vector_field;
 in vec2 in_position;
@@ -24,10 +25,37 @@ float random(const vec2 co) {
     return fract(sin(t) * (rand_constants.z + t));
 }
 
+
+vec2 read_value(const vec2 uv) {
+    vec2 value = texture(vector_field, uv).rg;
+    if ( value.x == escape_value || value.y == escape_value) {
+        return vec2(0.0);
+    }
+    return value;
+}
+
 vec2 lookup_wind(const vec2 uv) { // gerek kalmayabilir. sampler linear methodu ayni isi yapiyor
     // return texture(vector_field, uv).rg; // lower-res hardware filtering
     vec2 res = vec2(textureSize(vector_field, 0));
-    if (res.x == 0.0 || res.y == 0.0){ return vec2(0.0);}
+    vec2 px = 1.0 / res;
+    vec2 vc = (floor(uv * res)) * px;
+    vec2 f = fract(uv * res);
+    vec2 tl = texture(vector_field, vc).rg;
+    vec2 tr = texture(vector_field, vc + vec2(px.x, 0)).rg;
+    vec2 bl = texture(vector_field, vc + vec2(0, px.y)).rg;
+    vec2 br = texture(vector_field, vc + px).rg;
+    if (tl.x == 0.0 && tl.y == 0.0){ return vec2(0.0);}
+    if (tr.x == 0.0 && tr.y == 0.0){ return vec2(0.0);}
+    if (bl.x == 0.0 && bl.y == 0.0){ return vec2(0.0);}
+    if (br.x == 0.0 && br.y == 0.0){ return vec2(0.0);}
+    return mix(mix(tl, tr, f.x), mix(bl, br, f.x), f.y);
+}
+
+
+vec2 lookup_wind2(const vec2 uv) { // gerek kalmayabilir. sampler linear methodu ayni isi yapiyor
+    // return texture(vector_field, uv).rg; // lower-res hardware filtering
+    vec2 res = vec2(textureSize(vector_field, 0));
+    if (res.x == escape_value || res.y == escape_value){ return vec2(0.0);}
     vec2 px = 1.0 / res;
     vec2 vc = (floor(uv * res)) * px;
     vec2 f = fract(uv * res);
@@ -107,8 +135,9 @@ class Logic {
         if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
             throw new Error(gl.getProgramParameter(program));
         }
-        const ubo_location = gl.getUniformBlockIndex(program, 'UBO');
-        gl.uniformBlockBinding(program, ubo_location, UBO_BINDING_POINT);
+        // const ubo_location = gl.getUniformBlockIndex(program, 'UBO');
+        // gl.uniformBlockBinding(program, ubo_location, UBO_BINDING_POINT);
+        SeaWaveUbo.assignBindingPoint(gl, program, 0);
         return [program, gl.getUniformLocation(program, 'vector_field')];
         ;
     }

package/programs/vectorfields/logics/ubo-new.js

@@ -0,0 +1,25 @@
+import { UBO_BINDING_POINTS } from "./constants";
+import { UniformBlockManager } from "../../../util/gl-util/uniform-block/manager";
+const INITIAL_UBO_DATA = /*@__PURE__*/ new Float32Array([93.17, 0.2, 1.0, 7.0, 1.0, 1.0, 1.0, 0.05, 2000, 2000, -9999]);
+//0.7297389507293701, 0.20000000298023224, 1, 7, 1, 1, 1, 0, 0.05000000074505806, 0, 2200, 656, -9999,
+// {float random_seed;float range;vec2 tail_wing_base_limp;vec3 color;float drop_rate;vec2 draw_texture_size;float escape_value; }
+export const SeaWaveUbo = /*@__PURE__*/ new UniformBlockManager("Seawave_UBO", [
+    { name: "tail_wing_base_limp", type: "vec2", value: INITIAL_UBO_DATA.slice(2, 4) },
+    { name: "draw_texture_size", type: "vec2", value: INITIAL_UBO_DATA.slice(8, 10) },
+    { name: "random_seed", type: "float", value: INITIAL_UBO_DATA.slice(0, 1) },
+    { name: "range", type: "float", value: INITIAL_UBO_DATA.slice(1, 2) },
+    { name: "escape_value", type: "float", value: INITIAL_UBO_DATA.slice(10, 11) },
+    { name: "drop_rate", type: "float", value: INITIAL_UBO_DATA.slice(7, 8) },
+    { name: "color", type: "vec3", value: INITIAL_UBO_DATA.slice(4, 7) },
+], UBO_BINDING_POINTS.SEAWAVE);
+window.SeaWaveUbo = SeaWaveUbo;
+// const shaderUboSource = `
+// layout(std140) uniform UBO {
+//     float random_seed;
+//     float range;
+//     vec2 tail_wing_base_limp;
+//     vec3 color;
+//     float drop_rate;
+//     vec2 draw_texture_size;
+//     float escape_value;
+// };`;

package/programs/vectorfields/logics/ubo.js

@@ -1,22 +1,23 @@
 const UBO_BINDING_POINT = 0;
-const INITIAL_UBO_DATA = new Float32Array([93.17, 0.2, 1.0, 7.0, 1.0, 1.0, 1.0, 0.05, 2000, 2000]);
+const INITIAL_UBO_DATA = new Float32Array([93.17, 0.2, 1.0, 7.0, 1.0, 1.0, 1.0, 0.05, 2000, 2000, -9999]);
 const shaderUboSource = `
 layout(std140) uniform UBO {
-    float random_seed;
+    float random_seed; 
     float range;
-    vec2 tail_wing_base_limp;
-    vec3 color;
-    float drop_rate;
-    vec2 draw_texture_size;
+    vec2 tail_wing_base_limp; 
+    vec3 color; 
+    float drop_rate; 
+    vec2 draw_texture_size; 
+    float escape_value; 
 };`;
-const UBO_SIZE = 40;
+const UBO_SIZE = 44;
 class WaveParticalUboManager {
     constructor(gl) {
         this.gl = gl;
         this.ubo = this._createBuffer();
         this._data = null;
     }
-    update({ range, random_seed, tail_wing_base_limp, draw_texture_size, drop_rate, color }) {
+    update({ range, random_seed, tail_wing_base_limp, draw_texture_size, drop_rate, color, escape_value }) {
         const { gl, ubo } = this;
         gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
         if (random_seed !== undefined)
@@ -31,6 +32,8 @@ class WaveParticalUboManager {
             gl.bufferSubData(gl.UNIFORM_BUFFER, 28, new Float32Array([drop_rate]));
         if (draw_texture_size !== undefined)
             gl.bufferSubData(gl.UNIFORM_BUFFER, 32, new Float32Array(draw_texture_size));
+        if (escape_value !== undefined)
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 40, new Float32Array([escape_value]));
         gl.bindBuffer(gl.UNIFORM_BUFFER, null);
     }
     _createBuffer() {

package/util/gl-util/uniform-block/manager.js

@@ -41,7 +41,7 @@ const typeArrayConstructors = {
     'ivec4': Int32Array,
     'bool': Float32Array
 };
-class UniformBlockManager {
+export class UniformBlockManager {
     /**
      *
      * @param {UniformBlockName} blockName
@@ -93,11 +93,39 @@ class UniformBlockManager {
         return {
             ubo,
             update: (nameValueMap) => this.updateUBO(gl, ubo, nameValueMap),
+            updateSingle: (key, value) => this.updateUboSingle(gl, ubo, key, value),
             bind: () => this.bind(gl, ubo),
             unbind: () => this.unbind(gl),
             free: () => gl.deleteBuffer(ubo),
         };
     }
+    updateUboSingle(gl, ubo, key, value) {
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        const offset = this.offsetMap.get(key);
+        if (offset === undefined) {
+            throw new Error(`Uniform block member ${key} not found in offset map.`);
+        }
+        // @ts-ignore
+        const type = this.blockMembers.find(member => member.name === key).type;
+        let data;
+        if (Array.isArray(value)) {
+            data = new typeArrayConstructors[type](value);
+        }
+        else if (typeof value === 'number') {
+            data = new typeArrayConstructors[type]([value]);
+        }
+        else if (value instanceof ArrayBuffer) {
+            data = new typeArrayConstructors[type](value);
+        }
+        else if (ArrayBuffer.isView(value) && !(value instanceof DataView)) {
+            data = (typeof value === 'number') ? new typeArrayConstructors[type]([value]) : new typeArrayConstructors[type](value);
+        }
+        else {
+            throw new Error(`Unsupported value type for ${key}: ${typeof value}`);
+        }
+        gl.bufferSubData(gl.UNIFORM_BUFFER, offset, data);
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    }
     updateUBO(gl, ubo, nameValueMap) {
         gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
         for (const [name, value] of nameValueMap.entries()) {
@@ -122,7 +150,6 @@ class UniformBlockManager {
             else {
                 throw new Error(`Unsupported value type for ${name}: ${typeof value}`);
             }
-            console.log("Data to be uploaded:", data);
             gl.bufferSubData(gl.UNIFORM_BUFFER, offset, data);
         }
         gl.bindBuffer(gl.UNIFORM_BUFFER, null);
@@ -162,4 +189,3 @@ class UniformBlockManager {
         return lastOffset + lastItemAlignment;
     }
 }
-export { UniformBlockManager };

package/util/heatwavedatamanager/pointcoordinatesdatacalculator1.js

@@ -98,7 +98,7 @@ export default class PointCoordinatesDataCalculator {
     }
 }
 // function test() {
-//     const cp = window.plugin.getPointCoordinatesDataCalculator();
+//     const cp = window.plugin.getTexturePointSampler();
 //     const bbox = [-15, 25, 70, 60];
 //     cp.registerPoint("left up", -15, 60, (data0, data1, interpolated) => {
 //         console.log("left up", data0, data1, interpolated);

package/waveparticles/adaptor.js

@@ -2,7 +2,7 @@ function centigradePlus90ToVectorArray(centigradeArray, noDataValue = -9999) {
     const vectorArray = new Float32Array(centigradeArray.length * 2);
     for (let i = 0; i < centigradeArray.length; i++) {
         if (centigradeArray[i] === noDataValue) {
-            vectorArray.set([0, 0], i * 2);
+            vectorArray.set([noDataValue, noDataValue], i * 2);
             continue;
         }
         const rad = (centigradeArray[i] + 90.0) * Math.PI / 180;
@@ -10,6 +10,7 @@ function centigradePlus90ToVectorArray(centigradeArray, noDataValue = -9999) {
         const y = Math.sin(rad);
         vectorArray.set([x, y], i * 2);
     }
+    console.log('centigradePlus90ToVectorArray', vectorArray);
     return vectorArray;
 }
 export { centigradePlus90ToVectorArray };

package/waveparticles/plugin.js

@@ -4,6 +4,7 @@ import { vectorfield } from "../programs/index";
 import { pixelBasedMoveProgramCache } from "../programs/vectorfields/logics/pixelbased";
 import { drawRectangleParticlesProgramCache } from "../programs/vectorfields/logics/drawrectangleparticles";
 import { FadeAway } from "../programs";
+import { SeaWaveUbo } from "../programs/vectorfields/logics/ubo-new";
 const { PingPongBufferManager, WaveParticalUboManager } = vectorfield;
 /**
  * STEPS:
@@ -15,7 +16,7 @@ const { PingPongBufferManager, WaveParticalUboManager } = vectorfield;
  */
 const MAX_PIXELS_ON_DIMENSION = 2200;
 export default class Plugin {
-    constructor(id, { dataWidth, dataHeight, fadeOpacity = 0.83, opacity = 0.75, minLon = -180, minLat = -90, maxLon = 180, maxLat = 90, patricleCount = 8000, flipY = true, drawTextureMaxPixelOnDimension = MAX_PIXELS_ON_DIMENSION } = {}) {
+    constructor(id, { dataWidth, dataHeight, fadeOpacity = 0.83, opacity = 0.75, minLon = -180, minLat = -90, maxLon = 180, maxLat = 90, escapeValue = -9999, patricleCount = 8000, flipY = true, drawTextureMaxPixelOnDimension = MAX_PIXELS_ON_DIMENSION } = {}) {
         this.id = id;
         this.globe = null;
         this.gl = null;
@@ -33,6 +34,7 @@ export default class Plugin {
         this._particleCount = patricleCount;
         this._dataWidth = dataWidth;
         this._dataHeight = dataHeight;
+        this._escapeValue = escapeValue;
         this._drawTextureMaxPixelOnDimension = drawTextureMaxPixelOnDimension;
         this._globeshellparameters = {
             minLon,
@@ -54,11 +56,12 @@ export default class Plugin {
         const inPositionLocation = this.moveParticle.getInPositionLocation();
         this.bufferManager = new PingPongBufferManager(gl, this._particleCount, inPositionLocation);
         this._rgVectorFieldTexture = this._createRGTexture();
-        this.waveUbo = new WaveParticalUboManager(gl, 0);
+        this.waveUbo = SeaWaveUbo.createUBO(gl);
         this._drawTextures = [this._createDrawTexture(), this._createDrawTexture()];
         this._frameBuffer = gl.createFramebuffer();
         this.setBBox(this._globeshellparameters);
         this.setOpacity(this._opacity);
+        this.setEscapeValue(this._escapeValue);
         this.____drawIndex = 0;
     }
     _createDrawTexture() {
@@ -74,6 +77,16 @@ export default class Plugin {
         gl.bindTexture(gl.TEXTURE_2D, null);
         return texture;
     }
+    displayUBO() {
+        const { gl } = this;
+        //read this.waveUbo.ubo content and pring
+        const float32array = new Float32Array(SeaWaveUbo.size / Float32Array.BYTES_PER_ELEMENT);
+        console.log("WaveUbo initial data size:", SeaWaveUbo.size / Float32Array.BYTES_PER_ELEMENT);
+        gl.bindBuffer(gl.UNIFORM_BUFFER, this.waveUbo.ubo);
+        gl.getBufferSubData(gl.UNIFORM_BUFFER, 0, float32array);
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+        console.log("WaveUbo initial data:", float32array);
+    }
     _step() {
         this._stepIndex = (this._stepIndex + 1) % this._fullCycleStepCount;
     }
@@ -83,7 +96,9 @@ export default class Plugin {
         const { gl, moveParticle, drawParticle, bufferManager, globeShellWiggle, waveUbo, fadeAway, _rgVectorFieldTexture } = this;
         gl.disable(gl.DEPTH_TEST);
         if (this._stepIndex === 0) {
-            waveUbo.update({ random_seed: Math.random() });
+            // waveUbo.update({ random_seed: Math.random() });
+            this.waveUbo.updateSingle("random_seed", new Float32Array([Math.random()]));
+            ;
             moveParticle.move(bufferManager, _rgVectorFieldTexture, waveUbo);
             // 1s swap buffer b1 <-> b2
             bufferManager.swap();
@@ -188,7 +203,16 @@ export default class Plugin {
         this.globeShellWiggle.setHeight(value);
     }
     setDropRate(value) {
-        this.waveUbo.update({ drop_rate: value });
+        this.waveUbo.updateSingle("drop_rate", new Float32Array([value]));
+        ;
+    }
+    setEscapeValue(value) {
+        if (typeof value !== 'number') {
+            console.error("escape value must be a number");
+            return;
+        }
+        this._escapeValue = value;
+        this.waveUbo.updateSingle("escape_value", value);
     }
     __readAndWriteTextureData() {
         const { gl, _rgVectorFieldTexture, _dataWidth, _dataHeight } = this;
@@ -231,24 +255,40 @@ export default class Plugin {
     setDrawTextureMaxPixelOnDimension(value) {
         this._drawTextureMaxPixelOnDimension = value;
         this._drawTextureResolution = this._drawTextureSizeFromBbox(this._globeshellparameters);
-        this.waveUbo.update({ draw_texture_size: [this._drawTextureResolution.width, this._drawTextureResolution.height] });
+        this.waveUbo.updateSingle("draw_texture_size", new Float32Array([this._drawTextureResolution.width, this._drawTextureResolution.height]));
         this._drawTextures = [this._createDrawTexture(), this._createDrawTexture()];
     }
     setParticleSpeed(value) {
-        this.waveUbo.update({ range: value });
+        if (typeof value !== 'number' || value <= 0) {
+            console.error("Particle speed must be a positive number");
+            return;
+        }
+        if (value > 100) {
+            console.warn("Particle speed is too high, it may cause performance issues");
+        }
+        this.waveUbo.updateSingle("range", new Float32Array([value]));
     }
     setFadeOpacity(value) {
+        if (typeof value !== 'number' || value < 0 || value > 1) {
+            console.error("Fade opacity must be a number between 0 and 1");
+            return;
+        }
         this._fadeOpacity = value;
     }
     setOpacity(value) {
+        if (typeof value !== 'number' || value < 0 || value > 1) {
+            console.error("Opacity must be a number between 0 and 1");
+            return;
+        }
         this.globeShellWiggle.setOpacity(value);
     }
     setParticleDimensions(tail, wing) {
         if (0 < tail || 0 < wing) {
-            this.waveUbo.update({ tail_wing_base_limp: [tail, wing] });
+            console.error("tail and wing must be greater than 0");
         }
         else {
-            console.error("tail and wing must be greater than 0");
+            this.waveUbo.updateSingle("tail_wing_base_limp", new Float32Array([tail, wing]));
+            ;
         }
     }
     setParticleColor(color) {
@@ -256,13 +296,14 @@ export default class Plugin {
             console.error("color must be an array of rgb elements");
             return;
         }
-        this.waveUbo.update({ color });
+        this.waveUbo.updateSingle("color", new Float32Array(color));
+        ;
     }
     setBBox({ minLon, minLat, maxLon, maxLat }) {
         this._globeshellparameters = { minLon, minLat, maxLon, maxLat };
         this.globeShellWiggle.setBBox({ minLon, minLat, maxLon, maxLat });
         this._drawTextureResolution = this._drawTextureSizeFromBbox({ minLon, minLat, maxLon, maxLat });
-        this.waveUbo.update({ draw_texture_size: [this._drawTextureResolution.width, this._drawTextureResolution.height] });
+        this.waveUbo.updateSingle("draw_texture_size", new Float32Array([this._drawTextureResolution.width, this._drawTextureResolution.height]));
         this._drawTextures = [this._createDrawTexture(), this._createDrawTexture()];
     }
 }

package/wind/plugin.js

@@ -531,22 +531,22 @@ export default class WindPlugin {
             this.setWind(windData);
         };
     }
-    getPointCoordinatesDataCalculator() {
-        if (!this.coordinatesDataCalculator)
-            this._createPointCoordinatesDataCalculator();
-        return this.coordinatesDataCalculator;
+    getTexturePointSampler() {
+        if (!this.texturePointSampler)
+            this._createTexturePointSampler();
+        return this.texturePointSampler;
     }
-    _createPointCoordinatesDataCalculator() {
+    _createTexturePointSampler() {
         const { bbox, width, height } = this._windDataMeta;
-        this.coordinatesDataCalculator = new TexturePointSampler(bbox, width, height);
+        this.texturePointSampler = new TexturePointSampler(bbox, width, height);
         this._setCoorcinatesDataCalculatorData();
     }
     _setCoorcinatesDataCalculatorData() {
-        if (!this.windData || !this.coordinatesDataCalculator) {
+        if (!this.windData || !this.texturePointSampler) {
             return;
         }
         const magnitude = imageToMagnitude(this.windData);
-        this.coordinatesDataCalculator.updateTextureData(0, magnitude, magnitude);
+        this.texturePointSampler.updateTextureData(0, magnitude, magnitude);
     }
     // -----------------------------------------------
     //             --- inner methods ---