ol 10.1.1-dev.1724296077041 → 10.1.1-dev.1724415449548

package/renderer/webgl/FlowLayer.js

@@ -0,0 +1,496 @@
+/**
+ * @module ol/renderer/webgl/FlowLayer
+ */
+import WebGLArrayBuffer from '../../webgl/Buffer.js';
+import WebGLTileLayerRenderer from './TileLayer.js';
+import {ARRAY_BUFFER, STATIC_DRAW} from '../../webgl.js';
+import {DefaultUniform} from '../../webgl/Helper.js';
+
+/**
+ * @typedef {import("../../layer/Flow.js").default} LayerType
+ */
+
+/**
+ * @typedef {Object} Options
+ * @property {number} maxSpeed The maximum particle speed in the input data.
+ * @property {number} [speedFactor=0.001] A larger factor increases the rate at which particles cross the screen.
+ * @property {number} [particles=65536] The number of particles to render.
+ * @property {number} [cacheSize=512] The texture cache size.
+ * @property {string} tileVertexShader The flow tile vertex shader.
+ * @property {string} tileFragmentShader The flow tile fragment shader.
+ * @property {string} textureVertexShader Generic texture fragment shader.
+ * @property {string} textureFragmentShader Generic texture fragment shader.
+ * @property {string} particlePositionVertexShader The particle position vertex shader.
+ * @property {string} particlePositionFragmentShader The particle position fragment shader.
+ * @property {string} particleColorVertexShader The particle color vertex shader.
+ * @property {string} particleColorFragmentShader The particle color fragment shader.
+ */
+
+/**
+ * Shader uniforms.
+ * @enum {string}
+ */
+export const U = {
+  TEXTURE: 'u_texture',
+  VELOCITY_TEXTURE: 'u_velocityTexture',
+  POSITION_TEXTURE: 'u_positionTexture',
+  PARTICLE_COUNT_SQRT: 'u_particleCountSqrt',
+  MAX_SPEED: 'u_maxSpeed',
+  GAIN: 'u_gain',
+  OFFSET: 'u_offset',
+  IS_FLOAT: 'u_isFloat',
+  RANDOM_SEED: 'u_randomSeed',
+  SPEED_FACTOR: 'u_speedFactor',
+  DROP_RATE: 'u_dropRate',
+  DROP_RATE_BUMP: 'u_dropRateBump',
+  OPACITY: 'u_opacity',
+  ROTATION: DefaultUniform.ROTATION,
+  VIEWPORT_SIZE_PX: DefaultUniform.VIEWPORT_SIZE_PX,
+};
+
+/**
+ * Shader attributes.
+ * @enum {string}
+ */
+export const A = {
+  POSITION: 'a_position',
+  INDEX: 'a_index',
+};
+
+/**
+ * Shader varyings.
+ * @enum {string}
+ */
+export const V = {
+  POSITION: 'v_position',
+};
+
+/**
+ * @classdesc
+ * Experimental WebGL renderer for vector fields.
+ * @extends {WebGLTileLayerRenderer<LayerType>}
+ */
+class FlowLayerRenderer extends WebGLTileLayerRenderer {
+  /**
+   * @param {LayerType} layer The tiled field layer.
+   * @param {Options} options The renderer options.
+   */
+  constructor(layer, options) {
+    super(layer, {
+      vertexShader: options.tileVertexShader,
+      fragmentShader: options.tileFragmentShader,
+      cacheSize: options.cacheSize,
+      // TODO: rework the post-processing logic
+      // see https://github.com/openlayers/openlayers/issues/16120
+      postProcesses: [{}],
+      uniforms: {
+        [U.MAX_SPEED]: options.maxSpeed,
+      },
+    });
+
+    /**
+     * @type {string}
+     * @private
+     */
+    this.particleColorFragmentShader_ = options.particleColorFragmentShader;
+
+    /**
+     * @type {WebGLTexture|null}
+     * @private
+     */
+    this.velocityTexture_ = null;
+
+    /**
+     * @type {number}
+     * @private
+     */
+    this.particleCountSqrt_ = options.particles
+      ? Math.ceil(Math.sqrt(options.particles))
+      : 256;
+
+    /**
+     * @type {WebGLArrayBuffer}
+     * @private
+     */
+    this.particleIndexBuffer_;
+
+    /**
+     * @type {WebGLArrayBuffer}
+     * @private
+     */
+    this.quadBuffer_;
+
+    /**
+     * @type {WebGLProgram}
+     * @private
+     */
+    this.particlePositionProgram_;
+
+    /**
+     * @type {string}
+     * @private
+     */
+    this.particlePositionVertexShader_ = options.particlePositionVertexShader;
+
+    /**
+     * @type {string}
+     * @private
+     */
+    this.particlePositionFragmentShader_ =
+      options.particlePositionFragmentShader;
+
+    /**
+     * @type {WebGLTexture}
+     * @private
+     */
+    this.previousPositionTexture_;
+
+    /**
+     * @type {WebGLTexture}
+     * @private
+     */
+    this.nextPositionTexture_;
+
+    /**
+     * @type {WebGLProgram}
+     * @private
+     */
+    this.particleColorProgram_;
+
+    /**
+     * @type {string}
+     * @private
+     */
+    this.particleColorVertexShader_ = options.particleColorVertexShader;
+
+    /**
+     * @type {string}
+     * @private
+     */
+    this.particleColorFragmentShader_ = options.particleColorFragmentShader;
+
+    /**
+     * @type {WebGLProgram}
+     * @private
+     */
+    this.textureProgram_;
+
+    /**
+     * @type {string}
+     * @private
+     */
+    this.textureVertexShader_ = options.textureVertexShader;
+
+    /**
+     * @type {string}
+     * @private
+     */
+    this.textureFragmentShader_ = options.textureFragmentShader;
+
+    /**
+     * @type {WebGLTexture}
+     * @private
+     */
+    this.previousTrailsTexture_;
+
+    /**
+     * @type {WebGLTexture}
+     * @private
+     */
+    this.nextTrailsTexture_;
+
+    /**
+     * @type {number}
+     * @private
+     */
+    this.fadeOpacity_ = 0.996; // how fast the particle trails fade on each frame
+
+    /**
+     * @type {number}
+     * @private
+     */
+    this.maxSpeed_ = options.maxSpeed;
+
+    /**
+     * @type {number}
+     * @private
+     */
+    this.speedFactor_ = options.speedFactor || 0.001;
+
+    /**
+     * @type {number}
+     * @private
+     */
+    this.dropRate_ = 0.003; // how often the particles move to a random place
+
+    /**
+     * @type {number}
+     * @private
+     */
+    this.dropRateBump_ = 0.01; // drop rate increase relative to individual particle speed
+
+    /**
+     * @type {Array<number>}
+     * @private
+     */
+    this.tempVec2_ = [0, 0];
+
+    /**
+     * @type {number}
+     * @private
+     */
+    this.renderedWidth_ = 0;
+
+    /**
+     * @type {number}
+     * @private
+     */
+    this.renderedHeight_ = 0;
+  }
+
+  /**
+   * @override
+   */
+  afterHelperCreated() {
+    super.afterHelperCreated();
+    const helper = this.helper;
+
+    const gl = helper.getGL();
+    this.framebuffer_ = gl.createFramebuffer();
+
+    const particleCount = this.particleCountSqrt_ * this.particleCountSqrt_;
+    const particleIndices = new Float32Array(particleCount);
+    for (let i = 0; i < particleCount; ++i) {
+      particleIndices[i] = i;
+    }
+    const particleIndexBuffer = new WebGLArrayBuffer(ARRAY_BUFFER, STATIC_DRAW);
+    particleIndexBuffer.setArray(particleIndices);
+    helper.flushBufferData(particleIndexBuffer);
+    this.particleIndexBuffer_ = particleIndexBuffer;
+
+    const quadIndices = new Float32Array([0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1]);
+    const quadBuffer = new WebGLArrayBuffer(ARRAY_BUFFER, STATIC_DRAW);
+    quadBuffer.setArray(quadIndices);
+    helper.flushBufferData(quadBuffer);
+    this.quadBuffer_ = quadBuffer;
+
+    const particlePositions = new Uint8Array(particleCount * 4);
+    for (let i = 0; i < particlePositions.length; ++i) {
+      particlePositions[i] = Math.floor(Math.random() * 256);
+    }
+
+    this.previousPositionTexture_ = helper.createTexture(
+      [this.particleCountSqrt_, this.particleCountSqrt_],
+      particlePositions,
+      null,
+      true,
+    );
+
+    this.nextPositionTexture_ = helper.createTexture(
+      [this.particleCountSqrt_, this.particleCountSqrt_],
+      particlePositions,
+      null,
+      true,
+    );
+
+    this.particlePositionProgram_ = helper.getProgram(
+      this.particlePositionFragmentShader_,
+      this.particlePositionVertexShader_,
+    );
+
+    this.particleColorProgram_ = helper.getProgram(
+      this.particleColorFragmentShader_,
+      this.particleColorVertexShader_,
+    );
+
+    this.textureProgram_ = helper.getProgram(
+      this.textureFragmentShader_,
+      this.textureVertexShader_,
+    );
+  }
+
+  createSizeDependentTextures_() {
+    const helper = this.helper;
+    const gl = helper.getGL();
+    const canvas = helper.getCanvas();
+    const screenWidth = canvas.width;
+    const screenHeight = canvas.height;
+
+    const blank = new Uint8Array(screenWidth * screenHeight * 4);
+
+    if (this.nextTrailsTexture_) {
+      gl.deleteTexture(this.nextTrailsTexture_);
+    }
+    this.nextTrailsTexture_ = helper.createTexture(
+      [screenWidth, screenHeight],
+      blank,
+      null,
+      true,
+    );
+
+    if (this.previousTrailsTexture_) {
+      gl.deleteTexture(this.previousTrailsTexture_);
+    }
+    this.previousTrailsTexture_ = helper.createTexture(
+      [screenWidth, screenHeight],
+      blank,
+      null,
+      true,
+    );
+  }
+
+  /**
+   * @override
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   */
+  beforeFinalize(frameState) {
+    const helper = this.helper;
+    const gl = helper.getGL();
+    const canvas = helper.getCanvas();
+    const screenWidth = canvas.width;
+    const screenHeight = canvas.height;
+
+    if (
+      this.renderedWidth_ != screenWidth ||
+      this.renderedHeight_ != screenHeight
+    ) {
+      this.createSizeDependentTextures_();
+    }
+
+    const size = [screenWidth, screenHeight];
+
+    // copy current frame buffer to the velocity texture
+    this.velocityTexture_ = helper.createTexture(
+      size,
+      null,
+      this.velocityTexture_,
+    );
+    gl.copyTexImage2D(
+      gl.TEXTURE_2D,
+      0,
+      gl.RGBA,
+      0,
+      0,
+      screenWidth,
+      screenHeight,
+      0,
+    );
+
+    this.drawParticleTrails_(frameState);
+    this.updateParticlePositions_(frameState);
+
+    frameState.animate = true;
+    this.renderedWidth_ = screenWidth;
+    this.renderedHeight_ = screenHeight;
+  }
+
+  /**
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   */
+  drawParticleTrails_(frameState) {
+    const helper = this.helper;
+    const gl = helper.getGL();
+
+    helper.bindFrameBuffer(this.framebuffer_, this.nextTrailsTexture_);
+
+    this.drawTexture_(this.previousTrailsTexture_, this.fadeOpacity_);
+    this.drawParticleColor_(frameState);
+
+    helper.bindInitialFrameBuffer();
+    gl.clearColor(0.0, 0.0, 0.0, 0.0);
+    gl.clear(gl.COLOR_BUFFER_BIT);
+
+    gl.enable(gl.BLEND);
+    gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+    this.drawTexture_(this.nextTrailsTexture_, 1);
+    gl.disable(gl.BLEND);
+
+    const current = this.nextTrailsTexture_;
+    this.nextTrailsTexture_ = this.previousTrailsTexture_;
+    this.previousTrailsTexture_ = current;
+  }
+
+  /**
+   * @param {WebGLTexture} texture The texture to draw.
+   * @param {number} opacity The opacity.
+   */
+  drawTexture_(texture, opacity) {
+    const helper = this.helper;
+    const gl = helper.getGL();
+
+    helper.useProgram(this.textureProgram_);
+    helper.bindTexture(texture, 0, U.TEXTURE);
+    helper.bindAttribute(this.quadBuffer_, A.POSITION, 2);
+    this.helper.setUniformFloatValue(U.OPACITY, opacity);
+
+    gl.drawArrays(gl.TRIANGLES, 0, 6);
+  }
+
+  /**
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   */
+  drawParticleColor_(frameState) {
+    const helper = this.helper;
+    const gl = helper.getGL();
+
+    helper.useProgram(this.particleColorProgram_);
+
+    const particleCount = this.particleCountSqrt_ * this.particleCountSqrt_;
+
+    helper.bindAttribute(this.particleIndexBuffer_, A.INDEX, 1);
+
+    helper.bindTexture(this.previousPositionTexture_, 0, U.POSITION_TEXTURE);
+    helper.bindTexture(this.velocityTexture_, 1, U.VELOCITY_TEXTURE);
+
+    this.helper.setUniformFloatValue(
+      U.PARTICLE_COUNT_SQRT,
+      this.particleCountSqrt_,
+    );
+
+    const rotation = this.tempVec2_;
+    rotation[0] = Math.cos(frameState.viewState.rotation);
+    rotation[1] = Math.sin(frameState.viewState.rotation);
+    this.helper.setUniformFloatVec2(U.ROTATION, rotation);
+
+    this.helper.setUniformFloatValue(U.MAX_SPEED, this.maxSpeed_);
+
+    gl.drawArrays(gl.POINTS, 0, particleCount);
+  }
+
+  /**
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   */
+  updateParticlePositions_(frameState) {
+    const helper = this.helper;
+    const gl = helper.getGL();
+
+    helper.useProgram(this.particlePositionProgram_);
+    gl.viewport(0, 0, this.particleCountSqrt_, this.particleCountSqrt_);
+    helper.bindFrameBuffer(this.framebuffer_, this.nextPositionTexture_);
+
+    helper.bindTexture(this.previousPositionTexture_, 0, U.POSITION_TEXTURE);
+    helper.bindTexture(this.velocityTexture_, 1, U.VELOCITY_TEXTURE);
+    helper.bindAttribute(this.quadBuffer_, A.POSITION, 2);
+
+    helper.setUniformFloatValue(U.RANDOM_SEED, Math.random());
+    helper.setUniformFloatValue(U.SPEED_FACTOR, this.speedFactor_);
+    helper.setUniformFloatValue(U.DROP_RATE, this.dropRate_);
+    helper.setUniformFloatValue(U.DROP_RATE_BUMP, this.dropRateBump_);
+
+    const rotation = this.tempVec2_;
+    rotation[0] = Math.cos(frameState.viewState.rotation);
+    rotation[1] = Math.sin(frameState.viewState.rotation);
+    this.helper.setUniformFloatVec2(U.ROTATION, rotation);
+
+    const size = frameState.size;
+    this.helper.setUniformFloatVec2(U.VIEWPORT_SIZE_PX, [size[0], size[1]]);
+
+    gl.drawArrays(gl.TRIANGLES, 0, 6);
+
+    const current = this.nextPositionTexture_;
+    this.nextPositionTexture_ = this.previousPositionTexture_;
+    this.previousPositionTexture_ = current;
+  }
+}
+
+export default FlowLayerRenderer;

package/renderer/webgl/TileLayer.d.ts

@@ -44,8 +44,11 @@ export type Options = {
      * The texture cache size.
      */
     cacheSize?: number | undefined;
+    /**
+     * Post-processes definitions.
+     */
+    postProcesses?: import("./Layer.js").PostProcessesOptions[] | undefined;
 };
-export type LayerType = import("../../layer/WebGLTile.js").default;
 export type TileTextureType = import("../../webgl/TileTexture.js").TileType;
 export type TileTextureRepresentation = import("../../webgl/TileTexture.js").default;
 /**
@@ -56,9 +59,7 @@ export type TileTextureRepresentation = import("../../webgl/TileTexture.js").def
  * made available to shaders.
  * @property {Array<import("../../webgl/PaletteTexture.js").default>} [paletteTextures] Palette textures.
  * @property {number} [cacheSize=512] The texture cache size.
- */
-/**
- * @typedef {import("../../layer/WebGLTile.js").default} LayerType
+ * @property {Array<import('./Layer.js').PostProcessesOptions>} [postProcesses] Post-processes definitions.
  */
 /**
  * @typedef {import("../../webgl/TileTexture.js").TileType} TileTextureType
@@ -69,10 +70,11 @@ export type TileTextureRepresentation = import("../../webgl/TileTexture.js").def
 /**
  * @classdesc
  * WebGL renderer for tile layers.
+ * @template {import("../../layer/WebGLTile.js").default|import("../../layer/Flow.js").default} LayerType
  * @extends {WebGLBaseTileLayerRenderer<LayerType, TileTextureType, TileTextureRepresentation>}
  * @api
  */
-declare class WebGLTileLayerRenderer extends WebGLBaseTileLayerRenderer<import("../../layer/WebGLTile.js").default, import("../../webgl/TileTexture.js").TileType, TileTexture> {
+declare class WebGLTileLayerRenderer<LayerType extends import("../../layer/WebGLTile.js").default | import("../../layer/Flow.js").default> extends WebGLBaseTileLayerRenderer<LayerType, import("../../webgl/TileTexture.js").TileType, TileTexture> {
     /**
      * @param {LayerType} tileLayer Tile layer.
      * @param {Options} options Options.

package/renderer/webgl/TileLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TileLayer.d.ts","sourceRoot":"","sources":["TileLayer.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;EAQE;;;;;;;;;kBAmBY,MAAM;;;;oBACN,MAAM;;;;;;;;;;;;;;;;;wBAQP,OAAO,0BAA0B,EAAE,OAAO;8BAG1C,OAAO,4BAA4B,EAAE,QAAQ;wCAG7C,OAAO,4BAA4B,EAAE,OAAO;AAjBzD;;;;;;;;GAQG;AAEH;;GAEG;AACH;;GAEG;AACH;;GAEG;AAEH;;;;;GAKG;AACH;IACE;;;OAGG;IACH,uBAHW,SAAS,WACT,OAAO,EA8CjB;IAzCC;;;OAGG;IACH,iBAAa;IAEb;;OAEG;IACH,sBAAyC;IAEzC;;OAEG;IACH,wBAA6C;IAE7C;;;;;;;;;;;;;;;;OAgBG;IACH,iBAAuE;IAGvE;;;OAGG;IACH,yBAAqD;IAGvD;;;OAGG;IACH,wBAHW,OAAO,QAsBjB;IA6BD;;OAEG;IACH,6DAEC;IAED;;OAEG;IACH,uEAGC;IAED;;OAEG;IACH,+MA+FC;IAED;;;;OAIG;IACH,wBAJW,OAAO,gBAAgB,EAAE,KAAK,GAC7B,iBAAiB,GAAC,UAAU,GAAC,YAAY,GAAC,QAAQ,CA6F7D;CAsBF;wBApZuB,4BAA4B;uCAK7C,oBAAoB"}
+{"version":3,"file":"TileLayer.d.ts","sourceRoot":"","sources":["TileLayer.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;EAQE;;;;;;;;;kBAmBY,MAAM;;;;oBACN,MAAM;;;;;;;;;;;;;;;;;;;;;8BASP,OAAO,4BAA4B,EAAE,QAAQ;wCAI7C,OAAO,4BAA4B,EAAE,OAAO;AAhBzD;;;;;;;;;GASG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;;;;;GAMG;AACH,qCAJgG,SAAS,SAA3F,OAAO,0BAA0B,EAAE,OAAO,GAAC,OAAO,qBAAqB,EAAE,OAAQ;IAK7F;;;OAGG;IACH,uBAHW,SAAS,WACT,OAAO,EA8CjB;IAzCC;;;OAGG;IACH,iBAAa;IAEb;;OAEG;IACH,sBAAyC;IAEzC;;OAEG;IACH,wBAA6C;IAE7C;;;;;;;;;;;;;;;;OAgBG;IACH,iBAAuE;IAGvE;;;OAGG;IACH,yBAAqD;IAGvD;;;OAGG;IACH,wBAHW,OAAO,QA2BjB;IAmCD;;OAEG;IACH,6DAEC;IAED;;OAEG;IACH,uEAGC;IAED;;OAEG;IACH,+MA+FC;IAED;;;;OAIG;IACH,wBAJW,OAAO,gBAAgB,EAAE,KAAK,GAC7B,iBAAiB,GAAC,UAAU,GAAC,YAAY,GAAC,QAAQ,CA6F7D;CAsBF;wBA/ZuB,4BAA4B;uCAK7C,oBAAoB"}

package/renderer/webgl/TileLayer.js

@@ -55,14 +55,13 @@ const attributeDescriptions = [
  * made available to shaders.
  * @property {Array<import("../../webgl/PaletteTexture.js").default>} [paletteTextures] Palette textures.
  * @property {number} [cacheSize=512] The texture cache size.
+ * @property {Array<import('./Layer.js').PostProcessesOptions>} [postProcesses] Post-processes definitions.
  */
 
-/**
- * @typedef {import("../../layer/WebGLTile.js").default} LayerType
- */
 /**
  * @typedef {import("../../webgl/TileTexture.js").TileType} TileTextureType
  */
+
 /**
  * @typedef {import("../../webgl/TileTexture.js").default} TileTextureRepresentation
  */
@@ -70,6 +69,7 @@ const attributeDescriptions = [
 /**
  * @classdesc
  * WebGL renderer for tile layers.
+ * @template {import("../../layer/WebGLTile.js").default|import("../../layer/Flow.js").default} LayerType
  * @extends {WebGLBaseTileLayerRenderer<LayerType, TileTextureType, TileTextureRepresentation>}
  * @api
  */
@@ -146,6 +146,11 @@ class WebGLTileLayerRenderer extends WebGLBaseTileLayerRenderer {
         this.fragmentShader_,
         this.vertexShader_,
       );
+      const gl = this.helper.getGL();
+      for (const paletteTexture of this.paletteTextures_) {
+        // upload the texture data
+        paletteTexture.getTexture(gl);
+      }
     }
   }
 
@@ -155,6 +160,12 @@ class WebGLTileLayerRenderer extends WebGLBaseTileLayerRenderer {
   afterHelperCreated() {
     super.afterHelperCreated();
 
+    const gl = this.helper.getGL();
+    for (const paletteTexture of this.paletteTextures_) {
+      // upload the texture data
+      paletteTexture.getTexture(gl);
+    }
+
     this.program_ = this.helper.getProgram(
       this.fragmentShader_,
       this.vertexShader_,

package/renderer/webgl/TileLayerBase.d.ts

@@ -188,6 +188,11 @@ declare class WebGLBaseTileLayerRenderer<LayerType extends BaseLayerType, TileTy
      * @override
      */
     override renderFrame(frameState: import("../../Map.js").FrameState): HTMLElement;
+    /**
+     * @param {import("../../Map.js").FrameState} frameState Frame state.
+     * @protected
+     */
+    protected beforeFinalize(frameState: import("../../Map.js").FrameState): void;
     /**
      * Look for tiles covering the provided tile coordinate at an alternate
      * zoom level.  Loaded tiles will be added to the provided tile representation lookup.

package/renderer/webgl/TileLayerBase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TileLayerBase.d.ts","sourceRoot":"","sources":["TileLayerBase.js"],"names":[],"mappings":"AAuDA;;GAEG;AACH;;;;GAIG;AAEH;;GAEG;AACH,+CAFY,wBAAwB,CAInC;AA0DD,iEAEC;;;;;;;;;;;;;;yCAzEY,OAAO,uCAAuC,EAAE,OAAO,CAAC,OAAO,eAAe,EAAE,OAAO,CAAC;;;;;aAIvF,GAAG,CAAC,MAAM,CAAC;;;;wBACX;YAAO,MAAM,GAAE,GAAG,CAAC,0BAA0B,CAAC;KAAC;;;;;;;;;;;;;;;;;;;4BA+EhD,mDAAyC;AATtD;;;;;;GAMG;AAEH;;GAEG;AAEH;;;;;;;GAOG;AACH,yCAL6B,SAAS,SAAxB,aAAc,EACmB,QAAQ,SAA1C,OAAQ,eAAe,EAAE,OAAQ,EACmC,kBAAkB,SAAtF,OAAQ,uCAAuC,EAAE,OAAO,CAAC,QAAQ,CAAE;IAI9E;;;OAGG;IACH,uBAHW,SAAS,WACT,OAAO,EA+DjB;IAvDC;;;OAGG;IACH,gBAFU,OAAO,CAEU;IAE3B;;;;OAIG;IACH,uBAAuC;IAEvC;;;OAGG;IACH,oBAHU,KAAK,CAAC,MAAM,CAAC,CAGK;IAE5B;;;OAGG;IACH,uBAA+C;IAE/C;;;OAGG;IACH,uBAA8C;IAE9C;;;OAGG;IACH,kBAAuB;IAGvB;;;OAGG;IACH,mCAHU,OAAO,2BAA2B,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAGnB;IAEtD;;;OAGG;IACH,sBAFU,OAAO,cAAc,EAAE,UAAU,GAAC,IAAI,CAE1B;IAEtB;;;OAGG;IACH,oBAA4B;IAG9B;;;OAGG;IACH,wBAHW,OAAO,QAOjB;IA4BD;;;;;OAKG;IACH,4CAJW,OAAO,uCAAuC,EAAE,yBAAyB,CAAC,QAAQ,CAAC,GAClF,kBAAkB,CAK7B;IAED;;;;;;OAMG;IACH,yBANW,OAAO,cAAc,EAAE,UAAU,UACjC,OAAO,iBAAiB,EAAE,MAAM,YAChC,MAAM,4BACN,wBAAwB,WACxB,MAAM,QAqHhB;IAED;;;;OAIG;IACH,wCAJW,OAAO,cAAc,EAAE,UAAU,kBACjC,OAAO,QAKjB;IAED;;;;OAIG;IACH,4CAJW,OAAO,cAAc,EAAE,UAAU,GAChC,OAAO,CAKlB;IAED;;;;;;;;;;;;;OAaG;IACH,yCAbW,kBAAkB,iBAClB,OAAO,oBAAoB,EAAE,SAAS,cACtC,OAAO,cAAc,EAAE,UAAU,gBACjC,OAAO,iBAAiB,EAAE,MAAM,kBAChC,MAAM,YACN,OAAO,eAAe,EAAE,IAAI,cAC5B,OAAO,qBAAqB,EAAE,UAAU,cACxC,OAAO,iBAAiB,EAAE,MAAM,SAChC,MAAM,UACN,MAAM,SACN,MAAM,QAeb;IAEJ;;;;;;OAMG;IACH,6CANW,kBAAkB,SAClB,MAAM,UACN,OAAO,iBAAiB,EAAE,MAAM,SAChC,MAAM,QAG0C;IAE3D,iIAuEC;IAED;;;;;OAKG;IACH,iCAJW,OAAO,cAAc,EAAE,UAAU,GAChC,WAAW,CAyNtB;IAED;;;;;;;;;;OAUG;IACH,sBAsCC;CAkCF;+BA9yB8B,YAAY"}
+{"version":3,"file":"TileLayerBase.d.ts","sourceRoot":"","sources":["TileLayerBase.js"],"names":[],"mappings":"AAuDA;;GAEG;AACH;;;;GAIG;AAEH;;GAEG;AACH,+CAFY,wBAAwB,CAInC;AA0DD,iEAEC;;;;;;;;;;;;;;yCAzEY,OAAO,uCAAuC,EAAE,OAAO,CAAC,OAAO,eAAe,EAAE,OAAO,CAAC;;;;;aAIvF,GAAG,CAAC,MAAM,CAAC;;;;wBACX;YAAO,MAAM,GAAE,GAAG,CAAC,0BAA0B,CAAC;KAAC;;;;;;;;;;;;;;;;;;;4BA+EhD,mDAAyC;AATtD;;;;;;GAMG;AAEH;;GAEG;AAEH;;;;;;;GAOG;AACH,yCAL6B,SAAS,SAAxB,aAAc,EACmB,QAAQ,SAA1C,OAAQ,eAAe,EAAE,OAAQ,EACmC,kBAAkB,SAAtF,OAAQ,uCAAuC,EAAE,OAAO,CAAC,QAAQ,CAAE;IAI9E;;;OAGG;IACH,uBAHW,SAAS,WACT,OAAO,EA+DjB;IAvDC;;;OAGG;IACH,gBAFU,OAAO,CAEU;IAE3B;;;;OAIG;IACH,uBAAuC;IAEvC;;;OAGG;IACH,oBAHU,KAAK,CAAC,MAAM,CAAC,CAGK;IAE5B;;;OAGG;IACH,uBAA+C;IAE/C;;;OAGG;IACH,uBAA8C;IAE9C;;;OAGG;IACH,kBAAuB;IAGvB;;;OAGG;IACH,mCAHU,OAAO,2BAA2B,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAGnB;IAEtD;;;OAGG;IACH,sBAFU,OAAO,cAAc,EAAE,UAAU,GAAC,IAAI,CAE1B;IAEtB;;;OAGG;IACH,oBAA4B;IAG9B;;;OAGG;IACH,wBAHW,OAAO,QAOjB;IA4BD;;;;;OAKG;IACH,4CAJW,OAAO,uCAAuC,EAAE,yBAAyB,CAAC,QAAQ,CAAC,GAClF,kBAAkB,CAK7B;IAED;;;;;;OAMG;IACH,yBANW,OAAO,cAAc,EAAE,UAAU,UACjC,OAAO,iBAAiB,EAAE,MAAM,YAChC,MAAM,4BACN,wBAAwB,WACxB,MAAM,QAqHhB;IAED;;;;OAIG;IACH,wCAJW,OAAO,cAAc,EAAE,UAAU,kBACjC,OAAO,QAKjB;IAED;;;;OAIG;IACH,4CAJW,OAAO,cAAc,EAAE,UAAU,GAChC,OAAO,CAKlB;IAED;;;;;;;;;;;;;OAaG;IACH,yCAbW,kBAAkB,iBAClB,OAAO,oBAAoB,EAAE,SAAS,cACtC,OAAO,cAAc,EAAE,UAAU,gBACjC,OAAO,iBAAiB,EAAE,MAAM,kBAChC,MAAM,YACN,OAAO,eAAe,EAAE,IAAI,cAC5B,OAAO,qBAAqB,EAAE,UAAU,cACxC,OAAO,iBAAiB,EAAE,MAAM,SAChC,MAAM,UACN,MAAM,SACN,MAAM,QAeb;IAEJ;;;;;;OAMG;IACH,6CANW,kBAAkB,SAClB,MAAM,UACN,OAAO,iBAAiB,EAAE,MAAM,SAChC,MAAM,QAG0C;IAE3D,iIAuEC;IAED;;;;;OAKG;IACH,iCAJW,OAAO,cAAc,EAAE,UAAU,GAChC,WAAW,CA0NtB;IAED;;;OAGG;IACH,qCAHW,OAAO,cAAc,EAAE,UAAU,QAK3C;IAED;;;;;;;;;;OAUG;IACH,sBAsCC;CAkCF;+BAvzB8B,YAAY"}

package/renderer/webgl/TileLayerBase.js

@@ -706,6 +706,7 @@ class WebGLBaseTileLayerRenderer extends WebGLLayerRenderer {
       }
     }
 
+    this.beforeFinalize(frameState);
     this.helper.finalizeDraw(
       frameState,
       this.dispatchPreComposeEvent,
@@ -737,6 +738,14 @@ class WebGLBaseTileLayerRenderer extends WebGLLayerRenderer {
     return canvas;
   }
 
+  /**
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @protected
+   */
+  beforeFinalize(frameState) {
+    return;
+  }
+
   /**
    * Look for tiles covering the provided tile coordinate at an alternate
    * zoom level.  Loaded tiles will be added to the provided tile representation lookup.

package/util.js

@@ -33,4 +33,4 @@ export function getUid(obj) {
  * OpenLayers version.
  * @type {string}
  */
-export const VERSION = '10.1.1-dev.1724296077041';
+export const VERSION = '10.1.1-dev.1724415449548';

package/webgl/Buffer.d.ts

@@ -37,7 +37,7 @@ declare class WebGLArrayBuffer {
     /**
      * @param {number} type Buffer type, either ARRAY_BUFFER or ELEMENT_ARRAY_BUFFER.
      * @param {number} [usage] Intended usage, either `STATIC_DRAW`, `STREAM_DRAW` or `DYNAMIC_DRAW`.
-     * Default is `DYNAMIC_DRAW`.
+     * Default is `STATIC_DRAW`.
      */
     constructor(type: number, usage?: number | undefined);
     /**
@@ -83,6 +83,10 @@ declare class WebGLArrayBuffer {
      * @return {Float32Array|Uint32Array|null} Array.
      */
     getArray(): Float32Array | Uint32Array | null;
+    /**
+     * @param {Float32Array|Uint32Array} array Array.
+     */
+    setArray(array: Float32Array | Uint32Array): void;
     /**
      * @return {number} Usage.
      */

package/webgl/Buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Buffer.d.ts","sourceRoot":"","sources":["Buffer.js"],"names":[],"mappings":"AAmIA;;;;GAIG;AACH,2CAHW,MAAM,GACL,uBAAuB,GAAC,sBAAsB,CAWzD;;;;;0BAlIS,MAAM;;;;;;;4BANT,aAAa;4BAAb,aAAa;6BAAb,aAAa;AAcpB;;;;;;;;;;;;;;GAcG;AACH;IACE;;;;OAIG;IACH,kBAJW,MAAM,8BA2BhB;IAtBC;;;OAGG;IACH,eAAkB;IAElB;;;OAGG;IACH,cAAiB;IAOjB;;;OAGG;IACH,eAAmE;IAGrE;;;;OAIG;IACH,aAHW,MAAM,GACL,gBAAgB,CAK3B;IAED;;;;OAIG;IACH,iBAHW,KAAK,CAAC,MAAM,CAAC,GACZ,gBAAgB,CAK3B;IAED;;;;;OAKG;IACH,wBAJW,WAAW,GAEV,gBAAgB,CAK3B;IAED;;OAEG;IACH,WAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,YAFY,YAAY,GAAC,WAAW,GAAC,IAAI,CAIxC;IAED;;OAEG;IACH,YAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,WAFY,MAAM,CAIjB;CACF"}
+{"version":3,"file":"Buffer.d.ts","sourceRoot":"","sources":["Buffer.js"],"names":[],"mappings":"AA8IA;;;;GAIG;AACH,2CAHW,MAAM,GACL,uBAAuB,GAAC,sBAAsB,CAWzD;;;;;0BA7IS,MAAM;;;;;;;4BANT,aAAa;4BAAb,aAAa;6BAAb,aAAa;AAcpB;;;;;;;;;;;;;;GAcG;AACH;IACE;;;;OAIG;IACH,kBAJW,MAAM,8BA2BhB;IAtBC;;;OAGG;IACH,eAAkB;IAElB;;;OAGG;IACH,cAAiB;IAOjB;;;OAGG;IACH,eAAmE;IAGrE;;;;OAIG;IACH,aAHW,MAAM,GACL,gBAAgB,CAK3B;IAED;;;;OAIG;IACH,iBAHW,KAAK,CAAC,MAAM,CAAC,GACZ,gBAAgB,CAK3B;IAED;;;;;OAKG;IACH,wBAJW,WAAW,GAEV,gBAAgB,CAK3B;IAED;;OAEG;IACH,WAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,YAFY,YAAY,GAAC,WAAW,GAAC,IAAI,CAIxC;IAED;;OAEG;IACH,gBAFW,YAAY,GAAC,WAAW,QAQlC;IAED;;OAEG;IACH,YAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,WAFY,MAAM,CAIjB;CACF"}

package/webgl/Buffer.js

@@ -40,7 +40,7 @@ class WebGLArrayBuffer {
   /**
    * @param {number} type Buffer type, either ARRAY_BUFFER or ELEMENT_ARRAY_BUFFER.
    * @param {number} [usage] Intended usage, either `STATIC_DRAW`, `STREAM_DRAW` or `DYNAMIC_DRAW`.
-   * Default is `DYNAMIC_DRAW`.
+   * Default is `STATIC_DRAW`.
    */
   constructor(type, usage) {
     /**
@@ -113,6 +113,17 @@ class WebGLArrayBuffer {
     return this.array_;
   }
 
+  /**
+   * @param {Float32Array|Uint32Array} array Array.
+   */
+  setArray(array) {
+    const ArrayType = getArrayClassForType(this.type_);
+    if (!(array instanceof ArrayType)) {
+      throw new Error(`Expected ${ArrayType}`);
+    }
+    this.array_ = array;
+  }
+
   /**
    * @return {number} Usage.
    */