ol 7.3.0 → 7.3.1-dev

package/render/webgl/MixedGeometryBatch.js

@@ -1,14 +1,22 @@
 /**
  * @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';
+import {linearRingIsClockwise} from '../../geom/flat/orient.js';
+
+/**
+ * @typedef {import("../../render/Feature").default} RenderFeature
+ */
+/**
+ * @typedef {import("../../Feature").default} Feature
+ */
+/**
+ * @typedef {import("../../geom/Geometry.js").Type} GeometryType
+ */
 
 /**
  * @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 {Feature|RenderFeature} 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
@@ -24,13 +32,6 @@ import {getUid} from '../../util.js';
  * @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.
  */
@@ -40,13 +41,6 @@ import {getUid} from '../../util.js';
  * @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.
  */
 
@@ -55,13 +49,6 @@ import {getUid} from '../../util.js';
  * @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
  */
 
 /**
@@ -70,7 +57,7 @@ import {getUid} from '../../util.js';
  * 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 its linear 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
@@ -93,12 +80,6 @@ class MixedGeometryBatch {
       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(),
     };
 
     /**
@@ -107,12 +88,6 @@ class MixedGeometryBatch {
     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(),
     };
 
     /**
@@ -122,17 +97,11 @@ class MixedGeometryBatch {
       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
+   * @param {Array<Feature|RenderFeature>} features Array of features to add to the batch
    */
   addFeatures(features) {
     for (let i = 0; i < features.length; i++) {
@@ -141,7 +110,7 @@ class MixedGeometryBatch {
   }
 
   /**
-   * @param {import("../../Feature").default} feature Feature to add to the batch
+   * @param {Feature|RenderFeature} feature Feature to add to the batch
    */
   addFeature(feature) {
     const geometry = feature.getGeometry();
@@ -152,59 +121,7 @@ class MixedGeometryBatch {
   }
 
   /**
-   * @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
+   * @param {Feature|RenderFeature} feature Feature
    * @private
    */
   clearFeatureEntryInPointBatch_(feature) {
@@ -217,7 +134,7 @@ class MixedGeometryBatch {
   }
 
   /**
-   * @param {import("../../Feature").default} feature Feature
+   * @param {Feature|RenderFeature} feature Feature
    * @private
    */
   clearFeatureEntryInLineStringBatch_(feature) {
@@ -231,7 +148,7 @@ class MixedGeometryBatch {
   }
 
   /**
-   * @param {import("../../Feature").default} feature Feature
+   * @param {Feature|RenderFeature} feature Feature
    * @private
    */
   clearFeatureEntryInPolygonBatch_(feature) {
@@ -246,79 +163,245 @@ class MixedGeometryBatch {
   }
 
   /**
-   * @param {import("../../geom").Geometry} geometry Geometry
-   * @param {import("../../Feature").default} feature Feature
+   * @param {import("../../geom").Geometry|RenderFeature} geometry Geometry
+   * @param {Feature|RenderFeature} 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));
+        const geometries =
+          /** @type {import("../../geom").GeometryCollection} */ (
+            geometry
+          ).getGeometriesArray();
+        for (const geometry of geometries) {
+          this.addGeometry_(geometry, feature);
+        }
         break;
       case 'MultiPolygon':
-        /** @type {import("../../geom").MultiPolygon} */ (geometry)
-          .getPolygons()
-          .map((polygon) => this.addGeometry_(polygon, feature));
+        const multiPolygonGeom =
+          /** @type {import("../../geom").MultiPolygon|RenderFeature} */ (
+            geometry
+          );
+        this.addCoordinates_(
+          type,
+          multiPolygonGeom.getFlatCoordinates(),
+          multiPolygonGeom.getEndss(),
+          feature,
+          getUid(feature)
+        );
         break;
       case 'MultiLineString':
-        /** @type {import("../../geom").MultiLineString} */ (geometry)
-          .getLineStrings()
-          .map((line) => this.addGeometry_(line, feature));
+        const multiLineGeom =
+          /** @type {import("../../geom").MultiLineString|RenderFeature} */ (
+            geometry
+          );
+        this.addCoordinates_(
+          type,
+          multiLineGeom.getFlatCoordinates(),
+          multiLineGeom.getEnds(),
+          feature,
+          getUid(feature)
+        );
         break;
       case 'MultiPoint':
-        /** @type {import("../../geom").MultiPoint} */ (geometry)
-          .getPoints()
-          .map((point) => this.addGeometry_(point, feature));
+        const multiPointGeom =
+          /** @type {import("../../geom").MultiPoint|RenderFeature} */ (
+            geometry
+          );
+        this.addCoordinates_(
+          type,
+          multiPointGeom.getFlatCoordinates(),
+          null,
+          feature,
+          getUid(feature)
+        );
         break;
       case 'Polygon':
-        const polygonGeom = /** @type {import("../../geom").Polygon} */ (
+        const polygonGeom =
+          /** @type {import("../../geom").Polygon|RenderFeature} */ (geometry);
+        this.addCoordinates_(
+          type,
+          polygonGeom.getFlatCoordinates(),
+          polygonGeom.getEnds(),
+          feature,
+          getUid(feature)
+        );
+        break;
+      case 'Point':
+        const pointGeom = /** @type {import("../../geom").Point} */ (geometry);
+        this.addCoordinates_(
+          type,
+          pointGeom.getFlatCoordinates(),
+          null,
+          feature,
+          getUid(feature)
+        );
+        break;
+      case 'LineString':
+      case 'LinearRing':
+        const lineGeom = /** @type {import("../../geom").LineString} */ (
           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.addCoordinates_(
+          type,
+          lineGeom.getFlatCoordinates(),
+          null,
+          feature,
+          getUid(feature)
+        );
+        break;
+      default:
+      // pass
+    }
+  }
+
+  /**
+   * @param {GeometryType} type Geometry type
+   * @param {Array<number>} flatCoords Flat coordinates
+   * @param {Array<number> | Array<Array<number>> | null} ends Coordinate ends
+   * @param {Feature|RenderFeature} feature Feature
+   * @param {string} featureUid Feature uid
+   * @private
+   */
+  addCoordinates_(type, flatCoords, ends, feature, featureUid) {
+    /** @type {number} */
+    let verticesCount;
+    switch (type) {
+      case 'MultiPolygon':
+        const multiPolygonEndss = /** @type {Array<Array<number>>} */ (ends);
+        for (let i = 0, ii = multiPolygonEndss.length; i < ii; i++) {
+          let polygonEnds = multiPolygonEndss[i];
+          const prevPolygonEnds = i > 0 ? multiPolygonEndss[i - 1] : null;
+          const startIndex = prevPolygonEnds
+            ? prevPolygonEnds[prevPolygonEnds.length - 1]
+            : 0;
+          const endIndex = polygonEnds[polygonEnds.length - 1];
+          const polygonCoords = flatCoords.slice(startIndex, endIndex);
+          polygonEnds =
+            startIndex > 0
+              ? polygonEnds.map((end) => end - startIndex)
+              : polygonEnds;
+          this.addCoordinates_(
+            'Polygon',
+            polygonCoords,
+            polygonEnds,
+            feature,
+            featureUid
           );
+        }
+        break;
+      case 'MultiLineString':
+        const multiLineEnds = /** @type {Array<number>} */ (ends);
+        for (let i = 0, ii = multiLineEnds.length; i < ii; i++) {
+          const startIndex = i > 0 ? multiLineEnds[i - 1] : 0;
+          const ringCoords = flatCoords.slice(startIndex, multiLineEnds[i]);
+          this.addCoordinates_(
+            'LinearRing',
+            ringCoords,
+            null,
+            feature,
+            featureUid
+          );
+        }
+        break;
+      case 'MultiPoint':
+        for (let i = 0, ii = flatCoords.length; i < ii; i += 2) {
+          this.addCoordinates_(
+            'Point',
+            flatCoords.slice(i, i + 2),
+            null,
+            feature,
+            featureUid
+          );
+        }
+        break;
+      case 'Polygon':
+        const polygonEnds = /** @type {Array<number>} */ (ends);
+        // first look for a CW ring; if so, handle it and following rings as another polygon
+        for (let i = 1, ii = polygonEnds.length; i < ii; i++) {
+          const ringStartIndex = polygonEnds[i - 1];
+          if (
+            i > 0 &&
+            linearRingIsClockwise(flatCoords, ringStartIndex, polygonEnds[i], 2)
+          ) {
+            this.addCoordinates_(
+              'Polygon',
+              flatCoords.slice(0, ringStartIndex),
+              polygonEnds.slice(0, i),
+              feature,
+              featureUid
+            );
+            this.addCoordinates_(
+              'Polygon',
+              flatCoords.slice(ringStartIndex),
+              polygonEnds.slice(i).map((end) => end - polygonEnds[i - 1]),
+              feature,
+              featureUid
+            );
+            return;
+          }
+        }
+        if (!this.polygonBatch.entries[featureUid]) {
+          this.polygonBatch.entries[featureUid] = {
+            feature: feature,
+            flatCoordss: [],
+            verticesCount: 0,
+            ringsCount: 0,
+            ringsVerticesCounts: [],
+          };
+        }
+        verticesCount = flatCoords.length / 2;
+        const ringsCount = ends.length;
+        const ringsVerticesCount = ends.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));
+        this.polygonBatch.entries[featureUid].flatCoordss.push(flatCoords);
+        this.polygonBatch.entries[featureUid].ringsVerticesCounts.push(
+          ringsVerticesCount
+        );
+        this.polygonBatch.entries[featureUid].verticesCount += verticesCount;
+        this.polygonBatch.entries[featureUid].ringsCount += ringsCount;
+        for (let i = 0, ii = polygonEnds.length; i < ii; i++) {
+          const startIndex = i > 0 ? polygonEnds[i - 1] : 0;
+          const ringCoords = flatCoords.slice(startIndex, polygonEnds[i]);
+          this.addCoordinates_(
+            'LinearRing',
+            ringCoords,
+            null,
+            feature,
+            featureUid
+          );
+        }
         break;
       case 'Point':
-        const pointGeom = /** @type {import("../../geom").Point} */ (geometry);
-        batchEntry = this.addFeatureEntryInPointBatch_(feature);
-        flatCoords = pointGeom.getFlatCoordinates();
+        if (!this.pointBatch.entries[featureUid]) {
+          this.pointBatch.entries[featureUid] = {
+            feature: feature,
+            flatCoordss: [],
+          };
+        }
         this.pointBatch.geometriesCount++;
-        batchEntry.flatCoordss.push(flatCoords);
+        this.pointBatch.entries[featureUid].flatCoordss.push(flatCoords);
         break;
       case 'LineString':
       case 'LinearRing':
-        const lineGeom = /** @type {import("../../geom").LineString} */ (
-          geometry
-        );
-        batchEntry = this.addFeatureEntryInLineStringBatch_(feature);
-        flatCoords = lineGeom.getFlatCoordinates();
+        if (!this.lineStringBatch.entries[featureUid]) {
+          this.lineStringBatch.entries[featureUid] = {
+            feature: feature,
+            flatCoordss: [],
+            verticesCount: 0,
+          };
+        }
         verticesCount = flatCoords.length / 2;
         this.lineStringBatch.verticesCount += verticesCount;
         this.lineStringBatch.geometriesCount++;
-        batchEntry.flatCoordss.push(flatCoords);
-        batchEntry.verticesCount += verticesCount;
+        this.lineStringBatch.entries[featureUid].flatCoordss.push(flatCoords);
+        this.lineStringBatch.entries[featureUid].verticesCount += verticesCount;
         break;
       default:
       // pass
@@ -326,7 +409,7 @@ class MixedGeometryBatch {
   }
 
   /**
-   * @param {import("../../Feature").default} feature Feature
+   * @param {Feature|RenderFeature} feature Feature
    */
   changeFeature(feature) {
     this.clearFeatureEntryInPointBatch_(feature);
@@ -340,7 +423,7 @@ class MixedGeometryBatch {
   }
 
   /**
-   * @param {import("../../Feature").default} feature Feature
+   * @param {Feature|RenderFeature} feature Feature
    */
   removeFeature(feature) {
     this.clearFeatureEntryInPointBatch_(feature);