@antv/l7-layers 2.25.7 → 2.25.10

package/lib/wind/models/windRender.js

@@ -0,0 +1,343 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Wind = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var glUtils = _interopRequireWildcard(require("./utils"));
+var _windShader = require("./windShader");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function getColorRamp(colors) {
+  let canvas = document.createElement('canvas');
+  const ctx = canvas.getContext('2d');
+  canvas.width = 256;
+  canvas.height = 1;
+  const gradient = ctx.createLinearGradient(0, 0, 256, 0);
+  for (const stop of Object.keys(colors)) {
+    gradient.addColorStop(+stop, colors[+stop]);
+  }
+  ctx.fillStyle = gradient;
+  ctx.fillRect(0, 0, 256, 1);
+
+  // @ts-ignore dispose canvas element
+  canvas = null;
+  return new Uint8Array(ctx.getImageData(0, 0, 256, 1).data);
+}
+function bindAttribute(gl, buffer, attribute, numComponents) {
+  gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+  gl.enableVertexAttribArray(attribute);
+  gl.vertexAttribPointer(attribute, numComponents, gl.FLOAT, false, 0, 0);
+}
+function bindFramebuffer(gl, framebuffer, texture) {
+  gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+  if (texture) {
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+  }
+}
+class Wind {
+  constructor(options) {
+    (0, _defineProperty2.default)(this, "width", 512);
+    (0, _defineProperty2.default)(this, "height", 512);
+    (0, _defineProperty2.default)(this, "pixels", void 0);
+    (0, _defineProperty2.default)(this, "fadeOpacity", void 0);
+    (0, _defineProperty2.default)(this, "speedFactor", void 0);
+    (0, _defineProperty2.default)(this, "dropRate", void 0);
+    (0, _defineProperty2.default)(this, "dropRateBump", void 0);
+    (0, _defineProperty2.default)(this, "gl", void 0);
+    (0, _defineProperty2.default)(this, "drawProgram", void 0);
+    (0, _defineProperty2.default)(this, "fullScreenProgram", void 0);
+    (0, _defineProperty2.default)(this, "updateProgram", void 0);
+    (0, _defineProperty2.default)(this, "rampColors", void 0);
+    (0, _defineProperty2.default)(this, "numParticles", 65536);
+    (0, _defineProperty2.default)(this, "numParticlesSize", void 0);
+    (0, _defineProperty2.default)(this, "particleStateResolution", void 0);
+    (0, _defineProperty2.default)(this, "quadBuffer", void 0);
+    (0, _defineProperty2.default)(this, "particleIndexBuffer", void 0);
+    (0, _defineProperty2.default)(this, "framebuffer", void 0);
+    (0, _defineProperty2.default)(this, "colorRampTexture", void 0);
+    (0, _defineProperty2.default)(this, "backgroundTexture", void 0);
+    (0, _defineProperty2.default)(this, "screenTexture", void 0);
+    (0, _defineProperty2.default)(this, "particleStateTexture0", void 0);
+    (0, _defineProperty2.default)(this, "particleStateTexture1", void 0);
+    (0, _defineProperty2.default)(this, "windTexture", void 0);
+    (0, _defineProperty2.default)(this, "windData", void 0);
+    this.gl = options.glContext;
+    this.width = options.imageWidth;
+    this.height = options.imageHeight;
+    this.fadeOpacity = options.fadeOpacity;
+    this.speedFactor = options.speedFactor;
+    this.dropRate = options.dropRate;
+    this.dropRateBump = options.dropRateBump;
+    this.rampColors = options.rampColors;
+    this.init();
+  }
+  init() {
+    const gl = this.gl;
+    this.fadeOpacity = 0.996; // how fast the particle trails fade on each frame
+    this.speedFactor = 0.25; // how fast the particles move
+    this.dropRate = 0.003; // how often the particles move to a random place
+    this.dropRateBump = 0.01; // drop rate increase relative to individual particle speed
+
+    this.drawProgram = glUtils.createProgram(gl, _windShader.drawVert, _windShader.drawFrag);
+    this.fullScreenProgram = glUtils.createProgram(gl, _windShader.fullScreenVert, _windShader.fullScreenFrag);
+    this.updateProgram = glUtils.createProgram(gl, _windShader.updateVert, _windShader.updateFrag);
+    this.quadBuffer = glUtils.createBuffer(gl, new Float32Array([0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1]));
+    this.framebuffer = gl.createFramebuffer();
+    this.colorRampTexture = glUtils.createTexture(this.gl, this.gl.LINEAR, getColorRamp(this.rampColors), 16, 16);
+    const emptyPixels = new Uint8Array(this.width * this.height * 4);
+
+    // screen textures to hold the drawn screen for the previous and the current frame
+
+    this.backgroundTexture = glUtils.createTexture(gl, gl.NEAREST, emptyPixels, this.width, this.height);
+    this.screenTexture = glUtils.createTexture(gl, gl.NEAREST, emptyPixels, this.width, this.height);
+
+    // we create a square texture where each pixel will hold a particle position encoded as RGBA
+    const particleRes = this.particleStateResolution = Math.ceil(Math.sqrt(this.numParticles));
+    // particleRes size
+    this.numParticlesSize = particleRes * particleRes;
+    const particleState = new Uint8Array(this.numParticlesSize * 4);
+    for (let i = 0; i < particleState.length; i++) {
+      particleState[i] = Math.floor(Math.random() * 256); // randomize the initial particle positions
+    }
+    // textures to hold the particle state for the current and the next frame
+    this.particleStateTexture0 = glUtils.createTexture(gl, gl.NEAREST, particleState, particleRes, particleRes);
+    this.particleStateTexture1 = glUtils.createTexture(gl, gl.NEAREST, particleState, particleRes, particleRes);
+    const particleIndices = new Float32Array(this.numParticlesSize);
+    for (let i$1 = 0; i$1 < this.numParticlesSize; i$1++) {
+      particleIndices[i$1] = i$1;
+    }
+    this.particleIndexBuffer = glUtils.createBuffer(gl, particleIndices);
+  }
+  setWind(windData) {
+    this.windData = windData;
+    this.windTexture = glUtils.createDataTexture(this.gl, this.gl.LINEAR, windData.image);
+  }
+
+  /**
+   * 更新风场粒子数量
+   * @param num
+   */
+  updateParticelNum(num) {
+    const gl = this.gl;
+    if (num !== this.numParticles) {
+      this.numParticles = num; // params number
+
+      // we create a square texture where each pixel will hold a particle position encoded as RGBA
+      const particleRes = this.particleStateResolution = Math.ceil(Math.sqrt(this.numParticles));
+      this.numParticlesSize = particleRes * particleRes;
+      const particleState = new Uint8Array(this.numParticlesSize * 4);
+      for (let i = 0; i < particleState.length; i++) {
+        particleState[i] = Math.floor(Math.random() * 256); // randomize the initial particle positions
+      }
+      // textures to hold the particle state for the current and the next frame
+      this.particleStateTexture0 = glUtils.createTexture(gl, gl.NEAREST, particleState, particleRes, particleRes);
+      this.particleStateTexture1 = glUtils.createTexture(gl, gl.NEAREST, particleState, particleRes, particleRes);
+      const particleIndices = new Float32Array(this.numParticlesSize);
+      for (let i$1 = 0; i$1 < this.numParticlesSize; i$1++) {
+        particleIndices[i$1] = i$1;
+      }
+      this.particleIndexBuffer = glUtils.createBuffer(gl, particleIndices);
+    }
+  }
+
+  /**
+   * 更新风场风向风速
+   * @param uMin
+   * @param uMax
+   * @param vMin
+   * @param vMax
+   */
+  updateWindDir(uMin, uMax, vMin, vMax) {
+    this.windData.uMin = uMin;
+    this.windData.uMax = uMax;
+    this.windData.vMin = vMin;
+    this.windData.vMax = vMax;
+  }
+
+  /**
+   * update rampColors
+   * @param rampColors
+   */
+  updateColorRampTexture(rampColors) {
+    if (this.isColorChanged(rampColors)) {
+      this.rampColors = rampColors;
+      const gl = this.gl;
+      gl.deleteTexture(this.colorRampTexture);
+      this.colorRampTexture = glUtils.createTexture(gl, gl.LINEAR, getColorRamp(rampColors), 16, 16);
+    }
+  }
+  isColorChanged(rampColors) {
+    const keys = Object.keys(rampColors);
+    for (const item of keys) {
+      const key = Number(item);
+      // exist new key -> color need update
+      if (!this.rampColors[key]) {
+        return true;
+      }
+      // value changed -> color need update
+      if (this.rampColors[key] && this.rampColors[key] !== rampColors[key]) {
+        return true;
+      }
+    }
+    return false;
+  }
+  reSize(width, height) {
+    if (width !== this.width || height !== this.height) {
+      const gl = this.gl;
+      gl.deleteTexture(this.backgroundTexture);
+      gl.deleteTexture(this.screenTexture);
+      this.width = width;
+      this.height = height;
+      const emptyPixels = new Uint8Array(width * height * 4);
+      // screen textures to hold the drawn screen for the previous and the current frame
+      this.backgroundTexture = glUtils.createTexture(gl, gl.NEAREST, emptyPixels, width, height);
+      this.screenTexture = glUtils.createTexture(gl, gl.NEAREST, emptyPixels, width, height);
+    }
+  }
+  draw() {
+    var _this$windData;
+    if ((_this$windData = this.windData) !== null && _this$windData !== void 0 && _this$windData.image) {
+      const gl = this.gl;
+      glUtils.bindTexture(gl, this.windTexture, 0);
+      glUtils.bindTexture(gl, this.particleStateTexture0, 1);
+      this.drawScreen(); // draw Particles into framebuffer
+      this.updateParticles();
+      return {
+        d: this.pixels,
+        w: this.width,
+        h: this.height
+      };
+    } else {
+      return {
+        d: new Uint8Array([0, 0, 0, 0]),
+        w: 1,
+        h: 1
+      };
+    }
+  }
+  drawScreen() {
+    const gl = this.gl;
+
+    // draw the screen into a temporary framebuffer to retain it as the background on the next frame
+    bindFramebuffer(gl, this.framebuffer, this.screenTexture);
+    gl.viewport(0, 0, this.width, this.height);
+    gl.disable(gl.BLEND);
+    this.drawFullTexture(this.backgroundTexture, this.fadeOpacity);
+    this.drawParticles();
+    this.pixels = new Uint8Array(4 * this.width * this.height);
+    gl.readPixels(0, 0, this.width, this.height, gl.RGBA, gl.UNSIGNED_BYTE, this.pixels);
+    bindFramebuffer(gl, null, null);
+    gl.viewport(0, 0, this.gl.canvas.width, this.gl.canvas.height);
+
+    //   save the current screen as the background for the next frame
+    const temp = this.backgroundTexture;
+    this.backgroundTexture = this.screenTexture;
+    this.screenTexture = temp;
+  }
+  drawFullTexture(texture, opacity) {
+    const gl = this.gl;
+    const program = this.fullScreenProgram;
+    gl.useProgram(program);
+
+    // bindAttribute(gl, this.quadBuffer, program.a_pos, 2);
+
+    gl.bindBuffer(gl.ARRAY_BUFFER, this.quadBuffer);
+    gl.vertexAttribPointer(program.a_pos, 2, gl.FLOAT, false, 0, 0);
+    gl.enableVertexAttribArray(program.a_pos);
+    gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    glUtils.bindTexture(gl, texture, 2);
+    gl.uniform1i(program.u_screen, 2);
+    gl.uniform1f(program.u_opacity, opacity);
+    gl.drawArrays(gl.TRIANGLES, 0, 6);
+    // gl.drawArrays(gl.POINTS, 0, 6);
+  }
+  drawParticles() {
+    const gl = this.gl;
+    const program = this.drawProgram;
+    gl.useProgram(program);
+    bindAttribute(gl, this.particleIndexBuffer, program.a_index, 1);
+    glUtils.bindTexture(gl, this.colorRampTexture, 2);
+    gl.uniform1i(program.u_wind, 0);
+    gl.uniform1i(program.u_particles, 1);
+    gl.uniform1i(program.u_color_ramp, 2);
+    gl.uniform1f(program.u_particles_res, this.particleStateResolution);
+    gl.uniform2f(program.u_wind_min, this.windData.uMin, this.windData.vMin);
+    gl.uniform2f(program.u_wind_max, this.windData.uMax, this.windData.vMax);
+    gl.drawArrays(gl.POINTS, 0, this.numParticlesSize);
+  }
+  updateParticles() {
+    const gl = this.gl;
+    bindFramebuffer(gl, this.framebuffer, this.particleStateTexture1);
+    gl.viewport(0, 0, this.particleStateResolution, this.particleStateResolution);
+    const program = this.updateProgram;
+    gl.useProgram(program);
+    bindAttribute(gl, this.quadBuffer, program.a_pos, 2);
+    gl.uniform1i(program.u_wind, 0);
+    gl.uniform1i(program.u_particles, 1);
+    gl.uniform1f(program.u_rand_seed, Math.random());
+    gl.uniform2f(program.u_wind_res, this.windData.image.width * 2, this.windData.image.height * 2);
+    gl.uniform2f(program.u_wind_min, this.windData.uMin, this.windData.vMin);
+    gl.uniform2f(program.u_wind_max, this.windData.uMax, this.windData.vMax);
+    gl.uniform1f(program.u_speed_factor, this.speedFactor);
+    gl.uniform1f(program.u_drop_rate, this.dropRate);
+    gl.uniform1f(program.u_drop_rate_bump, this.dropRateBump);
+    gl.drawArrays(gl.TRIANGLES, 0, 6);
+
+    // swap the particle state textures so the new one becomes the current one
+    const temp = this.particleStateTexture0;
+    this.particleStateTexture0 = this.particleStateTexture1;
+    this.particleStateTexture1 = temp;
+    bindFramebuffer(gl, null, null);
+
+    // gl.viewport(0, 0, this.gl.canvas.width, this.gl.canvas.height);
+  }
+  destroy() {
+    // private drawProgram: WebGLProgram;
+    // private fullScreenProgram: WebGLProgram;
+    // private updateProgram: WebGLProgram;
+
+    // private quadBuffer: WebGLBuffer | null;
+    // private particleIndexBuffer: WebGLBuffer | null;
+
+    // private framebuffer: WebGLFramebuffer | null;
+
+    // private colorRampTexture: WebGLTexture | null;
+    // private backgroundTexture: WebGLTexture | null;
+    // private screenTexture: WebGLTexture | null;
+    // private particleStateTexture0: WebGLTexture | null;
+    // private particleStateTexture1: WebGLTexture | null;
+    // private windTexture: WebGLTexture | null;
+
+    this.gl.deleteBuffer(this.quadBuffer);
+    this.gl.deleteBuffer(this.particleIndexBuffer);
+    this.gl.deleteFramebuffer(this.framebuffer);
+
+    // @ts-ignore
+    this.gl.deleteShader(this.drawProgram.vertexShader);
+    // @ts-ignore
+    this.gl.deleteShader(this.drawProgram.fragmentShader);
+    this.gl.deleteProgram(this.drawProgram);
+
+    // @ts-ignore
+    this.gl.deleteShader(this.fullScreenProgram.vertexShader);
+    // @ts-ignore
+    this.gl.deleteShader(this.fullScreenProgram.fragmentShader);
+    this.gl.deleteProgram(this.fullScreenProgram);
+
+    // @ts-ignore
+    this.gl.deleteShader(this.updateProgram.vertexShader);
+    // @ts-ignore
+    this.gl.deleteShader(this.updateProgram.fragmentShader);
+    this.gl.deleteProgram(this.updateProgram);
+    this.gl.deleteTexture(this.colorRampTexture);
+    this.gl.deleteTexture(this.backgroundTexture);
+    this.gl.deleteTexture(this.screenTexture);
+    this.gl.deleteTexture(this.particleStateTexture0);
+    this.gl.deleteTexture(this.particleStateTexture1);
+    this.gl.deleteTexture(this.windTexture);
+  }
+}
+exports.Wind = Wind;

package/lib/wind/models/windShader.d.ts

@@ -0,0 +1,12 @@
+/**
+ * drawProgram          drawVert drawFrag
+ * screenProgram        screenVert screenFrag
+ * updateProgram        updateVert updateFrag
+ * fullScreenProgram    fullScreenVert fullScreenFrag
+ */
+export declare const drawVert = "\n precision mediump float;\n\n attribute float a_index;\n\n uniform sampler2D u_particles;\n uniform float u_particles_res;\n\n varying vec2 v_particle_pos;\n\n void main() {\n     vec4 color = texture2D(u_particles, vec2(\n         fract(a_index / u_particles_res),\n         floor(a_index / u_particles_res) / u_particles_res)\n     );\n\n     // decode current particle position from the pixel's RGBA value\n     v_particle_pos = vec2( color.r / 255.0 + color.b, color.g / 255.0 + color.a);\n\n     gl_PointSize = 1.0;\n     gl_Position = vec4(2.0 * v_particle_pos.x - 1.0, 1.0 - 2.0 * v_particle_pos.y, 0, 1);\n }";
+export declare const drawFrag = "\n precision mediump float;\n\n uniform sampler2D u_wind;\n uniform vec2 u_wind_min;\n uniform vec2 u_wind_max;\n uniform sampler2D u_color_ramp;\n\n varying vec2 v_particle_pos;\n\n void main() {\n     vec2 velocity = mix(u_wind_min, u_wind_max, texture2D(u_wind, v_particle_pos).rg);\n     float speed_t = length(velocity) / length(u_wind_max);\n\n     // color ramp is encoded in a 16x16 texture\n     vec2 ramp_pos = vec2( fract(16.0 * speed_t), floor(16.0 * speed_t) / 16.0);\n\n     gl_FragColor = texture2D(u_color_ramp, ramp_pos);\n }";
+export declare const updateVert = "\n precision mediump float;\n\n attribute vec2 a_pos;\n\n varying vec2 v_tex_pos;\n\n void main() {\n     v_tex_pos = a_pos;\n     gl_Position = vec4(1.0 - 2.0 * a_pos, 0, 1);\n     // framebuffer \u59CB\u7EC8\u7528\u94FA\u6EE1\u5C4F\u5E55\u7684 texture\n }";
+export declare const updateFrag = "\n precision highp float;\n\n uniform sampler2D u_particles;\n uniform sampler2D u_wind;\n uniform vec2 u_wind_res;\n uniform vec2 u_wind_min;\n uniform vec2 u_wind_max;\n uniform float u_rand_seed;\n uniform float u_speed_factor;\n uniform float u_drop_rate;\n uniform float u_drop_rate_bump;\n\n varying vec2 v_tex_pos;\n\n // pseudo-random generator\n const vec3 rand_constants = vec3(12.9898, 78.233, 4375.85453);\n float rand(const vec2 co) {\n float t = dot(rand_constants.xy, co);\n     return fract(sin(t) * (rand_constants.z + t));\n }\n\n // wind speed lookup; use manual bilinear filtering based on 4 adjacent pixels for smooth interpolation\n vec2 lookup_wind(const vec2 uv) {\n     // return texture2D(u_wind, uv).rg; // lower-res hardware filtering\n     vec2 px = 1.0 / u_wind_res;\n     vec2 vc = (floor(uv * u_wind_res)) * px;\n     vec2 f = fract(uv * u_wind_res);\n     vec2 tl = texture2D(u_wind, vc).rg;\n     vec2 tr = texture2D(u_wind, vc + vec2(px.x, 0)).rg;\n     vec2 bl = texture2D(u_wind, vc + vec2(0, px.y)).rg;\n     vec2 br = texture2D(u_wind, vc + px).rg;\n     return mix(mix(tl, tr, f.x), mix(bl, br, f.x), f.y);\n }\n\n void main() {\n     vec4 color = texture2D(u_particles, v_tex_pos);\n     vec2 pos = vec2(\n         color.r / 255.0 + color.b,\n         color.g / 255.0 + color.a); // decode particle position from pixel RGBA\n     vec2 velocity = mix(u_wind_min, u_wind_max, lookup_wind(pos));\n     float speed_t = length(velocity) / length(u_wind_max);\n\n     // take EPSG:4236 distortion into account for calculating where the particle moved\n     float distortion = cos(radians(pos.y * 180.0 - 90.0));\n     vec2 offset = vec2(velocity.x / distortion, -velocity.y) * 0.0001 * u_speed_factor;\n\n     // update particle position, wrapping around the date line\n     pos = fract(1.0 + pos + offset);\n\n     // a random seed to use for the particle drop\n     vec2 seed = (pos + v_tex_pos) * u_rand_seed;\n\n     // drop rate is a chance a particle will restart at random position, to avoid degeneration\n     float drop_rate = u_drop_rate + speed_t * u_drop_rate_bump;\n     float drop = step(1.0 - drop_rate, rand(seed));\n\n     vec2 random_pos = vec2(\n         rand(seed + 1.3),\n         rand(seed + 2.1));\n         pos = mix(pos, random_pos, drop);\n\n     // encode the new particle position back into RGBA\n     gl_FragColor = vec4(\n         fract(pos * 255.0),\n         floor(pos * 255.0) / 255.0);\n }";
+export declare const fullScreenVert = "\n     precision mediump float;\n\n     attribute vec2 a_pos;\n\n     varying vec2 v_tex_pos;\n\n     void main() {\n         v_tex_pos = a_pos;\n         gl_Position = vec4(1.0 - 2.0 * a_pos, 0.0, 1.0);\n         gl_PointSize = 100.0;\n }";
+export declare const fullScreenFrag = "\n precision mediump float;\n\n uniform sampler2D u_screen;\n uniform float u_opacity;\n varying vec2 v_tex_pos;\n\n void main() {\n     vec4 color = texture2D(u_screen, 1.0 - v_tex_pos);\n\n     // a hack to guarantee opacity fade out even with a value close to 1.0\n     gl_FragColor = vec4(floor(255.0 * color * u_opacity) / 255.0);\n }";

package/lib/wind/models/windShader.js

@@ -0,0 +1,157 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateVert = exports.updateFrag = exports.fullScreenVert = exports.fullScreenFrag = exports.drawVert = exports.drawFrag = void 0;
+/**
+ * drawProgram          drawVert drawFrag
+ * screenProgram        screenVert screenFrag
+ * updateProgram        updateVert updateFrag
+ * fullScreenProgram    fullScreenVert fullScreenFrag
+ */
+const drawVert = exports.drawVert = `
+ precision mediump float;
+
+ attribute float a_index;
+
+ uniform sampler2D u_particles;
+ uniform float u_particles_res;
+
+ varying vec2 v_particle_pos;
+
+ void main() {
+     vec4 color = texture2D(u_particles, vec2(
+         fract(a_index / u_particles_res),
+         floor(a_index / u_particles_res) / u_particles_res)
+     );
+
+     // decode current particle position from the pixel's RGBA value
+     v_particle_pos = vec2( color.r / 255.0 + color.b, color.g / 255.0 + color.a);
+
+     gl_PointSize = 1.0;
+     gl_Position = vec4(2.0 * v_particle_pos.x - 1.0, 1.0 - 2.0 * v_particle_pos.y, 0, 1);
+ }`;
+const drawFrag = exports.drawFrag = `
+ precision mediump float;
+
+ uniform sampler2D u_wind;
+ uniform vec2 u_wind_min;
+ uniform vec2 u_wind_max;
+ uniform sampler2D u_color_ramp;
+
+ varying vec2 v_particle_pos;
+
+ void main() {
+     vec2 velocity = mix(u_wind_min, u_wind_max, texture2D(u_wind, v_particle_pos).rg);
+     float speed_t = length(velocity) / length(u_wind_max);
+
+     // color ramp is encoded in a 16x16 texture
+     vec2 ramp_pos = vec2( fract(16.0 * speed_t), floor(16.0 * speed_t) / 16.0);
+
+     gl_FragColor = texture2D(u_color_ramp, ramp_pos);
+ }`;
+const updateVert = exports.updateVert = `
+ precision mediump float;
+
+ attribute vec2 a_pos;
+
+ varying vec2 v_tex_pos;
+
+ void main() {
+     v_tex_pos = a_pos;
+     gl_Position = vec4(1.0 - 2.0 * a_pos, 0, 1);
+     // framebuffer 始终用铺满屏幕的 texture
+ }`;
+const updateFrag = exports.updateFrag = `
+ precision highp float;
+
+ uniform sampler2D u_particles;
+ uniform sampler2D u_wind;
+ uniform vec2 u_wind_res;
+ uniform vec2 u_wind_min;
+ uniform vec2 u_wind_max;
+ uniform float u_rand_seed;
+ uniform float u_speed_factor;
+ uniform float u_drop_rate;
+ uniform float u_drop_rate_bump;
+
+ varying vec2 v_tex_pos;
+
+ // pseudo-random generator
+ const vec3 rand_constants = vec3(12.9898, 78.233, 4375.85453);
+ float rand(const vec2 co) {
+ float t = dot(rand_constants.xy, co);
+     return fract(sin(t) * (rand_constants.z + t));
+ }
+
+ // wind speed lookup; use manual bilinear filtering based on 4 adjacent pixels for smooth interpolation
+ vec2 lookup_wind(const vec2 uv) {
+     // return texture2D(u_wind, uv).rg; // lower-res hardware filtering
+     vec2 px = 1.0 / u_wind_res;
+     vec2 vc = (floor(uv * u_wind_res)) * px;
+     vec2 f = fract(uv * u_wind_res);
+     vec2 tl = texture2D(u_wind, vc).rg;
+     vec2 tr = texture2D(u_wind, vc + vec2(px.x, 0)).rg;
+     vec2 bl = texture2D(u_wind, vc + vec2(0, px.y)).rg;
+     vec2 br = texture2D(u_wind, vc + px).rg;
+     return mix(mix(tl, tr, f.x), mix(bl, br, f.x), f.y);
+ }
+
+ void main() {
+     vec4 color = texture2D(u_particles, v_tex_pos);
+     vec2 pos = vec2(
+         color.r / 255.0 + color.b,
+         color.g / 255.0 + color.a); // decode particle position from pixel RGBA
+     vec2 velocity = mix(u_wind_min, u_wind_max, lookup_wind(pos));
+     float speed_t = length(velocity) / length(u_wind_max);
+
+     // take EPSG:4236 distortion into account for calculating where the particle moved
+     float distortion = cos(radians(pos.y * 180.0 - 90.0));
+     vec2 offset = vec2(velocity.x / distortion, -velocity.y) * 0.0001 * u_speed_factor;
+
+     // update particle position, wrapping around the date line
+     pos = fract(1.0 + pos + offset);
+
+     // a random seed to use for the particle drop
+     vec2 seed = (pos + v_tex_pos) * u_rand_seed;
+
+     // drop rate is a chance a particle will restart at random position, to avoid degeneration
+     float drop_rate = u_drop_rate + speed_t * u_drop_rate_bump;
+     float drop = step(1.0 - drop_rate, rand(seed));
+
+     vec2 random_pos = vec2(
+         rand(seed + 1.3),
+         rand(seed + 2.1));
+         pos = mix(pos, random_pos, drop);
+
+     // encode the new particle position back into RGBA
+     gl_FragColor = vec4(
+         fract(pos * 255.0),
+         floor(pos * 255.0) / 255.0);
+ }`;
+const fullScreenVert = exports.fullScreenVert = `
+     precision mediump float;
+
+     attribute vec2 a_pos;
+
+     varying vec2 v_tex_pos;
+
+     void main() {
+         v_tex_pos = a_pos;
+         gl_Position = vec4(1.0 - 2.0 * a_pos, 0.0, 1.0);
+         gl_PointSize = 100.0;
+ }`;
+const fullScreenFrag = exports.fullScreenFrag = `
+ precision mediump float;
+
+ uniform sampler2D u_screen;
+ uniform float u_opacity;
+ varying vec2 v_tex_pos;
+
+ void main() {
+     vec4 color = texture2D(u_screen, 1.0 - v_tex_pos);
+
+     // a hack to guarantee opacity fade out even with a value close to 1.0
+     gl_FragColor = vec4(floor(255.0 * color * u_opacity) / 255.0);
+ }`;

package/lib/wind/shaders/wind_frag.glsl

@@ -0,0 +1,9 @@
+precision mediump float;
+uniform float u_opacity: 1.0;
+uniform sampler2D u_texture;
+varying vec2 v_texCoord;
+void main() {
+  vec4 color = texture2D(u_texture,vec2(v_texCoord.x,v_texCoord.y));
+  gl_FragColor = color;
+  gl_FragColor.a *= u_opacity;
+}

package/lib/wind/shaders/wind_vert.glsl

@@ -0,0 +1,14 @@
+precision highp float;
+uniform mat4 u_ModelMatrix;
+
+layout(location = ATTRIBUTE_LOCATION_POSITION) in vec3 a_Position;
+layout(location = ATTRIBUTE_LOCATION_UV) in vec2 a_Uv;
+
+varying vec2 v_texCoord;
+#pragma include "projection"
+void main() {
+  v_texCoord = a_Uv;
+  vec4 project_pos = project_position(vec4(a_Position, 1.0));
+
+  gl_Position = project_common_position_to_clipspace(vec4(project_pos.xy, 0.0, 1.0));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antv/l7-layers",
-  "version": "2.25.7",
+  "version": "2.25.10",
   "description": "L7's collection of built-in layers",
   "license": "MIT",
   "author": "https://github.com/orgs/antvis/people",
@@ -26,15 +26,15 @@
     "earcut": "^2.2.1",
     "eventemitter3": "^4.0.0",
     "gl-matrix": "^3.1.0",
-    "@antv/l7-maps": "2.25.7",
-    "@antv/l7-core": "2.25.7",
-    "@antv/l7-utils": "2.25.7",
-    "@antv/l7-source": "2.25.7"
+    "@antv/l7-core": "2.25.10",
+    "@antv/l7-maps": "2.25.10",
+    "@antv/l7-utils": "2.25.10",
+    "@antv/l7-source": "2.25.10"
   },
   "devDependencies": {
     "@types/earcut": "^2.1.0",
     "@types/gl-matrix": "^2.4.5",
-    "@antv/l7-test-utils": "^2.25.7"
+    "@antv/l7-test-utils": "^2.25.10"
   },
   "publishConfig": {
     "access": "public",