@pirireis/webglobeplugins 0.17.1 → 1.0.3

package/programs/totems/dem-textures-manager.js

@@ -0,0 +1,265 @@
+import { mergeMeshes } from "../../Math/tessellation/tile-merger";
+import { globeBBoxToXYBBOX } from "../../Math/methods";
+import { noRegisterGlobeProgramCache } from "../programcache";
+import { CameraUniformBlockTotemCache } from "./camerauniformblock";
+export const DEM_TEXTURE_BLOCK_STRING = `
+layout(std140) uniform DemTextureUniformBlock {
+    vec4 u_demTextureBBOX[6]; // 96 bytes
+    vec4 u_textureDataCoverRatio[6]; // 96 bytes
+    vec2 u_textureResolution; // 8 bytes
+    int u_breakLoopIndex; // 4 bytes
+};  
+uniform sampler2DArray u_demTexture;
+`;
+const MAXLAYERS = 6;
+// Size calculation:
+// BBOX: 6 * 16 bytes = 96
+// CoverRatio: 6 * 16 bytes = 96
+// Resolution: 8 bytes (offset 192)
+// BreakLoopIndex: 4 bytes (offset 200)
+// Total used: 204 bytes.
+// std140 blocks are typically padded to 16 bytes alignment -> 208 bytes.
+// 208 bytes / 4 bytes per float = 52 floats.
+const uniformBlockData = new Float32Array(52);
+function drawnedTilesHash(drawnTiles) {
+    let hash = 0;
+    for (const tile of drawnTiles) {
+        // Combine tile coordinates into a unique value
+        const val = (tile.level << 20) | (tile.x << 10) | tile.y;
+        hash = ((hash << 5) - hash) + val;
+        hash = hash | 0; // Convert to 32-bit integer
+    }
+    return hash;
+}
+function resCalculation(sourceResolution, mergeCount) {
+    return sourceResolution + (mergeCount - 1) * (sourceResolution - 1);
+}
+export class DemTextureManager {
+    _globe;
+    _mergeParameters = {
+        mergeCount: 20,
+        tileDimensionLength: 5,
+        processLimit: 6
+    };
+    STOP = false;
+    mergedData = [];
+    uniformBuffer = null;
+    demTexture = null;
+    textureWidth;
+    textureHeight;
+    cameraBlockTotem = null;
+    tilesHash = 0;
+    registry = new Set();
+    constructor(globe, { mergeCount = 20, tileDimensionLength = 5, processLimit = 6 } = {}) {
+        this._globe = globe;
+        this._mergeParameters.mergeCount = mergeCount;
+        this._mergeParameters.tileDimensionLength = tileDimensionLength;
+        this._mergeParameters.processLimit = processLimit;
+        this.textureWidth = this.textureHeight = resCalculation(tileDimensionLength, mergeCount);
+        this.cameraBlockTotem = CameraUniformBlockTotemCache.get(this._globe);
+        this.cameraBlockTotem.registerAttachment(this);
+        // Initialize uniform data buffer
+        this.initializeUniformBlock();
+        this.initializeTextureArray();
+    }
+    initializeUniformBlock() {
+        const gl = this._globe.gl;
+        if (!gl)
+            return;
+        // Create uniform buffer
+        this.uniformBuffer = gl.createBuffer();
+        gl.bindBuffer(gl.UNIFORM_BUFFER, this.uniformBuffer);
+        // Allocate buffer with correct size (52 floats * 4 bytes)
+        gl.bufferData(gl.UNIFORM_BUFFER, uniformBlockData.byteLength, gl.STREAM_COPY);
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    }
+    initializeTextureArray() {
+        const gl = this._globe.gl;
+        if (!gl)
+            return;
+        // Create texture array
+        this.demTexture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D_ARRAY, this.demTexture);
+        // Calculate correct size: tileDimensionLength + (mergeCount - 1) * (tileDimensionLength - 1)
+        // For tileDimensionLength=5, mergeCount=8: 5 + 7*4 = RESOLUTION
+        // gl.texStorage3D(gl.TEXTURE_2D_ARRAY, 1, gl.R32F, this.textureWidth, this.textureHeight, 6);
+        // // Allocate storage for texture array
+        gl.texImage3D(gl.TEXTURE_2D_ARRAY, 0, // mip level
+        gl.R32F, // internal format (32-bit float for DEM data)
+        this.textureWidth, this.textureHeight, MAXLAYERS, // number of layers
+        0, // border
+        gl.RED, // format
+        gl.FLOAT, // type
+        null // data (null to allocate)
+        );
+        const ext = gl.getExtension('OES_texture_float_linear');
+        if (!ext) {
+            throw new Error("OES_texture_float_linear extension is supported.");
+        }
+        // Set texture parameters
+        gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        gl.bindTexture(gl.TEXTURE_2D_ARRAY, null);
+    }
+    assignBindingPoint(program, bindingPoint) {
+        const gl = this._globe.gl;
+        if (!gl || !this.uniformBuffer || !program) {
+            console.warn('Cannot bind uniform block: missing GL context, buffer, or program');
+            return false;
+        }
+        const uniformBlockIndex = gl.getUniformBlockIndex(program, 'DemTextureUniformBlock');
+        if (uniformBlockIndex === gl.INVALID_INDEX) {
+            // Uniform block might be optimized out - this is not necessarily an error
+            console.warn(`Uniform block 'DemTextureUniformBlock' not found in program (may be optimized out)`);
+            return false;
+        }
+        gl.uniformBlockBinding(program, uniformBlockIndex, bindingPoint);
+        return true;
+    }
+    register(obj) {
+        this.registry.add(obj);
+        obj.setMergedTiles(this.mergedData);
+    }
+    unregister(obj) {
+        this.registry.delete(obj);
+    }
+    update() {
+        if (this.STOP)
+            return;
+        const gl = this._globe.gl;
+        const tilesMetaData = this._globe.api_GetVisibleTilesInfo();
+        const newHash = drawnedTilesHash(tilesMetaData);
+        if (this.tilesHash === newHash) {
+            return; // No change in drawn tiles, skip update
+        }
+        this.tilesHash = newHash;
+        this.mergedData = mergeMeshes(tilesMetaData, this._mergeParameters.mergeCount, this._mergeParameters.tileDimensionLength, this._mergeParameters.processLimit, this._globe);
+        // Bind texture before updating
+        gl.bindTexture(gl.TEXTURE_2D_ARRAY, this.demTexture);
+        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+        // turn off premultiply alpha
+        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
+        for (let i = 0; i < this.mergedData.length; i++) {
+            const { mesh, bbox, coverRatio } = this.mergedData[i];
+            gl.texSubImage3D(gl.TEXTURE_2D_ARRAY, 0, // mip level
+            0, // xoffset
+            0, // yoffset
+            i, // zoffset (layer index)
+            this.textureWidth, this.textureHeight, 1, // depth (1 layer)
+            gl.RED, gl.FLOAT, mesh);
+            const bboxXY = globeBBoxToXYBBOX(bbox);
+            uniformBlockData[i * 4 + 0] = bboxXY.ll[0];
+            uniformBlockData[i * 4 + 1] = bboxXY.ll[1];
+            uniformBlockData[i * 4 + 2] = bboxXY.ur[0];
+            uniformBlockData[i * 4 + 3] = bboxXY.ur[1];
+            uniformBlockData[24 + i * 4 + 0] = coverRatio.x;
+            uniformBlockData[24 + i * 4 + 1] = coverRatio.y;
+        }
+        // Set resolution (offset 192 bytes -> index 48)
+        uniformBlockData[48] = this.textureWidth;
+        uniformBlockData[49] = this.textureHeight;
+        // Set break loop index (offset 200 bytes -> index 50)
+        uniformBlockData[50] = this.mergedData.length;
+        // Unbind texture after updating
+        gl.bindTexture(gl.TEXTURE_2D_ARRAY, null);
+        gl.bindBuffer(gl.UNIFORM_BUFFER, this.uniformBuffer);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 0, uniformBlockData);
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+        for (const obj of this.registry) {
+            obj.setMergedTiles(this.mergedData);
+        }
+    }
+    bindData(textureUnit, bindingPoint) {
+        const gl = this._globe.gl;
+        if (!gl)
+            return;
+        // Bind uniform buffer
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, this.uniformBuffer);
+        // Bind texture array
+        gl.activeTexture(gl.TEXTURE0 + textureUnit);
+        gl.bindTexture(gl.TEXTURE_2D_ARRAY, this.demTexture);
+    }
+    find(x, y, zoom) {
+        for (const data of this._globe.api_GetVisibleTilesInfo()) {
+            if (data.x === x && data.y === y && data.level === zoom) {
+                return data;
+            }
+        }
+        return null;
+    }
+    showMergedDataInfo(zoomLevel) {
+        if (!this.mergedData[zoomLevel]) {
+            console.log(`No merged data at zoom level ${zoomLevel}`);
+            return;
+        }
+        const { textureHeight, textureWidth } = this;
+        const { mesh, bbox, coverRatio } = this.mergedData[zoomLevel];
+        const result = [];
+        const xLength = Math.ceil(mesh.length / textureHeight * coverRatio.x);
+        const yLength = Math.ceil(mesh.length / textureWidth * coverRatio.y);
+        for (let y = 0; y < yLength; y++) {
+            const row = [];
+            for (let x = 0; x < xLength; x++) {
+                const index = y * textureWidth + x;
+                const value = mesh[index];
+                row.push(value);
+            }
+            result.push(new Float32Array(row));
+        }
+        return { mesh: result, bbox: bbox, coverRatio: coverRatio };
+    }
+    unbindData(textureUnit, bindingPoint) {
+        const gl = this._globe.gl;
+        if (!gl)
+            return;
+        // Unbind texture array
+        gl.activeTexture(gl.TEXTURE0 + textureUnit);
+        // Unbind
+        gl.bindTexture(gl.TEXTURE_2D_ARRAY, null);
+        // call this right after drawing
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPoint, null);
+    }
+    get() {
+        return this.mergedData;
+    }
+    getBBoxes() {
+        const ressult = new Array(this.mergedData.length);
+        for (let i = 0; i < this.mergedData.length; i++) {
+            const { bbox, zoom } = this.mergedData[i];
+            ressult[i] = {
+                minX: bbox.ll.x,
+                minY: bbox.ll.y,
+                maxX: bbox.ur.x,
+                maxY: bbox.ur.y,
+                zoom
+            };
+        }
+        return ressult;
+    }
+    free() {
+        const gl = this._globe.gl;
+        this.cameraBlockTotem.unregisterAttachment(this);
+        if (gl) {
+            if (this.uniformBuffer) {
+                gl.deleteBuffer(this.uniformBuffer);
+                this.uniformBuffer = null;
+            }
+            if (this.demTexture) {
+                gl.deleteTexture(this.demTexture);
+                this.demTexture = null;
+            }
+        }
+    }
+}
+export const DemTextureManagerCache = Object.freeze({
+    get: (globe) => {
+        const result = noRegisterGlobeProgramCache.getProgram(globe, DemTextureManager);
+        window.demManager = result;
+        return result;
+    },
+    release: (globe) => {
+        noRegisterGlobeProgramCache.releaseProgram(globe, DemTextureManager);
+    }
+});

package/programs/vectorfields/logics/drawrectangleparticles.js

@@ -1,15 +1,17 @@
 import { createProgram } from "../../../util/webglobjectbuilders";
 import { glProgramCache } from "../../programcache";
-import { SeaWaveUbo } from "./ubo-new";
+import { ParticleUBO } from "./particle-ubo";
 /**
  * [+] ubo
  */
 const vertexShaderSource = `#version 300 es
 precision highp float;
-` + SeaWaveUbo.glslCode() + `
+` + ParticleUBO.glslCode() + `
 uniform sampler2D u_vector_field;
+uniform sampler2D u_color_field;
+uniform sampler2D u_speed_field;
 in vec2 in_position;
-out vec3 base_color;
+out vec4 base_color;
 
 
 vec2 read_value(const vec2 uv) {
@@ -37,7 +39,17 @@ vec2 lookup_wind(const vec2 uv) { // gerek kalmayabilir. sampler linear methodu
 
 
 void main(){
-    vec2 direction_vector = lookup_wind(in_position);
+    if ( use_speed_field != 0.0 ) {
+        base_color = vec4(0.0);
+        return;
+        float speed = texture(u_speed_field, in_position).r;
+        if ( speed < min_speed_threshold || speed > max_speed_threshold ) {
+            base_color = vec4(0.0);
+            return;
+        }
+    }
+
+    vec2 direction_vector = lookup_wind(in_position);    
     if (direction_vector.r == 0.0 && direction_vector.g == 0.0) return;
     
 
@@ -45,31 +57,37 @@ void main(){
     if ( 0 == gl_VertexID) { limp = -tail_wing_base_limp; }
     else if ( 1 == gl_VertexID) { limp = vec2( tail_wing_base_limp.x, -tail_wing_base_limp.y); }
     else if ( 2 == gl_VertexID) { limp = tail_wing_base_limp; }
-    else  { limp = vec2(-tail_wing_base_limp.x,  tail_wing_base_limp.y); } // if ( 3 == gl_VertexID)
-
+    else  { limp = vec2(-tail_wing_base_limp.x,  tail_wing_base_limp.y); } 
     limp = (limp  * mat2( 
         direction_vector.x, -direction_vector.y,
         direction_vector.y, direction_vector.x)) / draw_texture_size;
 
     vec2 pos = in_position * 2.0 - 1.0;
     gl_Position = vec4(pos + limp, 0.0, 1.0);
-    base_color = color;
+    
+    base_color = use_color_field != 0.0 ? texture(u_color_field, in_position).rgba : vec4(color, 1.0);
 }`;
 const fragmentShaderSource = `#version 300 es
 precision highp float;
 out vec4 outColor;
-in vec3 base_color;
+in vec4 base_color;
 void main(){
-    outColor = vec4(base_color, 1.0);
+    outColor = base_color;
 }`;
-class Logic {
+export class DrawRectangleParticleProgram {
     gl;
     program;
     _vector_field_location;
+    _color_texture_location;
+    _speed_field_location;
     constructor(gl) {
         this.gl = gl;
-        [this.program, this._vector_field_location] = this._createProgram();
         // this.decoyBuffer = new DecoyBufferManager(gl);
+        const { program, _vector_field_location, _color_texture_location, _speed_field_location } = this._createProgram();
+        this.program = program;
+        this._vector_field_location = _vector_field_location;
+        this._color_texture_location = _color_texture_location;
+        this._speed_field_location = _speed_field_location;
     }
     _createProgram() {
         const gl = this.gl;
@@ -77,23 +95,38 @@ class Logic {
         // ubo point
         // const ubo_location = gl.getUniformBlockIndex(program, 'UBO');
         // gl.uniformBlockBinding(program, ubo_location, UBO_BINDING_POINT);
-        SeaWaveUbo.assignBindingPoint(gl, program);
-        return [program, gl.getUniformLocation(program, 'u_vector_field')];
+        ParticleUBO.assignBindingPoint(gl, program);
+        return {
+            program,
+            _vector_field_location: gl.getUniformLocation(program, 'u_vector_field'),
+            _color_texture_location: gl.getUniformLocation(program, 'u_color_field'),
+            _speed_field_location: gl.getUniformLocation(program, 'u_speed_field')
+        };
     }
     /**
      * @param bufferManager | PingPongBufferManager
-     * @param vectorTexture | RG32F texture R: x, G: y
+     * @param vectorFieldTexture | RG32F texture R: x, G: y
      * @param uboManager | WaveParticalUboManager under ubo.js
      */
-    draw(bufferManager, vectorTexture, uboManager) {
+    draw(bufferManager, vectorFieldTexture, uboManager, colorFieldTexture, speedFieldTexture) {
         const { gl, program } = this;
         gl.useProgram(program);
         gl.bindVertexArray(bufferManager.getSourceVao());
         // gl.bindVertexArray(this.decoyBuffer.getSourceVao());
         uboManager.bind();
+        if (colorFieldTexture) {
+            gl.activeTexture(gl.TEXTURE1);
+            gl.uniform1i(this._color_texture_location, 1);
+            gl.bindTexture(gl.TEXTURE_2D, colorFieldTexture);
+        }
+        if (speedFieldTexture) {
+            gl.activeTexture(gl.TEXTURE2);
+            gl.uniform1i(this._speed_field_location, 2);
+            gl.bindTexture(gl.TEXTURE_2D, speedFieldTexture);
+        }
         gl.activeTexture(gl.TEXTURE0);
         gl.uniform1i(this._vector_field_location, 0);
-        gl.bindTexture(gl.TEXTURE_2D, vectorTexture);
+        gl.bindTexture(gl.TEXTURE_2D, vectorFieldTexture);
         gl.drawArraysInstanced(gl.TRIANGLE_FAN, 0, 4, bufferManager.length);
         gl.drawArraysInstanced(gl.POINTS, 0, 4, bufferManager.length);
         gl.bindVertexArray(null);
@@ -106,9 +139,9 @@ class Logic {
 }
 export const drawRectangleParticlesProgramCache = Object.freeze({
     getProgram: (gl) => {
-        return glProgramCache.getProgram(gl, Logic);
+        return glProgramCache.getProgram(gl, DrawRectangleParticleProgram);
     },
     releaseProgram: (gl) => {
-        glProgramCache.releaseProgram(gl, Logic);
+        glProgramCache.releaseProgram(gl, DrawRectangleParticleProgram);
     }
 });

package/programs/vectorfields/logics/{ubo-new.js → particle-ubo.js}

@@ -1,9 +1,7 @@
 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, 0]);
-//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", [
+export const ParticleUBO = /*@__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) },
@@ -11,15 +9,8 @@ export const SeaWaveUbo = /*@__PURE__*/ new UniformBlockManager("Seawave_UBO", [
     { 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) },
+    { name: "use_color_field", type: "float", value: new Float32Array([0]) },
+    { name: "use_speed_field", type: "float", value: new Float32Array([0]) },
+    { name: "min_speed_threshold", type: "float", value: new Float32Array([0]) },
+    { name: "max_speed_threshold", type: "float", value: new Float32Array([10000]) },
 ], UBO_BINDING_POINTS.SEAWAVE);
-// window add properties
-// 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/pixelbased.js

@@ -1,22 +1,14 @@
 import { createShader } from "../../../util/webglobjectbuilders";
 import { glProgramCache } from "../../programcache";
-import { SeaWaveUbo } from "./ubo-new";
-// program output is buffer
-// TODO: Mechanism for randomness
-//  drop out mechanism
-//  random particle position mechanism
+import { ParticleUBO } from "./particle-ubo";
 const vertexShaderSource = `#version 300 es
-` + SeaWaveUbo.glslCode() + `
+` + ParticleUBO.glslCode() + `
 
 uniform sampler2D vector_field;
+uniform sampler2D speed_field;
 in vec2 in_position;
 out vec2 out_position;
 
-// float random(vec2 st){
-//     float t = dot(st, vec2(12.9898,78.233));
-//     return fract(sin(t) * (t+43758.5453123));
-// }
-
 
 const vec3 rand_constants = vec3(12.9898, 78.233, 4375.85453);
 float random(const vec2 co) {
@@ -47,15 +39,10 @@ vec2 lookup_wind(const vec2 uv) {
     return mix(mix(tl, tr, f.x), mix(bl, br, f.x), f.y);
 }
 
-
-
-
-
 vec2 random_position(vec2 st){
     return vec2(random(st), random(st + 1.0));
 }
 
-
 void main(){
     vec2 vec = lookup_wind(in_position).xy;
     if (vec.x == 0.0 && vec.y == 0.0){
@@ -67,31 +54,43 @@ void main(){
         out_position = random_position(in_position);
         return;
     }
-    out_position = in_position + (vec / draw_texture_size)  * range;
+    float speed_multiplier = use_speed_field != 0.0 ? texture(speed_field, in_position).r : 1.0;
+    out_position = in_position + (vec / draw_texture_size)  * range * speed_multiplier * tail_wing_base_limp.y;
 }
 `;
 const fragmentShaderSource = `#version 300 es
 precision highp float;
 void main(){
 }`;
-class Logic {
+export class MoveParticalProgram {
+    gl;
+    program;
+    _vector_field_location;
+    _speed_field_location;
     constructor(gl) {
         this.gl = gl;
-        [this.program, this._vector_field_location] = this._createProgram();
+        [this.program, this._vector_field_location, this._speed_field_location] = this._createProgram();
     }
     /**
-     * @param {*} bufferManager | PingPongBufferManager
-     * @param {*} vectorTexture RG32F texture R: x, G: y
-     * @param {*} uboManager | WaveParticalUboManager under ubo.js
+     * @param bufferManager - PingPongBufferManager
+     * @param vectorTexture - RG32F texture R: x, G: y
+     * @param uboManager - WaveParticalUboManager under ubo.js
      */
-    move(bufferManager, vectorTexture, uboManager) {
+    move(bufferManager, vectorTexture, uboManager, speedTexture) {
         const { gl, program, _vector_field_location } = this;
+        if (!program)
+            return;
         gl.useProgram(program);
         gl.enable(gl.RASTERIZER_DISCARD);
         gl.bindVertexArray(bufferManager.getSourceVao());
         gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, bufferManager.getTargetTF());
         gl.beginTransformFeedback(gl.POINTS);
         uboManager.bind();
+        if (speedTexture) {
+            gl.activeTexture(gl.TEXTURE1);
+            gl.bindTexture(gl.TEXTURE_2D, speedTexture);
+            gl.uniform1i(this._speed_field_location, 1);
+        }
         gl.activeTexture(gl.TEXTURE0);
         gl.bindTexture(gl.TEXTURE_2D, vectorTexture);
         gl.uniform1i(_vector_field_location, 0);
@@ -102,6 +101,17 @@ class Logic {
         uboManager.unbind();
         gl.disable(gl.RASTERIZER_DISCARD);
     }
+    free() {
+        if (this.program) {
+            this.gl.deleteProgram(this.program);
+            this.program = null;
+        }
+    }
+    getInPositionLocation() {
+        if (!this.program)
+            return -1;
+        return this.gl.getAttribLocation(this.program, 'in_position');
+    }
     // -- private methods
     _createProgram() {
         const gl = this.gl;
@@ -113,27 +123,23 @@ class Logic {
         gl.transformFeedbackVaryings(program, ["out_position"], gl.SEPARATE_ATTRIBS);
         gl.linkProgram(program);
         if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-            throw new Error(gl.getProgramParameter(program));
+            throw new Error(gl.getProgramInfoLog(program) || 'Program link failed');
         }
         // 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')];
-        ;
-    }
-    free() {
-        this.gl.deleteProgram(this.program);
-        this.program = null;
-    }
-    getInPositionLocation() {
-        return this.gl.getAttribLocation(this.program, 'in_position');
+        ParticleUBO.assignBindingPoint(gl, program);
+        return [
+            program,
+            gl.getUniformLocation(program, 'vector_field'),
+            gl.getUniformLocation(program, 'speed_field'),
+        ];
     }
 }
 export const pixelBasedMoveProgramCache = Object.freeze({
     getProgram: (gl) => {
-        return glProgramCache.getProgram(gl, Logic);
+        return glProgramCache.getProgram(gl, MoveParticalProgram);
     },
     releaseProgram: (gl) => {
-        glProgramCache.releaseProgram(gl, Logic);
+        glProgramCache.releaseProgram(gl, MoveParticalProgram);
     }
 });

package/programs/vectorfields/pingpongbuffermanager.js

@@ -6,12 +6,20 @@
  * update coords and draw particles programs will use this class.
  */
 export class PingPongBufferManager {
+    gl;
+    length;
+    _inPositionLocation;
+    _buffers;
+    _tfs;
+    _vaos;
+    _index;
     constructor(gl, particleCount, inPositionLocation = 0) {
         this.gl = gl;
         this._inPositionLocation = inPositionLocation;
         this._buffers = [gl.createBuffer(), gl.createBuffer()];
         this._tfs = this._createTransformFeedbacksAndBindBuffers();
         this._vaos = this._createVaos();
+        this.length = 0;
         this.setParticleCount(particleCount);
         this._index = 0;
     }
@@ -27,7 +35,10 @@ export class PingPongBufferManager {
     }
     _createTransformFeedbacksAndBindBuffers() {
         const gl = this.gl;
-        const tfs = [gl.createTransformFeedback(), gl.createTransformFeedback()];
+        const tfs = [
+            gl.createTransformFeedback(),
+            gl.createTransformFeedback()
+        ];
         tfs.forEach((tf, idx) => {
             gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, tf);
             gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, this._buffers[idx]);
@@ -37,7 +48,10 @@ export class PingPongBufferManager {
     }
     _createVaos() {
         const gl = this.gl;
-        const vaos = [gl.createVertexArray(), gl.createVertexArray()];
+        const vaos = [
+            gl.createVertexArray(),
+            gl.createVertexArray()
+        ];
         vaos.forEach((vao, idx) => {
             gl.bindVertexArray(vao);
             gl.bindBuffer(gl.ARRAY_BUFFER, this._buffers[idx]);
@@ -48,12 +62,24 @@ export class PingPongBufferManager {
         });
         return vaos;
     }
-    getSourceVao() { return this._vaos[this._index]; }
-    getTargetVao() { return this._vaos[1 - this._index]; }
-    sourceBuffer() { return this._buffers[this._index]; }
-    targetBuffer() { return this._buffers[1 - this._index]; }
-    getTargetTF() { return this._tfs[1 - this._index]; }
-    swap() { this._index = 1 - this._index; }
+    getSourceVao() {
+        return this._vaos[this._index];
+    }
+    getTargetVao() {
+        return this._vaos[1 - this._index];
+    }
+    sourceBuffer() {
+        return this._buffers[this._index];
+    }
+    targetBuffer() {
+        return this._buffers[1 - this._index];
+    }
+    getTargetTF() {
+        return this._tfs[1 - this._index];
+    }
+    swap() {
+        this._index = 1 - this._index;
+    }
     free() {
         this.gl.deleteBuffer(this._buffers[0]);
         this.gl.deleteBuffer(this._buffers[1]);