Use reversedInstructions for hit detection

src/ol/render/canvas/canvasreplay.js

@@ -137,19 +137,20 @@ ol.render.canvas.Replay.prototype.beginGeometry = function(geometry) {
 
 
 /**
+ * @private
  * @param {CanvasRenderingContext2D} context Context.
  * @param {goog.vec.Mat4.AnyType} transform Transform.
  * @param {function(ol.geom.Geometry): boolean} renderGeometryFunction Render
  *     geometry function.
- * @param {function(ol.geom.Geometry, Object): T=} opt_callback
+ * @param {Array.<*>} instructions Instructions array.
+ * @param {function(ol.geom.Geometry, Object): T|undefined} geometryCallback
  *     Geometry callback.
  * @return {T|undefined} Callback result.
  * @template T
  */
-ol.render.canvas.Replay.prototype.replay =
+ol.render.canvas.Replay.prototype.replay_ =
-    function(context, transform, renderGeometryFunction, opt_callback) {
+    function(context, transform, renderGeometryFunction, instructions,
-  var perGeometryMode = goog.isDef(opt_callback);
+        geometryCallback) {
-  var batchMode = !perGeometryMode;
   /** @type {Array.<number>} */
   var pixelCoordinates;
   if (ol.vec.Mat4.equals2D(transform, this.renderedTransform_)) {
@@ -160,44 +161,39 @@ ol.render.canvas.Replay.prototype.replay =
     goog.vec.Mat4.setFromArray(this.renderedTransform_, transform);
     goog.asserts.assert(pixelCoordinates === this.pixelCoordinates_);
   }
-  var instructions = this.instructions;
   var i = 0; // instruction index
   var ii = instructions.length; // end of instructions
-  var d = 0; // data index
+  var d; // data index
   var dd; // end of per-instruction data
   while (i < ii) {
     var instruction = instructions[i];
     var type = /** @type {ol.render.canvas.Instruction} */ (instruction[0]);
     var geometry;
-    var executeInPerGeometryMode, executeInBatchMode;
     if (type == ol.render.canvas.Instruction.BEGIN_GEOMETRY) {
       geometry = /** @type {ol.geom.Geometry} */ (instruction[1]);
       if (renderGeometryFunction(geometry)) {
         ++i;
       } else {
-        d = /** @type {number} */ (instruction[2]);
+        i = /** @type {number} */ (instruction[2]);
-        i = /** @type {number} */ (instruction[3]);
       }
     } else if (type == ol.render.canvas.Instruction.BEGIN_PATH) {
-      executeInPerGeometryMode = /** @type {boolean} */ (instruction[1]);
+      context.beginPath();
-      executeInBatchMode = /** @type {boolean} */ (instruction[2]);
-      if ((perGeometryMode && executeInPerGeometryMode) ||
-          (batchMode && executeInBatchMode)) {
-        context.beginPath();
-      }
       ++i;
     } else if (type == ol.render.canvas.Instruction.CLOSE_PATH) {
       context.closePath();
       ++i;
     } else if (type == ol.render.canvas.Instruction.DRAW_IMAGE) {
-      dd = /** @type {number} */ (instruction[1]);
+      goog.asserts.assert(goog.isNumber(instruction[1]));
-      var anchorX = /** @type {number} */ (instruction[2]);
+      d = /** @type {number} */ (instruction[1]);
-      var anchorY = /** @type {number} */ (instruction[3]);
+      goog.asserts.assert(goog.isNumber(instruction[2]));
-      var width = /** @type {number} */ (instruction[4]);
+      dd = /** @type {number} */ (instruction[2]);
-      var height = /** @type {number} */ (instruction[5]);
+      var anchorX = /** @type {number} */ (instruction[3]);
+      var anchorY = /** @type {number} */ (instruction[4]);
+      var width = /** @type {number} */ (instruction[5]);
+      var height = /** @type {number} */ (instruction[6]);
       var image =  /** @type {HTMLCanvasElement|HTMLVideoElement|Image} */
-          (instruction[6]);
+          (instruction[7]);
-      var snapToPixel = /** @type {boolean|undefined} */ (instruction[7]);
+      var snapToPixel = /** @type {boolean|undefined} */ (instruction[8]);
       for (; d < dd; d += 2) {
         var x = pixelCoordinates[d] - anchorX;
         var y = pixelCoordinates[d + 1] - anchorY;
@@ -209,11 +205,10 @@ ol.render.canvas.Replay.prototype.replay =
       }
       ++i;
     } else if (type == ol.render.canvas.Instruction.END_GEOMETRY) {
-      if (perGeometryMode) {
+      if (goog.isDef(geometryCallback)) {
-        goog.asserts.assert(goog.isDef(opt_callback));
         geometry = /** @type {ol.geom.Geometry} */ (instruction[1]);
         var data = /** @type {Object} */ (instruction[2]);
-        var result = opt_callback(geometry, data);
+        var result = geometryCallback(geometry, data);
         if (result) {
           return result;
         }
@@ -223,9 +218,11 @@ ol.render.canvas.Replay.prototype.replay =
       context.fill();
       ++i;
     } else if (type == ol.render.canvas.Instruction.MOVE_TO_LINE_TO) {
-      context.moveTo(pixelCoordinates[d], pixelCoordinates[d + 1]);
       goog.asserts.assert(goog.isNumber(instruction[1]));
-      dd = /** @type {number} */ (instruction[1]);
+      d = /** @type {number} */ (instruction[1]);
+      goog.asserts.assert(goog.isNumber(instruction[2]));
+      dd = /** @type {number} */ (instruction[2]);
+      context.moveTo(pixelCoordinates[d], pixelCoordinates[d + 1]);
       for (d += 2; d < dd; d += 2) {
         context.lineTo(pixelCoordinates[d], pixelCoordinates[d + 1]);
       }
@@ -251,26 +248,53 @@ ol.render.canvas.Replay.prototype.replay =
       }
       ++i;
     } else if (type == ol.render.canvas.Instruction.STROKE) {
-      executeInPerGeometryMode = /** @type {boolean} */ (instruction[1]);
+      context.stroke();
-      executeInBatchMode = /** @type {boolean} */ (instruction[2]);
-      if ((perGeometryMode && executeInPerGeometryMode) ||
-          (batchMode && executeInBatchMode)) {
-        context.stroke();
-      }
       ++i;
     } else {
       goog.asserts.fail();
       ++i; // consume the instruction anyway, to avoid an infinite loop
     }
   }
-  // assert that all data were consumed
-  goog.asserts.assert(d == pixelCoordinates.length);
   // assert that all instructions were consumed
   goog.asserts.assert(i == instructions.length);
   return undefined;
 };
 
 
+/**
+ * @param {CanvasRenderingContext2D} context Context.
+ * @param {goog.vec.Mat4.AnyType} transform Transform.
+ * @param {function(ol.geom.Geometry): boolean} renderGeometryFunction Render
+ *     geometry function.
+ * @return {T|undefined} Callback result.
+ * @template T
+ */
+ol.render.canvas.Replay.prototype.replayForward =
+    function(context, transform, renderGeometryFunction) {
+  var instructions = this.instructions;
+  return this.replay_(context, transform, renderGeometryFunction,
+      instructions, undefined);
+};
+
+
+/**
+ * @param {CanvasRenderingContext2D} context Context.
+ * @param {goog.vec.Mat4.AnyType} transform Transform.
+ * @param {function(ol.geom.Geometry): boolean} renderGeometryFunction Render
+ *     geometry function.
+ * @param {function(ol.geom.Geometry, Object): T=} opt_geometryCallback
+ *     Geometry callback.
+ * @return {T|undefined} Callback result.
+ * @template T
+ */
+ol.render.canvas.Replay.prototype.replayBackward =
+    function(context, transform, renderGeometryFunction, opt_geometryCallback) {
+  var instructions = this.reversedInstructions;
+  return this.replay_(context, transform, renderGeometryFunction,
+      instructions, opt_geometryCallback);
+};
+
+
 /**
  * @private
  */
@@ -1061,18 +1085,16 @@ ol.render.canvas.ReplayGroup = function() {
  * @param {goog.vec.Mat4.AnyType} transform Transform.
  * @param {function(ol.geom.Geometry): boolean} renderGeometryFunction Render
  *     geometry function.
- * @param {function(ol.geom.Geometry, Object): T=} opt_callback Geometry
- *     callback.
  * @return {T|undefined} Callback result.
  * @template T
  */
-ol.render.canvas.ReplayGroup.prototype.replay =
+ol.render.canvas.ReplayGroup.prototype.replay = function(context, extent,
-    function(context, extent, transform, renderGeometryFunction, opt_callback) {
+    transform, renderGeometryFunction) {
   /** @type {Array.<number>} */
   var zs = goog.array.map(goog.object.getKeys(this.replayesByZIndex_), Number);
   goog.array.sort(zs);
-  return this.replay_(
+  return this.replayForward_(
-      zs, context, extent, transform, renderGeometryFunction, opt_callback);
+      zs, context, extent, transform, renderGeometryFunction);
 };
 
 
@@ -1084,22 +1106,52 @@ ol.render.canvas.ReplayGroup.prototype.replay =
  * @param {goog.vec.Mat4.AnyType} transform Transform.
  * @param {function(ol.geom.Geometry): boolean} renderGeometryFunction Render
  *     geometry function.
- * @param {function(ol.geom.Geometry, Object): T=} opt_callback Geometry
+ * @param {function(ol.geom.Geometry, Object): T} geometryCallback Geometry
  *     callback.
  * @return {T|undefined} Callback result.
  * @template T
  */
-ol.render.canvas.ReplayGroup.prototype.replay_ = function(zs, context, extent,
+ol.render.canvas.ReplayGroup.prototype.replayBackward_ = function(zs, context,
-    transform, renderGeometryFunction, opt_callback) {
+    extent, transform, renderGeometryFunction, geometryCallback) {
-  var i, ii;
+  var i, ii, replayes, replayType, replay, result;
   for (i = 0, ii = zs.length; i < ii; ++i) {
-    var replayes = this.replayesByZIndex_[zs[i].toString()];
+    replayes = this.replayesByZIndex_[zs[i].toString()];
-    var replayType;
     for (replayType in replayes) {
-      var replay = replayes[replayType];
+      replay = replayes[replayType];
       if (ol.extent.intersects(extent, replay.getExtent())) {
-        var result = replay.replay(
+        result = replay.replayBackward(
-            context, transform, renderGeometryFunction, opt_callback);
+            context, transform, renderGeometryFunction, geometryCallback);
+        if (result) {
+          return result;
+        }
+      }
+    }
+  }
+  return undefined;
+};
+
+
+/**
+ * @private
+ * @param {Array.<number>} zs Z-indices array.
+ * @param {CanvasRenderingContext2D} context Context.
+ * @param {ol.Extent} extent Extent.
+ * @param {goog.vec.Mat4.AnyType} transform Transform.
+ * @param {function(ol.geom.Geometry): boolean} renderGeometryFunction Render
+ *     geometry function.
+ * @return {T|undefined} Callback result.
+ * @template T
+ */
+ol.render.canvas.ReplayGroup.prototype.replayForward_ =
+    function(zs, context, extent, transform, renderGeometryFunction) {
+  var i, ii, replayes, replayType, replay, result;
+  for (i = 0, ii = zs.length; i < ii; ++i) {
+    replayes = this.replayesByZIndex_[zs[i].toString()];
+    for (replayType in replayes) {
+      replay = replayes[replayType];
+      if (ol.extent.intersects(extent, replay.getExtent())) {
+        result = replay.replayForward(
+            context, transform, renderGeometryFunction);
         if (result) {
           return result;
         }
@@ -1134,7 +1186,8 @@ ol.render.canvas.ReplayGroup.prototype.forEachGeometryAtCoordinate = function(
   var context = this.hitDetectionContext_;
   context.clearRect(0, 0, 1, 1);
 
-  return this.replay_(zs, context, extent, transform, renderGeometryFunction,
+  return this.replayBackward_(zs, context, extent, transform,
+      renderGeometryFunction,
       /**
        * @param {ol.geom.Geometry} geometry Geometry.
        * @param {Object} data Opaque data object.