ol 7.0.0-dev.1658443472213 → 7.0.0-dev.1658733468997

package/src/render/webgl/BatchRenderer.js

@@ -0,0 +1,201 @@
+/**
+ * @module ol/render/webgl/BatchRenderer
+ */
+import {WebGLWorkerMessageType} from './constants.js';
+import {abstract} from '../../util.js';
+import {
+  create as createTransform,
+  makeInverse as makeInverseTransform,
+  multiply as multiplyTransform,
+  translate as translateTransform,
+} from '../../transform.js';
+
+/**
+ * @typedef {Object} CustomAttribute A description of a custom attribute to be passed on to the GPU, with a value different
+ * for each feature.
+ * @property {string} name Attribute name.
+ * @property {function(import("../../Feature").default):number} callback This callback computes the numerical value of the
+ * attribute for a given feature.
+ */
+
+let workerMessageCounter = 0;
+
+/**
+ * @classdesc Abstract class for batch renderers.
+ * Batch renderers are meant to render the geometries contained in a {@link module:ol/render/webgl/GeometryBatch}
+ * instance. They are responsible for generating render instructions and transforming them into WebGL buffers.
+ */
+class AbstractBatchRenderer {
+  /**
+   * @param {import("../../webgl/Helper.js").default} helper WebGL helper instance
+   * @param {Worker} worker WebGL worker instance
+   * @param {string} vertexShader Vertex shader
+   * @param {string} fragmentShader Fragment shader
+   * @param {Array<CustomAttribute>} customAttributes List of custom attributes
+   */
+  constructor(helper, worker, vertexShader, fragmentShader, customAttributes) {
+    /**
+     * @type {import("../../webgl/Helper.js").default}
+     * @private
+     */
+    this.helper_ = helper;
+
+    /**
+     * @type {Worker}
+     * @private
+     */
+    this.worker_ = worker;
+
+    /**
+     * @type {WebGLProgram}
+     * @private
+     */
+    this.program_ = this.helper_.getProgram(fragmentShader, vertexShader);
+
+    /**
+     * A list of attributes used by the renderer.
+     * @type {Array<import('../../webgl/Helper.js').AttributeDescription>}
+     * @protected
+     */
+    this.attributes = [];
+
+    /**
+     * @type {Array<CustomAttribute>}
+     * @protected
+     */
+    this.customAttributes = customAttributes;
+  }
+
+  /**
+   * Rebuild rendering instructions and webgl buffers based on the provided frame state
+   * Note: this is a costly operation.
+   * @param {import("./MixedGeometryBatch.js").GeometryBatch} batch Geometry batch
+   * @param {import("../../PluggableMap").FrameState} frameState Frame state.
+   * @param {import("../../geom/Geometry.js").Type} geometryType Geometry type
+   * @param {function(): void} callback Function called once the render buffers are updated
+   */
+  rebuild(batch, frameState, geometryType, callback) {
+    // store transform for rendering instructions
+    batch.renderInstructionsTransform = this.helper_.makeProjectionTransform(
+      frameState,
+      createTransform()
+    );
+    this.generateRenderInstructions(batch);
+    this.generateBuffers_(batch, geometryType, callback);
+  }
+
+  /**
+   * Render the geometries in the batch. This will also update the current transform used for rendering according to
+   * the invert transform of the webgl buffers
+   * @param {import("./MixedGeometryBatch.js").GeometryBatch} batch Geometry batch
+   * @param {import("../../transform.js").Transform} currentTransform Transform
+   * @param {import("../../PluggableMap.js").FrameState} frameState Frame state.
+   * @param {number} offsetX X offset
+   */
+  render(batch, currentTransform, frameState, offsetX) {
+    // multiply the current projection transform with the invert of the one used to fill buffers
+    this.helper_.makeProjectionTransform(frameState, currentTransform);
+    translateTransform(currentTransform, offsetX, 0);
+    multiplyTransform(currentTransform, batch.invertVerticesBufferTransform);
+
+    // enable program, buffers and attributes
+    this.helper_.useProgram(this.program_, frameState);
+    this.helper_.bindBuffer(batch.verticesBuffer);
+    this.helper_.bindBuffer(batch.indicesBuffer);
+    this.helper_.enableAttributes(this.attributes);
+
+    const renderCount = batch.indicesBuffer.getSize();
+    this.helper_.drawElements(0, renderCount);
+  }
+
+  /**
+   * Rebuild rendering instructions based on the provided frame state
+   * This is specific to the geometry type and has to be implemented by subclasses.
+   * @param {import("./MixedGeometryBatch.js").GeometryBatch} batch Geometry batch
+   * @protected
+   */
+  generateRenderInstructions(batch) {
+    abstract();
+  }
+
+  /**
+   * Rebuild internal webgl buffers for rendering based on the current rendering instructions;
+   * This is asynchronous: webgl buffers wil _not_ be updated right away
+   * @param {import("./MixedGeometryBatch.js").GeometryBatch} batch Geometry batch
+   * @param {import("../../geom/Geometry.js").Type} geometryType Geometry type
+   * @param {function(): void} callback Function called once the render buffers are updated
+   * @private
+   */
+  generateBuffers_(batch, geometryType, callback) {
+    const messageId = workerMessageCounter++;
+
+    let messageType;
+    switch (geometryType) {
+      case 'Polygon':
+        messageType = WebGLWorkerMessageType.GENERATE_POLYGON_BUFFERS;
+        break;
+      case 'Point':
+        messageType = WebGLWorkerMessageType.GENERATE_POINT_BUFFERS;
+        break;
+      case 'LineString':
+        messageType = WebGLWorkerMessageType.GENERATE_LINE_STRING_BUFFERS;
+        break;
+      default:
+      // pass
+    }
+
+    /** @type {import('./constants.js').WebGLWorkerGenerateBuffersMessage} */
+    const message = {
+      id: messageId,
+      type: messageType,
+      renderInstructions: batch.renderInstructions.buffer,
+      renderInstructionsTransform: batch.renderInstructionsTransform,
+      customAttributesCount: this.customAttributes.length,
+    };
+    this.worker_.postMessage(message, [batch.renderInstructions.buffer]);
+
+    // leave ownership of render instructions
+    batch.renderInstructions = null;
+
+    const handleMessage =
+      /**
+       * @param {*} event Event.
+       * @this {AbstractBatchRenderer}
+       */
+      function (event) {
+        const received = event.data;
+
+        // this is not the response to our request: skip
+        if (received.id !== messageId) {
+          return;
+        }
+
+        // we've received our response: stop listening
+        this.worker_.removeEventListener('message', handleMessage);
+
+        // store transform & invert transform for webgl buffers
+        batch.verticesBufferTransform = received.renderInstructionsTransform;
+        makeInverseTransform(
+          batch.invertVerticesBufferTransform,
+          batch.verticesBufferTransform
+        );
+
+        // copy & flush received buffers to GPU
+        batch.verticesBuffer.fromArrayBuffer(received.vertexBuffer);
+        this.helper_.flushBufferData(batch.verticesBuffer);
+        batch.indicesBuffer.fromArrayBuffer(received.indexBuffer);
+        this.helper_.flushBufferData(batch.indicesBuffer);
+
+        // take back ownership of the render instructions for further use
+        batch.renderInstructions = new Float32Array(
+          received.renderInstructions
+        );
+
+        callback();
+      }.bind(this);
+
+    this.worker_.addEventListener('message', handleMessage);
+  }
+}
+
+export default AbstractBatchRenderer;

package/src/render/webgl/LineStringBatchRenderer.js

@@ -0,0 +1,116 @@
+/**
+ * @module ol/render/webgl/LineStringBatchRenderer
+ */
+import AbstractBatchRenderer from './BatchRenderer.js';
+import {AttributeType} from '../../webgl/Helper.js';
+import {transform2D} from '../../geom/flat/transform.js';
+
+/**
+ * Names of attributes made available to the vertex shader.
+ * Please note: changing these *will* break custom shaders!
+ * @enum {string}
+ */
+export const Attributes = {
+  SEGMENT_START: 'a_segmentStart',
+  SEGMENT_END: 'a_segmentEnd',
+  PARAMETERS: 'a_parameters',
+};
+
+class LineStringBatchRenderer extends AbstractBatchRenderer {
+  /**
+   * @param {import("../../webgl/Helper.js").default} helper WebGL helper instance
+   * @param {Worker} worker WebGL worker instance
+   * @param {string} vertexShader Vertex shader
+   * @param {string} fragmentShader Fragment shader
+   * @param {Array<import('./BatchRenderer.js').CustomAttribute>} customAttributes List of custom attributes
+   */
+  constructor(helper, worker, vertexShader, fragmentShader, customAttributes) {
+    super(helper, worker, vertexShader, fragmentShader, customAttributes);
+
+    // vertices for lines must hold both a position (x,y) and an offset (dx,dy)
+    this.attributes = [
+      {
+        name: Attributes.SEGMENT_START,
+        size: 2,
+        type: AttributeType.FLOAT,
+      },
+      {
+        name: Attributes.SEGMENT_END,
+        size: 2,
+        type: AttributeType.FLOAT,
+      },
+      {
+        name: Attributes.PARAMETERS,
+        size: 1,
+        type: AttributeType.FLOAT,
+      },
+    ].concat(
+      customAttributes.map(function (attribute) {
+        return {
+          name: 'a_' + attribute.name,
+          size: 1,
+          type: AttributeType.FLOAT,
+        };
+      })
+    );
+  }
+
+  /**
+   * Render instructions for lines are structured like so:
+   * [ customAttr0, ... , customAttrN, numberOfVertices0, x0, y0, ... , xN, yN, numberOfVertices1, ... ]
+   * @param {import("./MixedGeometryBatch.js").LineStringGeometryBatch} batch Linestring geometry batch
+   * @override
+   */
+  generateRenderInstructions(batch) {
+    // here we anticipate the amount of render instructions for lines:
+    // 2 instructions per vertex for position (x and y)
+    // + 1 instruction per line per custom attributes
+    // + 1 instruction per line (for vertices count)
+    const totalInstructionsCount =
+      2 * batch.verticesCount +
+      (1 + this.customAttributes.length) * batch.geometriesCount;
+    if (
+      !batch.renderInstructions ||
+      batch.renderInstructions.length !== totalInstructionsCount
+    ) {
+      batch.renderInstructions = new Float32Array(totalInstructionsCount);
+    }
+
+    // loop on features to fill the render instructions
+    let batchEntry;
+    const flatCoords = [];
+    let renderIndex = 0;
+    let value;
+    for (const featureUid in batch.entries) {
+      batchEntry = batch.entries[featureUid];
+      for (let i = 0, ii = batchEntry.flatCoordss.length; i < ii; i++) {
+        flatCoords.length = batchEntry.flatCoordss[i].length;
+        transform2D(
+          batchEntry.flatCoordss[i],
+          0,
+          flatCoords.length,
+          2,
+          batch.renderInstructionsTransform,
+          flatCoords
+        );
+
+        // custom attributes
+        for (let k = 0, kk = this.customAttributes.length; k < kk; k++) {
+          value = this.customAttributes[k].callback(batchEntry.feature);
+          batch.renderInstructions[renderIndex++] = value;
+        }
+
+        // vertices count
+        batch.renderInstructions[renderIndex++] = flatCoords.length / 2;
+
+        // looping on points for positions
+        for (let j = 0, jj = flatCoords.length; j < jj; j += 2) {
+          batch.renderInstructions[renderIndex++] = flatCoords[j];
+          batch.renderInstructions[renderIndex++] = flatCoords[j + 1];
+        }
+      }
+    }
+  }
+}
+
+export default LineStringBatchRenderer;

package/src/render/webgl/MixedGeometryBatch.js

@@ -0,0 +1,364 @@
+/**
+ * @module ol/render/webgl/MixedGeometryBatch
+ */
+import WebGLArrayBuffer from '../../webgl/Buffer.js';
+import {ARRAY_BUFFER, DYNAMIC_DRAW, ELEMENT_ARRAY_BUFFER} from '../../webgl.js';
+import {create as createTransform} from '../../transform.js';
+import {getUid} from '../../util.js';
+
+/**
+ * @typedef {Object} GeometryBatchItem Object that holds a reference to a feature as well as the raw coordinates of its various geometries
+ * @property {import("../../Feature").default} feature Feature
+ * @property {Array<Array<number>>} flatCoordss Array of flat coordinates arrays, one for each geometry related to the feature
+ * @property {number} [verticesCount] Only defined for linestring and polygon batches
+ * @property {number} [ringsCount] Only defined for polygon batches
+ * @property {Array<Array<number>>} [ringsVerticesCounts] Array of vertices counts in each ring for each geometry; only defined for polygons batches
+ */
+
+/**
+ * @typedef {PointGeometryBatch|LineStringGeometryBatch|PolygonGeometryBatch} GeometryBatch
+ */
+
+/**
+ * @typedef {Object} PolygonGeometryBatch A geometry batch specific to polygons
+ * @property {Object<string, GeometryBatchItem>} entries Dictionary of all entries in the batch with associated computed values.
+ * One entry corresponds to one feature. Key is feature uid.
+ * @property {number} geometriesCount Amount of geometries in the batch.
+ * @property {Float32Array} renderInstructions Render instructions for polygons are structured like so:
+ * [ numberOfRings, numberOfVerticesInRing0, ..., numberOfVerticesInRingN, x0, y0, customAttr0, ..., xN, yN, customAttrN, numberOfRings,... ]
+ * @property {WebGLArrayBuffer} verticesBuffer Vertices WebGL buffer
+ * @property {WebGLArrayBuffer} indicesBuffer Indices WebGL buffer
+ * @property {import("../../transform.js").Transform} renderInstructionsTransform Converts world space coordinates to screen space; applies to the rendering instructions
+ * @property {import("../../transform.js").Transform} verticesBufferTransform Converts world space coordinates to screen space; applies to the webgl vertices buffer
+ * @property {import("../../transform.js").Transform} invertVerticesBufferTransform Screen space to world space; applies to the webgl vertices buffer
+ * @property {number} verticesCount Amount of vertices from geometries in the batch.
+ * @property {number} ringsCount How many outer and inner rings in this batch.
+ */
+
+/**
+ * @typedef {Object} LineStringGeometryBatch A geometry batch specific to lines
+ * @property {Object<string, GeometryBatchItem>} entries Dictionary of all entries in the batch with associated computed values.
+ * One entry corresponds to one feature. Key is feature uid.
+ * @property {number} geometriesCount Amount of geometries in the batch.
+ * @property {Float32Array} renderInstructions Render instructions for polygons are structured like so:
+ * [ numberOfRings, numberOfVerticesInRing0, ..., numberOfVerticesInRingN, x0, y0, customAttr0, ..., xN, yN, customAttrN, numberOfRings,... ]
+ * @property {WebGLArrayBuffer} verticesBuffer Vertices WebGL buffer
+ * @property {WebGLArrayBuffer} indicesBuffer Indices WebGL buffer
+ * @property {import("../../transform.js").Transform} renderInstructionsTransform Converts world space coordinates to screen space; applies to the rendering instructions
+ * @property {import("../../transform.js").Transform} verticesBufferTransform Converts world space coordinates to screen space; applies to the webgl vertices buffer
+ * @property {import("../../transform.js").Transform} invertVerticesBufferTransform Screen space to world space; applies to the webgl vertices buffer
+ * @property {number} verticesCount Amount of vertices from geometries in the batch.
+ */
+
+/**
+ * @typedef {Object} PointGeometryBatch A geometry batch specific to points
+ * @property {Object<string, GeometryBatchItem>} entries Dictionary of all entries in the batch with associated computed values.
+ * One entry corresponds to one feature. Key is feature uid.
+ * @property {number} geometriesCount Amount of geometries in the batch.
+ * @property {Float32Array} renderInstructions Render instructions for polygons are structured like so:
+ * [ numberOfRings, numberOfVerticesInRing0, ..., numberOfVerticesInRingN, x0, y0, customAttr0, ..., xN, yN, customAttrN, numberOfRings,... ]
+ * @property {WebGLArrayBuffer} verticesBuffer Vertices WebGL buffer
+ * @property {WebGLArrayBuffer} indicesBuffer Indices WebGL buffer
+ * @property {import("../../transform.js").Transform} renderInstructionsTransform Converts world space coordinates to screen space; applies to the rendering instructions
+ * @property {import("../../transform.js").Transform} verticesBufferTransform Converts world space coordinates to screen space; applies to the webgl vertices buffer
+ * @property {import("../../transform.js").Transform} invertVerticesBufferTransform Screen space to world space; applies to the webgl vertices buffer
+ */
+
+/**
+ * @classdesc This class is used to group several geometries of various types together for faster rendering.
+ * Three inner batches are maintained for polygons, lines and points. Each time a feature is added, changed or removed
+ * from the batch, these inner batches are modified accordingly in order to keep them up-to-date.
+ *
+ * A feature can be present in several inner batches, for example a polygon geometry will be present in the polygon batch
+ * and its linar rings will be present in the line batch. Multi geometries are also broken down into individual geometries
+ * and added to the corresponding batches in a recursive manner.
+ *
+ * Corresponding {@link module:ol/render/webgl/BatchRenderer} instances are then used to generate the render instructions
+ * and WebGL buffers (vertices and indices) for each inner batches; render instructions are stored on the inner batches,
+ * alongside the transform used to convert world coords to screen coords at the time these instructions were generated.
+ * The resulting WebGL buffers are stored on the batches as well.
+ *
+ * An important aspect of geometry batches is that there is no guarantee that render instructions and WebGL buffers
+ * are synchronized, i.e. render instructions can describe a new state while WebGL buffers might not have been written yet.
+ * This is why two world-to-screen transforms are stored on each batch: one for the render instructions and one for
+ * the WebGL buffers.
+ */
+class MixedGeometryBatch {
+  constructor() {
+    /**
+     * @type {PolygonGeometryBatch}
+     */
+    this.polygonBatch = {
+      entries: {},
+      geometriesCount: 0,
+      verticesCount: 0,
+      ringsCount: 0,
+      renderInstructions: new Float32Array(0),
+      verticesBuffer: new WebGLArrayBuffer(ARRAY_BUFFER, DYNAMIC_DRAW),
+      indicesBuffer: new WebGLArrayBuffer(ELEMENT_ARRAY_BUFFER, DYNAMIC_DRAW),
+      renderInstructionsTransform: createTransform(),
+      verticesBufferTransform: createTransform(),
+      invertVerticesBufferTransform: createTransform(),
+    };
+
+    /**
+     * @type {PointGeometryBatch}
+     */
+    this.pointBatch = {
+      entries: {},
+      geometriesCount: 0,
+      renderInstructions: new Float32Array(0),
+      verticesBuffer: new WebGLArrayBuffer(ARRAY_BUFFER, DYNAMIC_DRAW),
+      indicesBuffer: new WebGLArrayBuffer(ELEMENT_ARRAY_BUFFER, DYNAMIC_DRAW),
+      renderInstructionsTransform: createTransform(),
+      verticesBufferTransform: createTransform(),
+      invertVerticesBufferTransform: createTransform(),
+    };
+
+    /**
+     * @type {LineStringGeometryBatch}
+     */
+    this.lineStringBatch = {
+      entries: {},
+      geometriesCount: 0,
+      verticesCount: 0,
+      renderInstructions: new Float32Array(0),
+      verticesBuffer: new WebGLArrayBuffer(ARRAY_BUFFER, DYNAMIC_DRAW),
+      indicesBuffer: new WebGLArrayBuffer(ELEMENT_ARRAY_BUFFER, DYNAMIC_DRAW),
+      renderInstructionsTransform: createTransform(),
+      verticesBufferTransform: createTransform(),
+      invertVerticesBufferTransform: createTransform(),
+    };
+  }
+
+  /**
+   * @param {Array<import("../../Feature").default>} features Array of features to add to the batch
+   */
+  addFeatures(features) {
+    for (let i = 0; i < features.length; i++) {
+      this.addFeature(features[i]);
+    }
+  }
+
+  /**
+   * @param {import("../../Feature").default} feature Feature to add to the batch
+   */
+  addFeature(feature) {
+    const geometry = feature.getGeometry();
+    if (!geometry) {
+      return;
+    }
+    this.addGeometry_(geometry, feature);
+  }
+
+  /**
+   * @param {import("../../Feature").default} feature Feature
+   * @return {GeometryBatchItem} Batch item added (or existing one)
+   * @private
+   */
+  addFeatureEntryInPointBatch_(feature) {
+    const uid = getUid(feature);
+    if (!(uid in this.pointBatch.entries)) {
+      this.pointBatch.entries[uid] = {
+        feature: feature,
+        flatCoordss: [],
+      };
+    }
+    return this.pointBatch.entries[uid];
+  }
+
+  /**
+   * @param {import("../../Feature").default} feature Feature
+   * @return {GeometryBatchItem} Batch item added (or existing one)
+   * @private
+   */
+  addFeatureEntryInLineStringBatch_(feature) {
+    const uid = getUid(feature);
+    if (!(uid in this.lineStringBatch.entries)) {
+      this.lineStringBatch.entries[uid] = {
+        feature: feature,
+        flatCoordss: [],
+        verticesCount: 0,
+      };
+    }
+    return this.lineStringBatch.entries[uid];
+  }
+
+  /**
+   * @param {import("../../Feature").default} feature Feature
+   * @return {GeometryBatchItem} Batch item added (or existing one)
+   * @private
+   */
+  addFeatureEntryInPolygonBatch_(feature) {
+    const uid = getUid(feature);
+    if (!(uid in this.polygonBatch.entries)) {
+      this.polygonBatch.entries[uid] = {
+        feature: feature,
+        flatCoordss: [],
+        verticesCount: 0,
+        ringsCount: 0,
+        ringsVerticesCounts: [],
+      };
+    }
+    return this.polygonBatch.entries[uid];
+  }
+
+  /**
+   * @param {import("../../Feature").default} feature Feature
+   * @private
+   */
+  clearFeatureEntryInPointBatch_(feature) {
+    const entry = this.pointBatch.entries[getUid(feature)];
+    if (!entry) {
+      return;
+    }
+    this.pointBatch.geometriesCount -= entry.flatCoordss.length;
+    delete this.pointBatch.entries[getUid(feature)];
+  }
+
+  /**
+   * @param {import("../../Feature").default} feature Feature
+   * @private
+   */
+  clearFeatureEntryInLineStringBatch_(feature) {
+    const entry = this.lineStringBatch.entries[getUid(feature)];
+    if (!entry) {
+      return;
+    }
+    this.lineStringBatch.verticesCount -= entry.verticesCount;
+    this.lineStringBatch.geometriesCount -= entry.flatCoordss.length;
+    delete this.lineStringBatch.entries[getUid(feature)];
+  }
+
+  /**
+   * @param {import("../../Feature").default} feature Feature
+   * @private
+   */
+  clearFeatureEntryInPolygonBatch_(feature) {
+    const entry = this.polygonBatch.entries[getUid(feature)];
+    if (!entry) {
+      return;
+    }
+    this.polygonBatch.verticesCount -= entry.verticesCount;
+    this.polygonBatch.ringsCount -= entry.ringsCount;
+    this.polygonBatch.geometriesCount -= entry.flatCoordss.length;
+    delete this.polygonBatch.entries[getUid(feature)];
+  }
+
+  /**
+   * @param {import("../../geom").Geometry} geometry Geometry
+   * @param {import("../../Feature").default} feature Feature
+   * @private
+   */
+  addGeometry_(geometry, feature) {
+    const type = geometry.getType();
+    let flatCoords;
+    let verticesCount;
+    let batchEntry;
+    switch (type) {
+      case 'GeometryCollection':
+        /** @type {import("../../geom").GeometryCollection} */ (geometry)
+          .getGeometries()
+          .map((geom) => this.addGeometry_(geom, feature));
+        break;
+      case 'MultiPolygon':
+        /** @type {import("../../geom").MultiPolygon} */ (geometry)
+          .getPolygons()
+          .map((polygon) => this.addGeometry_(polygon, feature));
+        break;
+      case 'MultiLineString':
+        /** @type {import("../../geom").MultiLineString} */ (geometry)
+          .getLineStrings()
+          .map((line) => this.addGeometry_(line, feature));
+        break;
+      case 'MultiPoint':
+        /** @type {import("../../geom").MultiPoint} */ (geometry)
+          .getPoints()
+          .map((point) => this.addGeometry_(point, feature));
+        break;
+      case 'Polygon':
+        const polygonGeom = /** @type {import("../../geom").Polygon} */ (
+          geometry
+        );
+        batchEntry = this.addFeatureEntryInPolygonBatch_(feature);
+        flatCoords = polygonGeom.getFlatCoordinates();
+        verticesCount = flatCoords.length / 2;
+        const ringsCount = polygonGeom.getLinearRingCount();
+        const ringsVerticesCount = polygonGeom
+          .getEnds()
+          .map((end, ind, arr) =>
+            ind > 0 ? (end - arr[ind - 1]) / 2 : end / 2
+          );
+        this.polygonBatch.verticesCount += verticesCount;
+        this.polygonBatch.ringsCount += ringsCount;
+        this.polygonBatch.geometriesCount++;
+        batchEntry.flatCoordss.push(flatCoords);
+        batchEntry.ringsVerticesCounts.push(ringsVerticesCount);
+        batchEntry.verticesCount += verticesCount;
+        batchEntry.ringsCount += ringsCount;
+        polygonGeom
+          .getLinearRings()
+          .map((ring) => this.addGeometry_(ring, feature));
+        break;
+      case 'Point':
+        const pointGeom = /** @type {import("../../geom").Point} */ (geometry);
+        batchEntry = this.addFeatureEntryInPointBatch_(feature);
+        flatCoords = pointGeom.getFlatCoordinates();
+        this.pointBatch.geometriesCount++;
+        batchEntry.flatCoordss.push(flatCoords);
+        break;
+      case 'LineString':
+      case 'LinearRing':
+        const lineGeom = /** @type {import("../../geom").LineString} */ (
+          geometry
+        );
+        batchEntry = this.addFeatureEntryInLineStringBatch_(feature);
+        flatCoords = lineGeom.getFlatCoordinates();
+        verticesCount = flatCoords.length / 2;
+        this.lineStringBatch.verticesCount += verticesCount;
+        this.lineStringBatch.geometriesCount++;
+        batchEntry.flatCoordss.push(flatCoords);
+        batchEntry.verticesCount += verticesCount;
+        break;
+      default:
+      // pass
+    }
+  }
+
+  /**
+   * @param {import("../../Feature").default} feature Feature
+   */
+  changeFeature(feature) {
+    this.clearFeatureEntryInPointBatch_(feature);
+    this.clearFeatureEntryInPolygonBatch_(feature);
+    this.clearFeatureEntryInLineStringBatch_(feature);
+    const geometry = feature.getGeometry();
+    if (!geometry) {
+      return;
+    }
+    this.addGeometry_(geometry, feature);
+  }
+
+  /**
+   * @param {import("../../Feature").default} feature Feature
+   */
+  removeFeature(feature) {
+    this.clearFeatureEntryInPointBatch_(feature);
+    this.clearFeatureEntryInPolygonBatch_(feature);
+    this.clearFeatureEntryInLineStringBatch_(feature);
+  }
+
+  clear() {
+    this.polygonBatch.entries = {};
+    this.polygonBatch.geometriesCount = 0;
+    this.polygonBatch.verticesCount = 0;
+    this.polygonBatch.ringsCount = 0;
+    this.lineStringBatch.entries = {};
+    this.lineStringBatch.geometriesCount = 0;
+    this.lineStringBatch.verticesCount = 0;
+    this.pointBatch.entries = {};
+    this.pointBatch.geometriesCount = 0;
+  }
+}
+
+export default MixedGeometryBatch;