ol 8.1.1-dev.1694687206621 → 8.1.1-dev.1694712969002

package/render/webgl/MixedGeometryBatch.d.ts

@@ -1,5 +1,5 @@
 export default MixedGeometryBatch;
-export type Feature = import("../../Feature").default;
+export type Feature = import("../../Feature.js").default;
 export type GeometryType = import("../../geom/Geometry.js").Type;
 /**
  * Object that holds a reference to a feature as well as the raw coordinates of its various geometries
@@ -25,6 +25,10 @@ export type GeometryBatchItem = {
      * Array of vertices counts in each ring for each geometry; only defined for polygons batches
      */
     ringsVerticesCounts?: number[][] | undefined;
+    /**
+     * The reference in the global batch (used for hit detection)
+     */
+    ref?: number | undefined;
 };
 export type GeometryBatch = PointGeometryBatch | LineStringGeometryBatch | PolygonGeometryBatch;
 /**
@@ -88,7 +92,7 @@ export type PointGeometryBatch = {
     geometriesCount: number;
 };
 /**
- * @typedef {import("../../Feature").default} Feature
+ * @typedef {import("../../Feature.js").default} Feature
  */
 /**
  * @typedef {import("../../geom/Geometry.js").Type} GeometryType
@@ -100,6 +104,7 @@ export type PointGeometryBatch = {
  * @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
+ * @property {number} [ref] The reference in the global batch (used for hit detection)
  */
 /**
  * @typedef {PointGeometryBatch|LineStringGeometryBatch|PolygonGeometryBatch} GeometryBatch
@@ -145,6 +150,26 @@ export type PointGeometryBatch = {
  * the WebGL buffers.
  */
 declare class MixedGeometryBatch {
+    globalCounter_: number;
+    /**
+     * Refs are used as keys for hit detection.
+     * @type {Map<number, Feature|RenderFeature>}
+     * @private
+     */
+    private refToFeature_;
+    /**
+     * Features are split in "entries", which are individual geometries. We use the following map to share a single ref for all those entries.
+     * @type {Map<string, number>}
+     * @private
+     */
+    private uidToRef_;
+    /**
+     * The precision in WebGL shaders is limited.
+     * To keep the refs as small as possible we maintain an array of returned references.
+     * @type {Array<number>}
+     * @private
+     */
+    private freeGlobalRef_;
     /**
      * @type {PolygonGeometryBatch}
      */
@@ -169,21 +194,24 @@ declare class MixedGeometryBatch {
     addFeature(feature: Feature | RenderFeature, projectionTransform?: import("../../proj.js").TransformFunction | undefined): void;
     /**
      * @param {Feature|RenderFeature} feature Feature
+     * @return {GeometryBatchItem|void} the cleared entry
      * @private
      */
     private clearFeatureEntryInPointBatch_;
     /**
      * @param {Feature|RenderFeature} feature Feature
+     * @return {GeometryBatchItem|void} the cleared entry
      * @private
      */
     private clearFeatureEntryInLineStringBatch_;
     /**
      * @param {Feature|RenderFeature} feature Feature
+     * @return {GeometryBatchItem|void} the cleared entry
      * @private
      */
     private clearFeatureEntryInPolygonBatch_;
     /**
-     * @param {import("../../geom").Geometry|RenderFeature} geometry Geometry
+     * @param {import("../../geom.js").Geometry|RenderFeature} geometry Geometry
      * @param {Feature|RenderFeature} feature Feature
      * @private
      */
@@ -198,6 +226,20 @@ declare class MixedGeometryBatch {
      * @private
      */
     private addCoordinates_;
+    /**
+     * @param {string} featureUid Feature uid
+     * @param {GeometryBatchItem} entry The entry to add
+     * @return {GeometryBatchItem} the added entry
+     * @private
+     */
+    private addRefToEntry_;
+    /**
+     * Return a ref to the pool of available refs.
+     * @param {number} ref the ref to return
+     * @param {string} featureUid the feature uid
+     * @private
+     */
+    private returnRef_;
     /**
      * @param {Feature|RenderFeature} feature Feature
      */
@@ -207,6 +249,12 @@ declare class MixedGeometryBatch {
      */
     removeFeature(feature: Feature | RenderFeature): void;
     clear(): void;
+    /**
+     * Resolve the feature associated to a ref.
+     * @param {number} ref Hit detected ref
+     * @return {Feature|RenderFeature} feature
+     */
+    getFeatureFromRef(ref: number): Feature | RenderFeature;
 }
 import RenderFeature from '../../render/Feature.js';
 //# sourceMappingURL=MixedGeometryBatch.d.ts.map

package/render/webgl/MixedGeometryBatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MixedGeometryBatch.d.ts","sourceRoot":"","sources":["MixedGeometryBatch.js"],"names":[],"mappings":";sBAQa,OAAO,eAAe,EAAE,OAAO;2BAG/B,OAAO,wBAAwB,EAAE,IAAI;;;;;;;;aAKpC,OAAO,GAAC,aAAa;;;;iBACrB,MAAM,MAAM,MAAM,CAAC,CAAC;;;;;;;;;;;;;;4BAOrB,kBAAkB,GAAC,uBAAuB,GAAC,oBAAoB;;;;;;;;;;YAKvD,MAAM,GAAE,iBAAiB;;;;;qBAEhC,MAAM;;;;mBACN,MAAM;;;;gBACN,MAAM;;;;;;;;;;;YAKC,MAAM,GAAE,iBAAiB;;;;;qBAEhC,MAAM;;;;mBACN,MAAM;;;;;;;;;;;YAKC,MAAM,GAAE,iBAAiB;;;;;qBAEhC,MAAM;;AAzCpB;;GAEG;AACH;;GAEG;AAEH;;;;;;;GAOG;AAEH;;GAEG;AAEH;;;;;;;GAOG;AAEH;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAEI;;OAEG;IACH,cAFU,oBAAoB,CAO7B;IAED;;OAEG;IACH,YAFU,kBAAkB,CAK3B;IAED;;OAEG;IACH,iBAFU,uBAAuB,CAMhC;IAGH;;;OAGG;IACH,sBAHW,MAAM,OAAO,GAAC,aAAa,CAAC,qFAOtC;IAED;;;OAGG;IACH,oBAHW,OAAO,GAAC,aAAa,qFAa/B;IAED;;;OAGG;IACH,uCAOC;IAED;;;OAGG;IACH,4CAQC;IAED;;;OAGG;IACH,yCASC;IAED;;;;OAIG;IACH,qBA4FC;IAED;;;;;;;;OAQG;IACH,wBAwIC;IAED;;OAEG;IACH,uBAFW,OAAO,GAAC,aAAa,QAW/B;IAED;;OAEG;IACH,uBAFW,OAAO,GAAC,aAAa,QAM/B;IAED,cAUC;CACF;0BA7byB,yBAAyB"}
+{"version":3,"file":"MixedGeometryBatch.d.ts","sourceRoot":"","sources":["MixedGeometryBatch.js"],"names":[],"mappings":";sBAQa,OAAO,kBAAkB,EAAE,OAAO;2BAGlC,OAAO,wBAAwB,EAAE,IAAI;;;;;;;;aAKpC,OAAO,GAAC,aAAa;;;;iBACrB,MAAM,MAAM,MAAM,CAAC,CAAC;;;;;;;;;;;;;;;;;;4BAQrB,kBAAkB,GAAC,uBAAuB,GAAC,oBAAoB;;;;;;;;;;YAKvD,MAAM,GAAE,iBAAiB;;;;;qBAEhC,MAAM;;;;mBACN,MAAM;;;;gBACN,MAAM;;;;;;;;;;;YAKC,MAAM,GAAE,iBAAiB;;;;;qBAEhC,MAAM;;;;mBACN,MAAM;;;;;;;;;;;YAKC,MAAM,GAAE,iBAAiB;;;;;qBAEhC,MAAM;;AA1CpB;;GAEG;AACH;;GAEG;AAEH;;;;;;;;GAQG;AAEH;;GAEG;AAEH;;;;;;;GAOG;AAEH;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAEI,uBAAuB;IACvB;;;;OAIG;IACH,sBAA8B;IAE9B;;;;OAIG;IACH,kBAA0B;IAE1B;;;;;OAKG;IACH,uBAAwB;IAExB;;OAEG;IACH,cAFU,oBAAoB,CAO7B;IAED;;OAEG;IACH,YAFU,kBAAkB,CAK3B;IAED;;OAEG;IACH,iBAFU,uBAAuB,CAMhC;IAGH;;;OAGG;IACH,sBAHW,MAAM,OAAO,GAAC,aAAa,CAAC,qFAOtC;IAED;;;OAGG;IACH,oBAHW,OAAO,GAAC,aAAa,qFAa/B;IAED;;;;OAIG;IACH,uCAQC;IAED;;;;OAIG;IACH,4CASC;IAED;;;;OAIG;IACH,yCAUC;IAED;;;;OAIG;IACH,qBAuGC;IAED;;;;;;;;OAQG;IACH,wBAoJC;IAED;;;;;OAKG;IACH,uBAYC;IAED;;;;;OAKG;IACH,mBAOC;IAED;;OAEG;IACH,uBAFW,OAAO,GAAC,aAAa,QAS/B;IAED;;OAEG;IACH,uBAFW,OAAO,GAAC,aAAa,QAU/B;IAED,cAcC;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACL,OAAO,GAAC,aAAa,CAIhC;CACF;0BApiByB,yBAAyB"}

package/render/webgl/MixedGeometryBatch.js

@@ -6,7 +6,7 @@ import {getUid} from '../../util.js';
 import {inflateEnds} from '../../geom/flat/orient.js';
 
 /**
- * @typedef {import("../../Feature").default} Feature
+ * @typedef {import("../../Feature.js").default} Feature
  */
 /**
  * @typedef {import("../../geom/Geometry.js").Type} GeometryType
@@ -19,6 +19,7 @@ import {inflateEnds} from '../../geom/flat/orient.js';
  * @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
+ * @property {number} [ref] The reference in the global batch (used for hit detection)
  */
 
 /**
@@ -70,6 +71,29 @@ import {inflateEnds} from '../../geom/flat/orient.js';
  */
 class MixedGeometryBatch {
   constructor() {
+    this.globalCounter_ = 0;
+    /**
+     * Refs are used as keys for hit detection.
+     * @type {Map<number, Feature|RenderFeature>}
+     * @private
+     */
+    this.refToFeature_ = new Map();
+
+    /**
+     * Features are split in "entries", which are individual geometries. We use the following map to share a single ref for all those entries.
+     * @type {Map<string, number>}
+     * @private
+     */
+    this.uidToRef_ = new Map();
+
+    /**
+     * The precision in WebGL shaders is limited.
+     * To keep the refs as small as possible we maintain an array of returned references.
+     * @type {Array<number>}
+     * @private
+     */
+    this.freeGlobalRef_ = [];
+
     /**
      * @type {PolygonGeometryBatch}
      */
@@ -126,6 +150,7 @@ class MixedGeometryBatch {
 
   /**
    * @param {Feature|RenderFeature} feature Feature
+   * @return {GeometryBatchItem|void} the cleared entry
    * @private
    */
   clearFeatureEntryInPointBatch_(feature) {
@@ -135,10 +160,12 @@ class MixedGeometryBatch {
     }
     this.pointBatch.geometriesCount -= entry.flatCoordss.length;
     delete this.pointBatch.entries[getUid(feature)];
+    return entry;
   }
 
   /**
    * @param {Feature|RenderFeature} feature Feature
+   * @return {GeometryBatchItem|void} the cleared entry
    * @private
    */
   clearFeatureEntryInLineStringBatch_(feature) {
@@ -149,10 +176,12 @@ class MixedGeometryBatch {
     this.lineStringBatch.verticesCount -= entry.verticesCount;
     this.lineStringBatch.geometriesCount -= entry.flatCoordss.length;
     delete this.lineStringBatch.entries[getUid(feature)];
+    return entry;
   }
 
   /**
    * @param {Feature|RenderFeature} feature Feature
+   * @return {GeometryBatchItem|void} the cleared entry
    * @private
    */
   clearFeatureEntryInPolygonBatch_(feature) {
@@ -164,28 +193,30 @@ class MixedGeometryBatch {
     this.polygonBatch.ringsCount -= entry.ringsCount;
     this.polygonBatch.geometriesCount -= entry.flatCoordss.length;
     delete this.polygonBatch.entries[getUid(feature)];
+    return entry;
   }
 
   /**
-   * @param {import("../../geom").Geometry|RenderFeature} geometry Geometry
+   * @param {import("../../geom.js").Geometry|RenderFeature} geometry Geometry
    * @param {Feature|RenderFeature} feature Feature
    * @private
    */
   addGeometry_(geometry, feature) {
     const type = geometry.getType();
     switch (type) {
-      case 'GeometryCollection':
+      case 'GeometryCollection': {
         const geometries =
-          /** @type {import("../../geom").GeometryCollection} */ (
+          /** @type {import("../../geom.js").GeometryCollection} */ (
             geometry
           ).getGeometriesArray();
         for (const geometry of geometries) {
           this.addGeometry_(geometry, feature);
         }
         break;
-      case 'MultiPolygon':
+      }
+      case 'MultiPolygon': {
         const multiPolygonGeom =
-          /** @type {import("../../geom").MultiPolygon} */ (geometry);
+          /** @type {import("../../geom.js").MultiPolygon} */ (geometry);
         this.addCoordinates_(
           type,
           multiPolygonGeom.getFlatCoordinates(),
@@ -195,9 +226,10 @@ class MixedGeometryBatch {
           multiPolygonGeom.getStride()
         );
         break;
-      case 'MultiLineString':
+      }
+      case 'MultiLineString': {
         const multiLineGeom =
-          /** @type {import("../../geom").MultiLineString|RenderFeature} */ (
+          /** @type {import("../../geom.js").MultiLineString|RenderFeature} */ (
             geometry
           );
         this.addCoordinates_(
@@ -209,9 +241,10 @@ class MixedGeometryBatch {
           multiLineGeom.getStride()
         );
         break;
-      case 'MultiPoint':
+      }
+      case 'MultiPoint': {
         const multiPointGeom =
-          /** @type {import("../../geom").MultiPoint|RenderFeature} */ (
+          /** @type {import("../../geom.js").MultiPoint|RenderFeature} */ (
             geometry
           );
         this.addCoordinates_(
@@ -223,9 +256,12 @@ class MixedGeometryBatch {
           multiPointGeom.getStride()
         );
         break;
-      case 'Polygon':
+      }
+      case 'Polygon': {
         const polygonGeom =
-          /** @type {import("../../geom").Polygon|RenderFeature} */ (geometry);
+          /** @type {import("../../geom.js").Polygon|RenderFeature} */ (
+            geometry
+          );
         this.addCoordinates_(
           type,
           polygonGeom.getFlatCoordinates(),
@@ -235,8 +271,11 @@ class MixedGeometryBatch {
           polygonGeom.getStride()
         );
         break;
-      case 'Point':
-        const pointGeom = /** @type {import("../../geom").Point} */ (geometry);
+      }
+      case 'Point': {
+        const pointGeom = /** @type {import("../../geom.js").Point} */ (
+          geometry
+        );
         this.addCoordinates_(
           type,
           pointGeom.getFlatCoordinates(),
@@ -246,9 +285,10 @@ class MixedGeometryBatch {
           pointGeom.getStride()
         );
         break;
+      }
       case 'LineString':
-      case 'LinearRing':
-        const lineGeom = /** @type {import("../../geom").LineString} */ (
+      case 'LinearRing': {
+        const lineGeom = /** @type {import("../../geom.js").LineString} */ (
           geometry
         );
         this.addCoordinates_(
@@ -260,6 +300,7 @@ class MixedGeometryBatch {
           lineGeom.getStride()
         );
         break;
+      }
       default:
       // pass
     }
@@ -278,7 +319,7 @@ class MixedGeometryBatch {
     /** @type {number} */
     let verticesCount;
     switch (type) {
-      case 'MultiPolygon':
+      case 'MultiPolygon': {
         const multiPolygonEndss = /** @type {Array<Array<number>>} */ (ends);
         for (let i = 0, ii = multiPolygonEndss.length; i < ii; i++) {
           let polygonEnds = multiPolygonEndss[i];
@@ -301,12 +342,13 @@ class MixedGeometryBatch {
           );
         }
         break;
-      case 'MultiLineString':
+      }
+      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;
           this.addCoordinates_(
-            'LinearRing',
+            'LineString',
             flatCoords.slice(startIndex, multiLineEnds[i]),
             null,
             feature,
@@ -315,6 +357,7 @@ class MixedGeometryBatch {
           );
         }
         break;
+      }
       case 'MultiPoint':
         for (let i = 0, ii = flatCoords.length; i < ii; i += stride) {
           this.addCoordinates_(
@@ -327,7 +370,7 @@ class MixedGeometryBatch {
           );
         }
         break;
-      case 'Polygon':
+      case 'Polygon': {
         const polygonEnds = /** @type {Array<number>} */ (ends);
         if (feature instanceof RenderFeature) {
           const multiPolygonEnds = inflateEnds(flatCoords, polygonEnds);
@@ -344,13 +387,16 @@ class MixedGeometryBatch {
           }
         }
         if (!this.polygonBatch.entries[featureUid]) {
-          this.polygonBatch.entries[featureUid] = {
-            feature: feature,
-            flatCoordss: [],
-            verticesCount: 0,
-            ringsCount: 0,
-            ringsVerticesCounts: [],
-          };
+          this.polygonBatch.entries[featureUid] = this.addRefToEntry_(
+            featureUid,
+            {
+              feature: feature,
+              flatCoordss: [],
+              verticesCount: 0,
+              ringsCount: 0,
+              ringsVerticesCounts: [],
+            }
+          );
         }
         verticesCount = flatCoords.length / stride;
         const ringsCount = ends.length;
@@ -380,12 +426,16 @@ class MixedGeometryBatch {
           );
         }
         break;
+      }
       case 'Point':
         if (!this.pointBatch.entries[featureUid]) {
-          this.pointBatch.entries[featureUid] = {
-            feature: feature,
-            flatCoordss: [],
-          };
+          this.pointBatch.entries[featureUid] = this.addRefToEntry_(
+            featureUid,
+            {
+              feature: feature,
+              flatCoordss: [],
+            }
+          );
         }
         this.pointBatch.geometriesCount++;
         this.pointBatch.entries[featureUid].flatCoordss.push(flatCoords);
@@ -393,11 +443,14 @@ class MixedGeometryBatch {
       case 'LineString':
       case 'LinearRing':
         if (!this.lineStringBatch.entries[featureUid]) {
-          this.lineStringBatch.entries[featureUid] = {
-            feature: feature,
-            flatCoordss: [],
-            verticesCount: 0,
-          };
+          this.lineStringBatch.entries[featureUid] = this.addRefToEntry_(
+            featureUid,
+            {
+              feature: feature,
+              flatCoordss: [],
+              verticesCount: 0,
+            }
+          );
         }
         verticesCount = flatCoords.length / stride;
         this.lineStringBatch.verticesCount += verticesCount;
@@ -412,13 +465,46 @@ class MixedGeometryBatch {
     }
   }
 
+  /**
+   * @param {string} featureUid Feature uid
+   * @param {GeometryBatchItem} entry The entry to add
+   * @return {GeometryBatchItem} the added entry
+   * @private
+   */
+  addRefToEntry_(featureUid, entry) {
+    const currentRef = this.uidToRef_.get(featureUid);
+
+    // the ref starts at 1 to distinguish from white color (no feature)
+    const ref =
+      currentRef || this.freeGlobalRef_.pop() || ++this.globalCounter_;
+    entry.ref = ref;
+    if (!currentRef) {
+      this.refToFeature_.set(ref, entry.feature);
+      this.uidToRef_.set(featureUid, ref);
+    }
+    return entry;
+  }
+
+  /**
+   * Return a ref to the pool of available refs.
+   * @param {number} ref the ref to return
+   * @param {string} featureUid the feature uid
+   * @private
+   */
+  returnRef_(ref, featureUid) {
+    if (!ref) {
+      throw new Error('This feature has no ref: ' + featureUid);
+    }
+    this.refToFeature_.delete(ref);
+    this.uidToRef_.delete(featureUid);
+    this.freeGlobalRef_.push(ref);
+  }
+
   /**
    * @param {Feature|RenderFeature} feature Feature
    */
   changeFeature(feature) {
-    this.clearFeatureEntryInPointBatch_(feature);
-    this.clearFeatureEntryInPolygonBatch_(feature);
-    this.clearFeatureEntryInLineStringBatch_(feature);
+    this.removeFeature(feature);
     const geometry = feature.getGeometry();
     if (!geometry) {
       return;
@@ -430,9 +516,13 @@ class MixedGeometryBatch {
    * @param {Feature|RenderFeature} feature Feature
    */
   removeFeature(feature) {
-    this.clearFeatureEntryInPointBatch_(feature);
-    this.clearFeatureEntryInPolygonBatch_(feature);
-    this.clearFeatureEntryInLineStringBatch_(feature);
+    let entry;
+    entry = this.clearFeatureEntryInPointBatch_(feature) || entry;
+    entry = this.clearFeatureEntryInPolygonBatch_(feature) || entry;
+    entry = this.clearFeatureEntryInLineStringBatch_(feature) || entry;
+    if (entry) {
+      this.returnRef_(entry.ref, getUid(entry.feature));
+    }
   }
 
   clear() {
@@ -445,6 +535,19 @@ class MixedGeometryBatch {
     this.lineStringBatch.verticesCount = 0;
     this.pointBatch.entries = {};
     this.pointBatch.geometriesCount = 0;
+    this.globalCounter_ = 0;
+    this.freeGlobalRef_ = [];
+    this.refToFeature_.clear();
+    this.uidToRef_.clear();
+  }
+
+  /**
+   * Resolve the feature associated to a ref.
+   * @param {number} ref Hit detected ref
+   * @return {Feature|RenderFeature} feature
+   */
+  getFeatureFromRef(ref) {
+    return this.refToFeature_.get(ref);
   }
 }
 

package/render/webgl/VectorStyleRenderer.d.ts

@@ -27,7 +27,7 @@ export type AttributeDefinition = {
      * This callback computes the numerical value of the
      * attribute for a given feature.
      */
-    callback: (arg0: import("../../Feature").FeatureLike) => number | Array<number>;
+    callback: (this: import("./MixedGeometryBatch.js").GeometryBatchItem, arg1: import("../../Feature").FeatureLike) => number | Array<number>;
 };
 export type AttributeDefinitions = {
     [x: string]: AttributeDefinition;
@@ -113,7 +113,7 @@ export type VectorStyle = import('../../style/literal.js').LiteralStyle | StyleS
  * for each feature.
  * @property {number} [size] Amount of numerical values composing the attribute, either 1, 2, 3 or 4; in case size is > 1, the return value
  * of the callback should be an array; if unspecified, assumed to be a single float value
- * @property {function(import("../../Feature").FeatureLike):number|Array<number>} callback This callback computes the numerical value of the
+ * @property {function(this:import("./MixedGeometryBatch.js").GeometryBatchItem, import("../../Feature").FeatureLike):number|Array<number>} callback This callback computes the numerical value of the
  * attribute for a given feature.
  */
 /**
@@ -167,9 +167,11 @@ declare class VectorStyleRenderer {
     /**
      * @param {VectorStyle} styleOrShaders Literal style or custom shaders
      * @param {import('../../webgl/Helper.js').default} helper Helper
+     * @param {boolean} enableHitDetection Whether to enable the hit detection (needs compatible shader)
      */
-    constructor(styleOrShaders: VectorStyle, helper: import('../../webgl/Helper.js').default);
+    constructor(styleOrShaders: VectorStyle, helper: import('../../webgl/Helper.js').default, enableHitDetection: boolean);
     helper_: import("../../webgl/Helper.js").default;
+    hitDetectionEnabled_: boolean;
     /**
      * @type {boolean}
      * @private
@@ -194,9 +196,18 @@ declare class VectorStyleRenderer {
     symbolVertexShader_: string | undefined;
     symbolFragmentShader_: string | undefined;
     symbolProgram_: WebGLProgram | undefined;
-    customAttributes_: {
+    customAttributes_: ({
+        hitColor: {
+            callback(): number[];
+            size: number;
+        };
+    } & {
         [x: string]: AttributeDefinition;
-    } | undefined;
+    }) | ({
+        hitColor?: undefined;
+    } & {
+        [x: string]: AttributeDefinition;
+    });
     uniforms_: {
         [x: string]: import("../../webgl/Helper.js").UniformValue;
     } | undefined;

package/render/webgl/VectorStyleRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VectorStyleRenderer.d.ts","sourceRoot":"","sources":["VectorStyleRenderer.js"],"names":[],"mappings":";;;;yBA0BU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;qBAiBO,OAAO,eAAe,EAAE,WAAW,KAAE,MAAM,GAAC,MAAM,MAAM,CAAC;;;QAK5D,MAAM,GAAE,mBAAmB;;;QAC3B,MAAM,GAAE,OAAO,oBAAoB,EAAE,YAAY;;;;;;oBAKvD,MAAM,gBAAgB,CAAC;;;;uBACvB,MAAM,gBAAgB,CAAC;;;;kBACvB,MAAM,gBAAgB,CAAC;;;;6BACvB,OAAO,oBAAoB,EAAE,SAAS;;;;;;yBAKtC,YAAY,GAAC,IAAI;;;;4BACjB,YAAY,GAAC,IAAI;;;;uBACjB,YAAY,GAAC,IAAI;;;;;;;;;YAKjB,MAAM;;;;cACN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAcP,OAAO,wBAAwB,EAAE,YAAY,GAAC,YAAY;AA9CvE;;;;;;;GAOG;AAEH;;;GAGG;AAEH;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;;GAEG;AAEH;;;;;;;;;;;;GAYG;AACH;IACE;;;OAGG;IACH,4BAHW,WAAW,UACX,OAAO,uBAAuB,EAAE,OAAO,EAyJjD;IAtJC,iDAAqB;IAiCrB;;;OAGG;IACH,iBAAsC;IAEpC,sCAA4C;IAC5C,wCAAgD;IAChD,uCAGC;IAGH;;;OAGG;IACH,mBAA0C;IAExC,wCAAkE;IAClE,0CAAsE;IACtE,yCAGC;IAGH;;;OAGG;IACH,mBAA0C;IAExC,wCAAkE;IAClE,0CAAsE;IACtE,yCAGC;IAGH;;kBAA2C;IAC3C;;kBAAiC;IASjC;;;OAGG;IACH,+BAOC;IACD;;;OAGG;IACH,kCA2BC;IACD;;;OAGG;IACH,6BAYC;IAOH;;;;OAIG;IACH,+BAJW,OAAO,yBAAyB,EAAE,OAAO,aACzC,OAAO,oBAAoB,EAAE,SAAS,GACrC,QAAQ,YAAY,CAAC,CAqChC;IAED;;;;;OAKG;IACH,oCA+BC;IAED;;;;;;OAMG;IACH,gCAuEC;IAED;;;;;OAKG;IACH,gBAJW,YAAY,cACZ,OAAO,cAAc,EAAE,UAAU,2BACrB,IAAI,QA8B1B;IAED;;;;;;;;OAQG;IACH,wBAeC;CACF;6BA7d4B,uBAAuB"}
+{"version":3,"file":"VectorStyleRenderer.d.ts","sourceRoot":"","sources":["VectorStyleRenderer.js"],"names":[],"mappings":";;;;yBA4BU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;qBAiBY,OAAO,yBAAyB,EAAE,iBAAiB,QAAE,OAAO,eAAe,EAAE,WAAW,KAAE,MAAM,GAAC,MAAM,MAAM,CAAC;;;QAKtH,MAAM,GAAE,mBAAmB;;;QAC3B,MAAM,GAAE,OAAO,oBAAoB,EAAE,YAAY;;;;;;oBAKvD,MAAM,gBAAgB,CAAC;;;;uBACvB,MAAM,gBAAgB,CAAC;;;;kBACvB,MAAM,gBAAgB,CAAC;;;;6BACvB,OAAO,oBAAoB,EAAE,SAAS;;;;;;yBAKtC,YAAY,GAAC,IAAI;;;;4BACjB,YAAY,GAAC,IAAI;;;;uBACjB,YAAY,GAAC,IAAI;;;;;;;;;YAKjB,MAAM;;;;cACN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAcP,OAAO,wBAAwB,EAAE,YAAY,GAAC,YAAY;AA9CvE;;;;;;;GAOG;AAEH;;;GAGG;AAEH;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;;GAEG;AAEH;;;;;;;;;;;;GAYG;AACH;IACE;;;;OAIG;IACH,4BAJW,WAAW,UACX,OAAO,uBAAuB,EAAE,OAAO,sBACvC,OAAO,EAyKjB;IAtKC,iDAAqB;IAErB,8BAA8C;IAgC9C;;;OAGG;IACH,iBAAsC;IAEpC,sCAA4C;IAC5C,wCAAgD;IAChD,uCAGC;IAGH;;;OAGG;IACH,mBAA0C;IAExC,wCAAkE;IAClE,0CAAsE;IACtE,yCAGC;IAGH;;;OAGG;IACH,mBAA0C;IAExC,wCAAkE;IAClE,0CAAsE;IACtE,yCAGC;IAcH;;;;;;;;;;;OAIC;IACD;;kBAAiC;IASjC;;;OAGG;IACH,+BAOC;IACD;;;OAGG;IACH,kCA2BC;IACD;;;OAGG;IACH,6BAYC;IAOH;;;;OAIG;IACH,+BAJW,OAAO,yBAAyB,EAAE,OAAO,aACzC,OAAO,oBAAoB,EAAE,SAAS,GACrC,QAAQ,YAAY,CAAC,CAqChC;IAED;;;;;OAKG;IACH,oCA+BC;IAED;;;;;;OAMG;IACH,gCAuEC;IAED;;;;;OAKG;IACH,gBAJW,YAAY,cACZ,OAAO,cAAc,EAAE,UAAU,2BACrB,IAAI,QA8B1B;IAED;;;;;;;;OAQG;IACH,wBAkBC;CACF;6BAnf4B,uBAAuB"}

package/render/webgl/VectorStyleRenderer.js

@@ -5,6 +5,7 @@ import WebGLArrayBuffer from '../../webgl/Buffer.js';
 import {ARRAY_BUFFER, DYNAMIC_DRAW, ELEMENT_ARRAY_BUFFER} from '../../webgl.js';
 import {AttributeType} from '../../webgl/Helper.js';
 import {WebGLWorkerMessageType} from './constants.js';
+import {colorEncodeId} from './utils.js';
 import {
   create as createTransform,
   makeInverse as makeInverseTransform,
@@ -18,6 +19,7 @@ import {
 } from './renderinstructions.js';
 import {parseLiteralStyle} from '../../webgl/styleparser.js';
 
+const tmpColor = [];
 const WEBGL_WORKER = createWebGLWorker();
 let workerMessageCounter = 0;
 
@@ -41,7 +43,7 @@ export const Attributes = {
  * for each feature.
  * @property {number} [size] Amount of numerical values composing the attribute, either 1, 2, 3 or 4; in case size is > 1, the return value
  * of the callback should be an array; if unspecified, assumed to be a single float value
- * @property {function(import("../../Feature").FeatureLike):number|Array<number>} callback This callback computes the numerical value of the
+ * @property {function(this:import("./MixedGeometryBatch.js").GeometryBatchItem, import("../../Feature").FeatureLike):number|Array<number>} callback This callback computes the numerical value of the
  * attribute for a given feature.
  */
 
@@ -102,10 +104,12 @@ class VectorStyleRenderer {
   /**
    * @param {VectorStyle} styleOrShaders Literal style or custom shaders
    * @param {import('../../webgl/Helper.js').default} helper Helper
+   * @param {boolean} enableHitDetection Whether to enable the hit detection (needs compatible shader)
    */
-  constructor(styleOrShaders, helper) {
+  constructor(styleOrShaders, helper, enableHitDetection) {
     this.helper_ = helper;
 
+    this.hitDetectionEnabled_ = enableHitDetection;
     let shaders = /** @type {StyleShaders} */ (styleOrShaders);
 
     // TODO: improve discrimination between shaders and style
@@ -179,13 +183,28 @@ class VectorStyleRenderer {
       );
     }
 
-    this.customAttributes_ = shaders.attributes;
+    const hitDetectionAttributes = this.hitDetectionEnabled_
+      ? {
+          hitColor: {
+            callback() {
+              return colorEncodeId(this.ref, tmpColor);
+            },
+            size: 4,
+          },
+        }
+      : {};
+
+    this.customAttributes_ = Object.assign(
+      {},
+      hitDetectionAttributes,
+      shaders.attributes
+    );
     this.uniforms_ = shaders.uniforms;
 
-    const customAttributesDesc = Object.keys(this.customAttributes_).map(
-      (name) => ({
+    const customAttributesDesc = Object.entries(this.customAttributes_).map(
+      ([name, value]) => ({
         name: `a_${name}`,
-        size: this.customAttributes_[name].size || 1,
+        size: value.size || 1,
         type: AttributeType.FLOAT,
       })
     );
@@ -470,12 +489,15 @@ class VectorStyleRenderer {
     frameState,
     preRenderCallback
   ) {
+    const renderCount = indicesBuffer.getSize();
+    if (renderCount === 0) {
+      return;
+    }
     this.helper_.useProgram(program, frameState);
     this.helper_.bindBuffer(verticesBuffer);
     this.helper_.bindBuffer(indicesBuffer);
     this.helper_.enableAttributes(attributes);
     preRenderCallback();
-    const renderCount = indicesBuffer.getSize();
     this.helper_.drawElements(0, renderCount);
   }
 }

package/render/webgl/constants.d.ts

@@ -20,11 +20,11 @@ export type WebGLWorkerGenerateBuffersMessage = {
      */
     type: WebGLWorkerMessageType;
     /**
-     * Polygon render instructions raw binary buffer.
+     * render instructions raw binary buffer.
      */
     renderInstructions: ArrayBuffer;
     /**
-     * Amount of custom attributes count in the polygon render instructions.
+     * Amount of hit detection + custom attributes count in the render instructions.
      */
     customAttributesSize?: number | undefined;
     /**

package/render/webgl/constants.js

@@ -19,8 +19,8 @@ export const WebGLWorkerMessageType = {
  * Note that any addition properties present in the message *will* be sent back to the main thread.
  * @property {number} id Message id; will be used both in request and response as a means of identification
  * @property {WebGLWorkerMessageType} type Message type
- * @property {ArrayBuffer} renderInstructions Polygon render instructions raw binary buffer.
- * @property {number} [customAttributesSize] Amount of custom attributes count in the polygon render instructions.
+ * @property {ArrayBuffer} renderInstructions render instructions raw binary buffer.
+ * @property {number} [customAttributesSize] Amount of hit detection + custom attributes count in the render instructions.
  * @property {ArrayBuffer} [vertexBuffer] Vertices array raw binary buffer (sent by the worker).
  * @property {ArrayBuffer} [indexBuffer] Indices array raw binary buffer (sent by the worker).
  * @property {import("../../transform").Transform} [renderInstructionsTransform] Transformation matrix used to project the instructions coordinates