ol 7.4.1-dev.1686166152921 → 7.4.1-dev.1686296564657

package/renderer/webgl/PointsLayer.js

@@ -50,8 +50,7 @@ import {listen, unlistenByKey} from '../../events.js';
  * Please note that these can only be numerical values.
  * @property {string} vertexShader Vertex shader source, mandatory.
  * @property {string} fragmentShader Fragment shader source, mandatory.
- * @property {string} [hitVertexShader] Vertex shader source for hit detection rendering.
- * @property {string} [hitFragmentShader] Fragment shader source for hit detection rendering.
+ * @property {boolean} [hitDetectionEnabled] Whether shader is hit detection aware.
  * @property {Object<string,import("../../webgl/Helper").UniformValue>} [uniforms] Uniform definitions for the post process steps
  * Please note that `u_texture` is reserved for the main texture slot and `u_opacity` is reserved for the layer opacity.
  * @property {Array<import("./Layer").PostProcessesOptions>} [postProcesses] Post-processes definitions
@@ -138,7 +137,6 @@ class WebGLPointsLayerRenderer extends WebGLLayerRenderer {
     this.sourceRevision_ = -1;
 
     this.verticesBuffer_ = new WebGLArrayBuffer(ARRAY_BUFFER, DYNAMIC_DRAW);
-    this.hitVerticesBuffer_ = new WebGLArrayBuffer(ARRAY_BUFFER, DYNAMIC_DRAW);
     this.indicesBuffer_ = new WebGLArrayBuffer(
       ELEMENT_ARRAY_BUFFER,
       DYNAMIC_DRAW
@@ -164,24 +162,7 @@ class WebGLPointsLayerRenderer extends WebGLLayerRenderer {
      * @type {boolean}
      * @private
      */
-    this.hitDetectionEnabled_ =
-      options.hitFragmentShader && options.hitVertexShader ? true : false;
-
-    /**
-     * @private
-     */
-    this.hitVertexShader_ = options.hitVertexShader;
-
-    /**
-     * @private
-     */
-    this.hitFragmentShader_ = options.hitFragmentShader;
-
-    /**
-     * @type {WebGLProgram}
-     * @private
-     */
-    this.hitProgram_;
+    this.hitDetectionEnabled_ = options.hitDetectionEnabled ?? true;
 
     const customAttributes = options.attributes
       ? options.attributes.map(function (attribute) {
@@ -209,34 +190,21 @@ class WebGLPointsLayerRenderer extends WebGLLayerRenderer {
         size: 1,
         type: AttributeType.FLOAT,
       },
-    ].concat(customAttributes);
+    ];
 
-    /**
-     * A list of attributes used for hit detection.
-     * @type {Array<import('../../webgl/Helper.js').AttributeDescription>}
-     */
-    this.hitDetectionAttributes = [
-      {
-        name: 'a_position',
-        size: 2,
-        type: AttributeType.FLOAT,
-      },
-      {
-        name: 'a_index',
-        size: 1,
-        type: AttributeType.FLOAT,
-      },
-      {
+    if (this.hitDetectionEnabled_) {
+      this.attributes.push({
         name: 'a_hitColor',
         size: 4,
         type: AttributeType.FLOAT,
-      },
-      {
+      });
+      this.attributes.push({
         name: 'a_featureUid',
         size: 1,
         type: AttributeType.FLOAT,
-      },
-    ].concat(customAttributes);
+      });
+    }
+    this.attributes.push(...customAttributes);
 
     this.customAttributes = options.attributes ? options.attributes : [];
 
@@ -270,13 +238,6 @@ class WebGLPointsLayerRenderer extends WebGLLayerRenderer {
      */
     this.renderInstructions_ = new Float32Array(0);
 
-    /**
-     * These instructions are used for hit detection
-     * @type {Float32Array}
-     * @private
-     */
-    this.hitRenderInstructions_ = new Float32Array(0);
-
     /**
      * @type {WebGLRenderTarget}
      * @private
@@ -304,13 +265,8 @@ class WebGLPointsLayerRenderer extends WebGLLayerRenderer {
         const received = event.data;
         if (received.type === WebGLWorkerMessageType.GENERATE_POINT_BUFFERS) {
           const projectionTransform = received.projectionTransform;
-          if (received.hitDetection) {
-            this.hitVerticesBuffer_.fromArrayBuffer(received.vertexBuffer);
-            this.helper.flushBufferData(this.hitVerticesBuffer_);
-          } else {
-            this.verticesBuffer_.fromArrayBuffer(received.vertexBuffer);
-            this.helper.flushBufferData(this.verticesBuffer_);
-          }
+          this.verticesBuffer_.fromArrayBuffer(received.vertexBuffer);
+          this.helper.flushBufferData(this.verticesBuffer_);
           this.indicesBuffer_.fromArrayBuffer(received.indexBuffer);
           this.helper.flushBufferData(this.indicesBuffer_);
 
@@ -319,19 +275,12 @@ class WebGLPointsLayerRenderer extends WebGLLayerRenderer {
             this.invertRenderTransform_,
             this.renderTransform_
           );
-          if (received.hitDetection) {
-            this.hitRenderInstructions_ = new Float32Array(
-              event.data.renderInstructions
-            );
-          } else {
-            this.renderInstructions_ = new Float32Array(
-              event.data.renderInstructions
-            );
-            if (received.id === this.lastSentId) {
-              this.ready = true;
-            }
+          this.renderInstructions_ = new Float32Array(
+            event.data.renderInstructions
+          );
+          if (received.id === this.lastSentId) {
+            this.ready = true;
           }
-
           this.getLayer().changed();
         }
       }
@@ -395,11 +344,6 @@ class WebGLPointsLayerRenderer extends WebGLLayerRenderer {
     );
 
     if (this.hitDetectionEnabled_) {
-      this.hitProgram_ = this.helper.getProgram(
-        this.hitFragmentShader_,
-        this.hitVertexShader_
-      );
-
       this.hitRenderTarget_ = new WebGLRenderTarget(this.helper);
     }
   }
@@ -458,6 +402,36 @@ class WebGLPointsLayerRenderer extends WebGLLayerRenderer {
     const gl = this.helper.getGL();
     this.preRender(gl, frameState);
 
+    const [startWorld, endWorld, worldWidth] =
+      this.getWorldParameters_(frameState);
+
+    // draw the normal canvas
+    this.renderWorlds(frameState, false, startWorld, endWorld, worldWidth);
+
+    this.helper.finalizeDraw(
+      frameState,
+      this.dispatchPreComposeEvent,
+      this.dispatchPostComposeEvent
+    );
+    const canvas = this.helper.getCanvas();
+
+    if (this.hitDetectionEnabled_) {
+      this.renderWorlds(frameState, true, startWorld, endWorld, worldWidth);
+      this.hitRenderTarget_.clearCachedData();
+    }
+
+    this.postRender(gl, frameState);
+
+    return canvas;
+  }
+
+  /**
+   * Compute world params
+   * @private
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @return {Array<number>} The world start, end and width.
+   */
+  getWorldParameters_(frameState) {
     const projection = frameState.viewState.projection;
     const layer = this.getLayer();
     const vectorSource = layer.getSource();
@@ -475,34 +449,7 @@ class WebGLPointsLayerRenderer extends WebGLLayerRenderer {
       ? Math.floor((extent[0] - projectionExtent[0]) / worldWidth)
       : 0;
 
-    let world = startWorld;
-    const renderCount = this.indicesBuffer_.getSize();
-
-    do {
-      // apply the current projection transform with the invert of the one used to fill buffers
-      this.helper.makeProjectionTransform(frameState, this.currentTransform_);
-      translateTransform(this.currentTransform_, world * worldWidth, 0);
-      multiplyTransform(this.currentTransform_, this.invertRenderTransform_);
-      this.helper.applyUniforms(frameState);
-
-      this.helper.drawElements(0, renderCount);
-    } while (++world < endWorld);
-
-    this.helper.finalizeDraw(
-      frameState,
-      this.dispatchPreComposeEvent,
-      this.dispatchPostComposeEvent
-    );
-    const canvas = this.helper.getCanvas();
-
-    if (this.hitDetectionEnabled_) {
-      this.renderHitDetection(frameState, startWorld, endWorld, worldWidth);
-      this.hitRenderTarget_.clearCachedData();
-    }
-
-    this.postRender(gl, frameState);
-
-    return canvas;
+    return [startWorld, endWorld, worldWidth];
   }
 
   /**
@@ -558,38 +505,22 @@ class WebGLPointsLayerRenderer extends WebGLLayerRenderer {
     const projectionTransform = createTransform();
     this.helper.makeProjectionTransform(frameState, projectionTransform);
 
-    // here we anticipate the amount of render instructions that we well generate
-    // this can be done since we know that for normal render we only have x, y as base instructions,
-    // and x, y, r, g, b, a and featureUid for hit render instructions
-    // and we also know the amount of custom attributes to append to these
-    const totalInstructionsCount =
-      (2 + this.customAttributes.length) * this.featureCount_;
+    const baseInstructionLength = this.hitDetectionEnabled_ ? 7 : 2; // see below
+    const singleInstructionLength =
+      baseInstructionLength + this.customAttributes.length;
+    const totalSize = singleInstructionLength * this.featureCount_;
     if (
       !this.renderInstructions_ ||
-      this.renderInstructions_.length !== totalInstructionsCount
+      this.renderInstructions_.length !== totalSize
     ) {
-      this.renderInstructions_ = new Float32Array(totalInstructionsCount);
-    }
-    if (this.hitDetectionEnabled_) {
-      const totalHitInstructionsCount =
-        (7 + this.customAttributes.length) * this.featureCount_;
-      if (
-        !this.hitRenderInstructions_ ||
-        this.hitRenderInstructions_.length !== totalHitInstructionsCount
-      ) {
-        this.hitRenderInstructions_ = new Float32Array(
-          totalHitInstructionsCount
-        );
-      }
+      this.renderInstructions_ = new Float32Array(totalSize);
     }
 
     // loop on features to fill the buffer
     let featureCache, geometry;
     const tmpCoords = [];
     const tmpColor = [];
-    let renderIndex = 0;
-    let hitIndex = 0;
-    let hitColor;
+    let idx = -1;
     for (const featureUid in this.featureCache_) {
       featureCache = this.featureCache_[featureUid];
       geometry = /** @type {import("../../geom").Point} */ (
@@ -598,39 +529,31 @@ class WebGLPointsLayerRenderer extends WebGLLayerRenderer {
       if (!geometry || geometry.getType() !== 'Point') {
         continue;
       }
-
       tmpCoords[0] = geometry.getFlatCoordinates()[0];
       tmpCoords[1] = geometry.getFlatCoordinates()[1];
       applyTransform(projectionTransform, tmpCoords);
 
-      hitColor = colorEncodeId(hitIndex + 6, tmpColor);
-
-      this.renderInstructions_[renderIndex++] = tmpCoords[0];
-      this.renderInstructions_[renderIndex++] = tmpCoords[1];
+      this.renderInstructions_[++idx] = tmpCoords[0];
+      this.renderInstructions_[++idx] = tmpCoords[1];
 
       // for hit detection, the feature uid is saved in the opacity value
       // and the index of the opacity value is encoded in the color values
       if (this.hitDetectionEnabled_) {
-        this.hitRenderInstructions_[hitIndex++] = tmpCoords[0];
-        this.hitRenderInstructions_[hitIndex++] = tmpCoords[1];
-        this.hitRenderInstructions_[hitIndex++] = hitColor[0];
-        this.hitRenderInstructions_[hitIndex++] = hitColor[1];
-        this.hitRenderInstructions_[hitIndex++] = hitColor[2];
-        this.hitRenderInstructions_[hitIndex++] = hitColor[3];
-        this.hitRenderInstructions_[hitIndex++] = Number(featureUid);
+        const hitColor = colorEncodeId(idx + 5, tmpColor);
+        this.renderInstructions_[++idx] = hitColor[0];
+        this.renderInstructions_[++idx] = hitColor[1];
+        this.renderInstructions_[++idx] = hitColor[2];
+        this.renderInstructions_[++idx] = hitColor[3];
+        this.renderInstructions_[++idx] = Number(featureUid);
       }
 
       // pushing custom attributes
-      let value;
       for (let j = 0; j < this.customAttributes.length; j++) {
-        value = this.customAttributes[j].callback(
+        const value = this.customAttributes[j].callback(
           featureCache.feature,
           featureCache.properties
         );
-        this.renderInstructions_[renderIndex++] = value;
-        if (this.hitDetectionEnabled_) {
-          this.hitRenderInstructions_[hitIndex++] = value;
-        }
+        this.renderInstructions_[++idx] = value;
       }
     }
 
@@ -639,29 +562,13 @@ class WebGLPointsLayerRenderer extends WebGLLayerRenderer {
       id: ++this.lastSentId,
       type: WebGLWorkerMessageType.GENERATE_POINT_BUFFERS,
       renderInstructions: this.renderInstructions_.buffer,
-      customAttributesSize: this.customAttributes.length,
+      customAttributesSize: singleInstructionLength - 2,
     };
     // additional properties will be sent back as-is by the worker
     message['projectionTransform'] = projectionTransform;
     this.ready = false;
     this.worker_.postMessage(message, [this.renderInstructions_.buffer]);
     this.renderInstructions_ = null;
-
-    /** @type {import('../../render/webgl/constants.js').WebGLWorkerGenerateBuffersMessage} */
-    if (this.hitDetectionEnabled_) {
-      const hitMessage = {
-        id: 0,
-        type: WebGLWorkerMessageType.GENERATE_POINT_BUFFERS,
-        renderInstructions: this.hitRenderInstructions_.buffer,
-        customAttributesSize: 5 + this.customAttributes.length,
-      };
-      hitMessage['projectionTransform'] = projectionTransform;
-      hitMessage['hitDetection'] = true;
-      this.worker_.postMessage(hitMessage, [
-        this.hitRenderInstructions_.buffer,
-      ]);
-      this.hitRenderInstructions_ = null;
-    }
   }
 
   /**
@@ -681,7 +588,7 @@ class WebGLPointsLayerRenderer extends WebGLLayerRenderer {
     matches
   ) {
     assert(this.hitDetectionEnabled_, 66);
-    if (!this.hitRenderInstructions_) {
+    if (!this.renderInstructions_ || !this.hitDetectionEnabled_) {
       return undefined;
     }
 
@@ -693,7 +600,7 @@ class WebGLPointsLayerRenderer extends WebGLLayerRenderer {
     const data = this.hitRenderTarget_.readPixel(pixel[0] / 2, pixel[1] / 2);
     const color = [data[0] / 255, data[1] / 255, data[2] / 255, data[3] / 255];
     const index = colorDecodeId(color);
-    const opacity = this.hitRenderInstructions_[index];
+    const opacity = this.renderInstructions_[index];
     const uid = Math.floor(opacity).toString();
 
     const source = this.getLayer().getSource();
@@ -705,42 +612,40 @@ class WebGLPointsLayerRenderer extends WebGLLayerRenderer {
   }
 
   /**
-   * Render the hit detection data to the corresponding render target
+   * Render the world, either to the main framebuffer or to the hit framebuffer
    * @param {import("../../Map.js").FrameState} frameState current frame state
+   * @param {boolean} forHitDetection whether the rendering is for hit detection
    * @param {number} startWorld the world to render in the first iteration
    * @param {number} endWorld the last world to render
    * @param {number} worldWidth the width of the worlds being rendered
    */
-  renderHitDetection(frameState, startWorld, endWorld, worldWidth) {
-    // skip render entirely if vertex buffers not ready/generated yet
-    if (!this.hitVerticesBuffer_.getSize()) {
-      return;
-    }
-
+  renderWorlds(frameState, forHitDetection, startWorld, endWorld, worldWidth) {
     let world = startWorld;
 
-    this.hitRenderTarget_.setSize([
-      Math.floor(frameState.size[0] / 2),
-      Math.floor(frameState.size[1] / 2),
-    ]);
+    this.helper.useProgram(this.program_, frameState);
 
-    this.helper.useProgram(this.hitProgram_, frameState);
-    this.helper.prepareDrawToRenderTarget(
-      frameState,
-      this.hitRenderTarget_,
-      true
-    );
+    if (forHitDetection) {
+      this.hitRenderTarget_.setSize([
+        Math.floor(frameState.size[0] / 2),
+        Math.floor(frameState.size[1] / 2),
+      ]);
+      this.helper.prepareDrawToRenderTarget(
+        frameState,
+        this.hitRenderTarget_,
+        true
+      );
+    }
 
-    this.helper.bindBuffer(this.hitVerticesBuffer_);
+    this.helper.bindBuffer(this.verticesBuffer_);
     this.helper.bindBuffer(this.indicesBuffer_);
-    this.helper.enableAttributes(this.hitDetectionAttributes);
+    this.helper.enableAttributes(this.attributes);
 
     do {
       this.helper.makeProjectionTransform(frameState, this.currentTransform_);
       translateTransform(this.currentTransform_, world * worldWidth, 0);
       multiplyTransform(this.currentTransform_, this.invertRenderTransform_);
       this.helper.applyUniforms(frameState);
-
+      this.helper.applyHitDetectionUniform(forHitDetection);
       const renderCount = this.indicesBuffer_.getSize();
       this.helper.drawElements(0, renderCount);
     } while (++world < endWorld);

package/renderer/webgl/VectorLayer.d.ts

@@ -9,6 +9,7 @@ export const Uniforms: {
     RESOLUTION: string;
     VIEWPORT_SIZE_PX: string;
     PIXEL_RATIO: string;
+    HIT_DETECTION: string;
 };
 export default WebGLVectorLayerRenderer;
 export type VectorStyle = import('../../render/webgl/VectorStyleRenderer.js').VectorStyle;

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

@@ -1 +1 @@
-{"version":3,"file":"VectorLayer.d.ts","sourceRoot":"","sources":["VectorLayer.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;EAIE;;0BAGW,OAAO,2CAA2C,EAAE,WAAW;;;;;;;;;WAM9D,WAAW,GAAC,MAAM,WAAW,CAAC;;;;;;AAP5C;;GAEG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH;IACE;;;OAGG;IACH,mBAHW,OAAO,sBAAsB,EAAE,OAAO,WACtC,OAAO,EAwFjB;IA3EC,wBAAyB;IAEzB,kDAAoC;IAEpC;;;;;;OAMG;IACH,0BAA0C;IAE1C,wBAAsC;IACtC,mBAA4B;IAE5B;;;OAGG;IACH,oCAAoD;IAEpD;;;OAGG;IACH,gBAAiB;IAEjB;;;OAGG;IACH,wBAAyB;IAEzB;;;OAGG;IACH,iBAAkB;IAIlB;;OAEG;IACH,eAAsC;IAItC,yDAyBC;IAGH;;;OAGG;IACH,sBAIC;IAED;;OAEG;IACH,yBAKC;IAED,0BAMC;IAMD;;;OAGG;IACH,kCAGC;IAED;;;OAGG;IACH,oCAGC;IAED;;;OAGG;IACH,mCAGC;IAED;;OAEG;IACH,kCAEC;IAED;;;OAGG;IACH,uBAQC;IAED;;;;OAIG;IACH,wBAHW,OAAO,cAAc,EAAE,UAAU,GAChC,WAAW,CAoDtB;CAkFF;+BAxW8B,YAAY"}
+{"version":3,"file":"VectorLayer.d.ts","sourceRoot":"","sources":["VectorLayer.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;EAIE;;0BAGW,OAAO,2CAA2C,EAAE,WAAW;;;;;;;;;WAM9D,WAAW,GAAC,MAAM,WAAW,CAAC;;;;;;AAP5C;;GAEG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH;IACE;;;OAGG;IACH,mBAHW,OAAO,sBAAsB,EAAE,OAAO,WACtC,OAAO,EAwFjB;IA3EC,wBAAyB;IAEzB,kDAAoC;IAEpC;;;;;;OAMG;IACH,0BAA0C;IAE1C,wBAAsC;IACtC,mBAA4B;IAE5B;;;OAGG;IACH,oCAAoD;IAEpD;;;OAGG;IACH,gBAAiB;IAEjB;;;OAGG;IACH,wBAAyB;IAEzB;;;OAGG;IACH,iBAAkB;IAIlB;;OAEG;IACH,eAAsC;IAItC,yDAyBC;IAGH;;;OAGG;IACH,sBAIC;IAED;;OAEG;IACH,yBAKC;IAED,0BAMC;IAMD;;;OAGG;IACH,kCAGC;IAED;;;OAGG;IACH,oCAGC;IAED;;;OAGG;IACH,mCAGC;IAED;;OAEG;IACH,kCAEC;IAED;;;OAGG;IACH,uBAQC;IAED;;;;OAIG;IACH,wBAHW,OAAO,cAAc,EAAE,UAAU,GAChC,WAAW,CAoDtB;CAkFF;+BAxW8B,YAAY"}

package/util.js

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

package/webgl/Helper.d.ts

@@ -26,6 +26,7 @@ export namespace DefaultUniform {
     let RESOLUTION: string;
     let VIEWPORT_SIZE_PX: string;
     let PIXEL_RATIO: string;
+    let HIT_DETECTION: string;
 }
 /**
  * Attribute types, either `UNSIGNED_BYTE`, `UNSIGNED_SHORT`, `UNSIGNED_INT` or `FLOAT`
@@ -443,6 +444,11 @@ declare class WebGLHelper extends Disposable {
      * @param {import("../Map.js").FrameState} frameState Frame state.
      */
     applyFrameState(frameState: import("../Map.js").FrameState): void;
+    /**
+     * Sets the `u_hitDetection` uniform.
+     * @param {boolean} enabled Whether to enable the hit detection code path
+     */
+    applyHitDetectionUniform(enabled: boolean): void;
     /**
      * Sets the custom uniforms based on what was given in the constructor. This is called internally in `prepareDraw`.
      * @param {import("../Map.js").FrameState} frameState Frame state.

package/webgl/Helper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Helper.d.ts","sourceRoot":"","sources":["Helper.js"],"names":[],"mappings":"AAyjCA;;;;GAIG;AACH,oDAHW,MAAM,oBAAoB,CAAC,GAC1B,MAAM,CASjB;;;;yBAriCS,MAAM;;;;;;;;;6BAUN,MAAM;;;;;;;;;;;;;;;4BAgBN,MAAM;;;;;;;;;;;;YAhCF,OAAO,aAAa,EAAE,OAAO;;;;iBAC7B,WAAW;;;;;;;;;UA2CX,MAAM;;;;UACN,MAAM;;;;;;;;kCAOP,MAAM,GAAC,MAAM,MAAM,CAAC,GAAC,iBAAiB,GAAC,gBAAgB,GAAC,SAAS,GAAC,OAAO,cAAc,EAAE,SAAS;;;;;2BAMlG,mBAAmB,WAAU,OAAO,WAAW,EAAE,UAAU,KAAE,mBAAmB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAsB/E,MAAM;;;;;;;;;;;;;;;;;;YASN,iBAAiB;;;;WACjB,MAAM;;8BAxGb,aAAa;+BAAb,aAAa;6BAAb,aAAa;sBAAb,aAAa;AA6KpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2HG;AACH;IACE;;OAEG;IACH,2CAkIC;IA9HC,eAAe;IACf,qCAA0E;IAE1E,eAAe;IACf,yCAC4C;IAE5C;;;OAGG;IACH,wBAE6B;IAE7B;;;OAGG;IACH,gBAA8C;IAE9C;;;OAGG;IACH,YAAmC;IAEnC;;;OAGG;IACH,qBAAsB;IAEtB;;;OAGG;IACH,wBAAyB;IAEzB;;;OAGG;IACH,wBAA2B;IAW3B;;;OAGG;IACH,4BAA4C;IAE5C;;;OAGG;IACH,2BAA2C;IAE3C;;;OAGG;IACH,iBAAwB;IAExB;;;OAGG;IACH,mCAAoC;IAEpC;;;OAGG;IACH,kCAAmC;IAEnC;;;;;OAKG;IACH,kBAAmB;IAKnB;;;;;;OAMG;IACH,2BAW2D;IAE3D;;;OAGG;IACH,6BAAgC;IAEhC;;;OAGG;IACH,mBAA4B;IAG9B;;OAEG;IACH;YAFkB,MAAM,GAAE,YAAY;aAUrC;IAED;;;OAGG;IACH,sCAHW,MAAM,GACL,OAAO,CAIlB;IAED;;;;;OAKG;IACH,mBAHW,MAAM,GACL,MAAO,IAAI,CAStB;IAED;;;;;OAKG;IACH,mBAFW,OAAO,UAAU,EAAE,OAAO,QAepC;IAED;;;;OAIG;IACH,wBAFW,OAAO,UAAU,EAAE,OAAO,QAMpC;IAED;;OAEG;IACH,kBAFW,OAAO,aAAa,EAAE,OAAO,QAUvC;IAqBD;;;;;;OAMG;IACH,wBAHW,OAAO,WAAW,EAAE,UAAU,iDA+BxC;IAED;;;;;OAKG;IACH,qBAJW,YAAY,QACZ,MAAM,eACN,MAAM,QAOhB;IAED;;;;;;;OAOG;IACH,sCAJW,OAAO,WAAW,EAAE,UAAU,gBAC9B,OAAO,mBAAmB,EAAE,OAAO,iDAc7C;IAED;;;;OAIG;IACH,oBAHW,MAAM,OACN,MAAM,QAYhB;IAED;;;;;OAKG;IACH,yBAJW,OAAO,WAAW,EAAE,UAAU,uBACrB,qBAAqB,QAAE,OAAO,WAAW,EAAE,UAAU,KAAE,IAAI,qCAC3D,qBAAqB,QAAE,OAAO,WAAW,EAAE,UAAU,KAAE,IAAI,qBAmB9E;IAED;;OAEG;IACH,aAFY,iBAAiB,CAI5B;IAED;;;OAGG;IACH,SAFY,qBAAqB,CAIhC;IAED;;;OAGG;IACH,4BAFW,OAAO,WAAW,EAAE,UAAU,QAsCxC;IAED;;;OAGG;IACH,0BAFW,OAAO,WAAW,EAAE,UAAU,QAqFxC;IAED;;;;;OAKG;IACH,oBAHW,YAAY,cACZ,OAAO,WAAW,EAAE,UAAU,QAQxC;IAED;;;;;;;;OAQG;IACH,sBAJW,MAAM,QACN,UAAU,GACT,WAAW,CAQtB;IAED;;;;;OAKG;IACH,iCAJW,MAAM,sBACN,MAAM,GACL,YAAY,CA4CvB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACL,oBAAoB,CAY/B;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACL,MAAM,CAYjB;IAED;;;;;;OAMG;IACH,oCAJW,OAAO,WAAW,EAAE,UAAU,aAC9B,OAAO,cAAc,EAAE,SAAS,GAC/B,OAAO,cAAc,EAAE,SAAS,CAkB3C;IAED;;;;OAIG;IACH,8BAHW,MAAM,SACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,6BAHW,MAAM,SACN,MAAM,MAAM,CAAC,QAIvB;IAED;;;;OAIG;IACH,6BAHW,MAAM,SACN,MAAM,MAAM,CAAC,QAIvB;IAED;;;;OAIG;IACH,+BAHW,MAAM,SACN,MAAM,MAAM,CAAC,QAIvB;IAED;;;;;;;;;OASG;IACH,8BAQC;IAED;;;;;OAKG;IACH,6BAFW,MAAM,oBAAoB,CAAC,QAgBrC;IAED;;;OAGG;IACH,+BAGC;IAED;;;OAGG;IACH,mCAA+B;IAE/B;;;;;;;;;OASG;IACH,oBALW,MAAM,MAAM,CAAC,4GAGZ,YAAY,CAiCvB;CACF;uBAnjCsB,kBAAkB"}
+{"version":3,"file":"Helper.d.ts","sourceRoot":"","sources":["Helper.js"],"names":[],"mappings":"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"}

package/webgl/Helper.js

@@ -51,6 +51,7 @@ export const DefaultUniform = {
   RESOLUTION: 'u_resolution',
   VIEWPORT_SIZE_PX: 'u_viewportSizePx',
   PIXEL_RATIO: 'u_pixelRatio',
+  HIT_DETECTION: 'u_hitDetection',
 };
 
 /**
@@ -713,6 +714,15 @@ class WebGLHelper extends Disposable {
     ]);
   }
 
+  /**
+   * Sets the `u_hitDetection` uniform.
+   * @param {boolean} enabled Whether to enable the hit detection code path
+   */
+  applyHitDetectionUniform(enabled) {
+    const loc = this.getUniformLocation(DefaultUniform.HIT_DETECTION);
+    this.getGL().uniform1i(loc, enabled ? 1 : 0);
+  }
+
   /**
    * Sets the custom uniforms based on what was given in the constructor. This is called internally in `prepareDraw`.
    * @param {import("../Map.js").FrameState} frameState Frame state.
@@ -990,7 +1000,7 @@ class WebGLHelper extends Disposable {
    */
   enableAttributeArray_(attribName, size, type, stride, offset) {
     const location = this.getAttributeLocation(attribName);
-    // the attribute has not been found in the shaders; do not enable it
+    // the attribute has not been found in the shaders or is not used; do not enable it
     if (location < 0) {
       return;
     }

package/webgl/ShaderBuilder.d.ts

@@ -191,63 +191,49 @@ export class ShaderBuilder {
     /**
      * Generates a symbol vertex shader from the builder parameters
      *
-     * Four uniforms are hardcoded in all shaders: `u_projectionMatrix`, `u_offsetScaleMatrix`,
-     * `u_offsetRotateMatrix`, `u_time`.
+     * The following uniforms are hardcoded in all shaders: `u_projectionMatrix`, `u_offsetScaleMatrix`,
+     * `u_offsetRotateMatrix`, `u_time`, `u_zoom`, `u_resolution`, `u_hitDetection`.
      *
      * The following attributes are hardcoded and expected to be present in the vertex buffers:
-     * `vec2 a_position`, `float a_index` (being the index of the vertex in the quad, 0 to 3).
+     * `vec2 a_position`, `float a_index` (being the index of the vertex in the quad, 0 to 3), `vec4 a_hitColor`.
      *
      * The following varyings are hardcoded and gives the coordinate of the pixel both in the quad and on the texture:
-     * `vec2 v_quadCoord`, `vec2 v_texCoord`
+     * `vec2 v_quadCoord`, `vec2 v_texCoord`, `vec4 v_hitColor`.
      *
-     * @param {boolean} [forHitDetection] If true, the shader will be modified to include hit detection variables
-     * (namely, hit color with encoded feature id).
      * @return {string} The full shader as a string.
      */
-    getSymbolVertexShader(forHitDetection?: boolean | undefined): string;
+    getSymbolVertexShader(): string;
     /**
      * Generates a symbol fragment shader from the builder parameters
      *
      * Expects the following varyings to be transmitted by the vertex shader:
-     * `vec2 v_quadCoord`, `vec2 v_texCoord`
+     * `vec2 v_quadCoord`, `vec2 v_texCoord`, `vec4 v_hitColor`.
      *
-     * @param {boolean} [forHitDetection] If true, the shader will be modified to include hit detection variables
-     * (namely, hit color with encoded feature id).
      * @return {string} The full shader as a string.
      */
-    getSymbolFragmentShader(forHitDetection?: boolean | undefined): string;
+    getSymbolFragmentShader(): string;
     /**
      * Generates a stroke vertex shader from the builder parameters
-     *
-     * @param {boolean} [forHitDetection] If true, the shader will be modified to include hit detection variables
-     * (namely, hit color with encoded feature id).
      * @return {string} The full shader as a string.
      */
-    getStrokeVertexShader(forHitDetection?: boolean | undefined): string;
+    getStrokeVertexShader(): string;
     /**
      * Generates a stroke fragment shader from the builder parameters
      *
-     * @param {boolean} [forHitDetection] If true, the shader will be modified to include hit detection variables
-     * (namely, hit color with encoded feature id).
      * @return {string} The full shader as a string.
      */
-    getStrokeFragmentShader(forHitDetection?: boolean | undefined): string;
+    getStrokeFragmentShader(): string;
     /**
      * Generates a fill vertex shader from the builder parameters
      *
-     * @param {boolean} [forHitDetection] If true, the shader will be modified to include hit detection variables
-     * (namely, hit color with encoded feature id).
      * @return {string} The full shader as a string.
      */
-    getFillVertexShader(forHitDetection?: boolean | undefined): string;
+    getFillVertexShader(): string;
     /**
      * Generates a fill fragment shader from the builder parameters
-     *
-     * @param {boolean} [forHitDetection] If true, the shader will be modified to include hit detection variables
-     * (namely, hit color with encoded feature id).
      * @return {string} The full shader as a string.
      */
-    getFillFragmentShader(forHitDetection?: boolean | undefined): string;
+    getFillFragmentShader(): string;
 }
 export type VaryingDescription = {
     /**

package/webgl/ShaderBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShaderBuilder.d.ts","sourceRoot":"","sources":["ShaderBuilder.js"],"names":[],"mappings":"AAeA;;;;;;GAMG;AAEH;;;;;;;;;;;;;GAaG;AACH;IAEI;;;;OAIG;IACH,kBAAmB;IAEnB;;;;OAIG;IACH,oBAAqB;IAErB;;;;OAIG;IACH,kBAAmB;IAEnB;;;OAGG;IACH,8BAAwC;IAExC;;;OAGG;IACH,kCAAsC;IAEtC;;;OAGG;IACH,gCAA0C;IAE1C;;;OAGG;IACH,+BAAyC;IAEzC;;;OAGG;IACH,4BAAqD;IAErD;;;OAGG;IACH,2BAAiC;IAEjC;;;OAGG;IACH,8BAAkC;IAElC;;;OAGG;IACH,+BAAmC;IAEnC;;;OAGG;IACH,+BAAyC;IAEzC;;;OAGG;IACH,6BAAuC;IAEvC;;;OAGG;IACH,+BAAgC;IAEhC;;;OAGG;IACH,iCAAkC;IAGpC;;;;;OAKG;IACH,iBAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;;;OAKG;IACH,mBAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;;;;;OAOG;IACH,iBALW,MAAM,QACN,OAAO,GAAC,MAAM,GAAC,MAAM,GAAC,MAAM,cAC5B,MAAM,GACL,aAAa,CASxB;IAED;;;;;;OAMG;IACH,oCAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;;;;OAMG;IACH,wCAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;;;;;OAOG;IACH,sCAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;;;;OAMG;IACH,qCAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;;;;OAMG;IACH,2CAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;;;;;;OAQG;IACH,yCAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;;;OAKG;IACH,wCAHW,OAAO,GACN,aAAa,CAKxB;IAED;;;OAGG;IACH,qCAHW,MAAM,GACL,aAAa,CAKxB;IAED,gDAGC;IAED,8CAGC;IAED,yCAKC;IACD,2CAKC;IAED;;;;;;;;;;;;;;;OAeG;IACH,8DAFY,MAAM,CAiFjB;IAED;;;;;;;;;OASG;IACH,gEAFY,MAAM,CAwCjB;IAED;;;;;;OAMG;IACH,8DAFY,MAAM,CA6FjB;IAED;;;;;;OAMG;IACH,gEAFY,MAAM,CAwEjB;IAED;;;;;;OAMG;IACH,4DAFY,MAAM,CA8CjB;IAED;;;;;;OAMG;IACH,8DAFY,MAAM,CAyDjB;CACF;;;;;UA3sBa,MAAM;;;;UACN,MAAM;;;;;gBACN,MAAM"}
+{"version":3,"file":"ShaderBuilder.d.ts","sourceRoot":"","sources":["ShaderBuilder.js"],"names":[],"mappings":"AAiBA;;;;;;GAMG;AAEH;;;;;;;;;;;;;GAaG;AACH;IAEI;;;;OAIG;IACH,kBAAmB;IAEnB;;;;OAIG;IACH,oBAAqB;IAErB;;;;OAIG;IACH,kBAAmB;IAEnB;;;OAGG;IACH,8BAAwC;IAExC;;;OAGG;IACH,kCAAsC;IAEtC;;;OAGG;IACH,gCAA0C;IAE1C;;;OAGG;IACH,+BAAyC;IAEzC;;;OAGG;IACH,4BAAqD;IAErD;;;OAGG;IACH,2BAAiC;IAEjC;;;OAGG;IACH,8BAAkC;IAElC;;;OAGG;IACH,+BAAmC;IAEnC;;;OAGG;IACH,+BAAyC;IAEzC;;;OAGG;IACH,6BAAuC;IAEvC;;;OAGG;IACH,+BAAgC;IAEhC;;;OAGG;IACH,iCAAkC;IAGpC;;;;;OAKG;IACH,iBAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;;;OAKG;IACH,mBAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;;;;;OAOG;IACH,iBALW,MAAM,QACN,OAAO,GAAC,MAAM,GAAC,MAAM,GAAC,MAAM,cAC5B,MAAM,GACL,aAAa,CASxB;IAED;;;;;;OAMG;IACH,oCAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;;;;OAMG;IACH,wCAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;;;;;OAOG;IACH,sCAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;;;;OAMG;IACH,qCAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;;;;OAMG;IACH,2CAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;;;;;;OAQG;IACH,yCAHW,MAAM,GACL,aAAa,CAKxB;IAED;;;;;OAKG;IACH,wCAHW,OAAO,GACN,aAAa,CAKxB;IAED;;;OAGG;IACH,qCAHW,MAAM,GACL,aAAa,CAKxB;IAED,gDAGC;IAED,8CAGC;IAED,yCAKC;IACD,2CAKC;IAED;;;;;;;;;;;;;OAaG;IACH,yBAFY,MAAM,CA0EjB;IAED;;;;;;;OAOG;IACH,2BAFY,MAAM,CA+BjB;IAED;;;OAGG;IACH,yBAFY,MAAM,CAoFjB;IAED;;;;OAIG;IACH,2BAFY,MAAM,CA8DjB;IAED;;;;OAIG;IACH,uBAFY,MAAM,CAoCjB;IAED;;;OAGG;IACH,yBAFY,MAAM,CA+CjB;CACF;;;;;UAtoBa,MAAM;;;;UACN,MAAM;;;;;gBACN,MAAM"}