ol 9.2.5-dev.1718651852752 → 9.2.5-dev.1718925536936

package/renderer/canvas/VectorTileLayer.d.ts

@@ -8,8 +8,9 @@ export default CanvasVectorTileLayerRenderer;
 declare class CanvasVectorTileLayerRenderer extends CanvasTileLayerRenderer<import("../../layer/VectorTile.js").default<import("../../source/VectorTile.js").default<import("../../Feature.js").FeatureLike>, import("../../Feature.js").FeatureLike>> {
     /**
      * @param {import("../../layer/VectorTile.js").default} layer VectorTile layer.
+     * @param {import("./TileLayer.js").Options} options Options.
      */
-    constructor(layer: import("../../layer/VectorTile.js").default);
+    constructor(layer: import("../../layer/VectorTile.js").default, options: import("./TileLayer.js").Options);
     /** @private */
     private boundHandleStyleImageChange_;
     /**
@@ -44,16 +45,15 @@ declare class CanvasVectorTileLayerRenderer extends CanvasTileLayerRenderer<impo
     private tileClipContexts_;
     /**
      * @param {import("../../VectorRenderTile.js").default} tile Tile.
-     * @param {number} pixelRatio Pixel ratio.
-     * @param {import("../../proj/Projection").default} projection Projection.
-     * @return {boolean|undefined} Tile needs to be rendered.
-     */
-    prepareTile(tile: import("../../VectorRenderTile.js").default, pixelRatio: number, projection: import("../../proj/Projection").default): boolean | undefined;
-    /**
-     * @param {import("../../VectorRenderTile.js").default} tile Tile.
-     * @return {boolean} Tile is drawable.
-     */
-    isDrawableTile(tile: import("../../VectorRenderTile.js").default): boolean;
+     * @param {import("../../Map.js").FrameState} frameState Frame state.
+     * @param {number} x Left of the tile.
+     * @param {number} y Top of the tile.
+     * @param {number} w Width of the tile.
+     * @param {number} h Height of the tile.
+     * @param {number} gutter Tile gutter.
+     * @param {boolean} transition Apply an alpha transition.
+     */
+    drawTile(tile: import("../../VectorRenderTile.js").default, frameState: import("../../Map.js").FrameState, x: number, y: number, w: number, h: number, gutter: number, transition: boolean): void;
     /**
      * @inheritDoc
      */

package/renderer/canvas/VectorTileLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VectorTileLayer.d.ts","sourceRoot":"","sources":["VectorTileLayer.js"],"names":[],"mappings":";AA4DA;;;;;GAKG;AACH;IACE;;OAEG;IACH,mBAFW,OAAO,2BAA2B,EAAE,OAAO,EA2CrD;IAtCC,eAAe;IACf,qCAA2E;IAE3E;;;OAGG;IACH,+BAA2B;IAE3B;;;OAGG;IACH,4CAA+C;IAE/C;;;OAGG;IACH,0BAAsB;IAEtB;;;OAGG;IACH,yBAAyB;IAEzB;;;OAGG;IACH,sBAAsC;IAEtC;;;OAGG;IACH,0BAA6B;IAG/B;;;;;OAKG;IACH,kBALW,OAAO,2BAA2B,EAAE,OAAO,cAC3C,MAAM,cACN,OAAO,uBAAuB,EAAE,OAAO,GACtC,OAAO,GAAC,SAAS,CAY5B;IAkCD;;;OAGG;IACH,qBAHW,OAAO,2BAA2B,EAAE,OAAO,GAC1C,OAAO,CAUlB;IAED;;OAEG;IACH,6BAEC;IAgBD;;;;;OAKG;IACH,6BAqHC;IAyND;;;;OAIG;IACH,gCAEC;IAED;;;;OAIG;IACH,4BAHW,OAAO,cAAc,EAAE,UAAU,cACjC,OAAO,sBAAsB,EAAE,KAAK,QAiC9C;IA0DD,6DA+BC;IAkID;;;;;;;;OAQG;IACH,uBARW,OAAO,kBAAkB,EAAE,WAAW,oBACtC,MAAM,UACN,OAAO,sBAAsB,EAAE,OAAO,GAAC,MAAM,OAAO,sBAAsB,EAAE,OAAO,CAAC,gBACpF,OAAO,qCAAqC,EAAE,OAAO,gEAGpD,OAAO,CAyClB;IAED;;;;OAIG;IACH,8BAcC;IAED;;;;OAIG;IACH,yBAwDC;CACF;oCAh6BmC,gBAAgB"}
+{"version":3,"file":"VectorTileLayer.d.ts","sourceRoot":"","sources":["VectorTileLayer.js"],"names":[],"mappings":";AA4DA;;;;;GAKG;AACH;IACE;;;OAGG;IACH,mBAHW,OAAO,2BAA2B,EAAE,OAAO,WAC3C,OAAO,gBAAgB,EAAE,OAAO,EA2C1C;IAtCC,eAAe;IACf,qCAA2E;IAE3E;;;OAGG;IACH,+BAA2B;IAE3B;;;OAGG;IACH,4CAA+C;IAE/C;;;OAGG;IACH,0BAAsB;IAEtB;;;OAGG;IACH,yBAAyB;IAEzB;;;OAGG;IACH,sBAAsC;IAEtC;;;OAGG;IACH,0BAA6B;IAG/B;;;;;;;;;OASG;IACH,eATW,OAAO,2BAA2B,EAAE,OAAO,cAC3C,OAAO,cAAc,EAAE,UAAU,KACjC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,cACN,OAAO,QAYjB;IA6BD;;OAEG;IACH,6BAEC;IAgBD;;;;;OAKG;IACH,6BAqHC;IAyND;;;;OAIG;IACH,gCAEC;IAED;;;;OAIG;IACH,4BAHW,OAAO,cAAc,EAAE,UAAU,cACjC,OAAO,sBAAsB,EAAE,KAAK,QAiC9C;IA0DD,6DAgCC;IAkID;;;;;;;;OAQG;IACH,uBARW,OAAO,kBAAkB,EAAE,WAAW,oBACtC,MAAM,UACN,OAAO,sBAAsB,EAAE,OAAO,GAAC,MAAM,OAAO,sBAAsB,EAAE,OAAO,CAAC,gBACpF,OAAO,qCAAqC,EAAE,OAAO,gEAGpD,OAAO,CAyClB;IAED;;;;OAIG;IACH,8BAcC;IAED;;;;OAIG;IACH,yBAwDC;CACF;oCAn5BmC,gBAAgB"}

package/renderer/canvas/VectorTileLayer.js

@@ -67,9 +67,10 @@ const VECTOR_REPLAYS = {
 class CanvasVectorTileLayerRenderer extends CanvasTileLayerRenderer {
   /**
    * @param {import("../../layer/VectorTile.js").default} layer VectorTile layer.
+   * @param {import("./TileLayer.js").Options} options Options.
    */
-  constructor(layer) {
-    super(layer);
+  constructor(layer, options) {
+    super(layer, options);
 
     /** @private */
     this.boundHandleStyleImageChange_ = this.handleStyleImageChange_.bind(this);
@@ -113,20 +114,24 @@ class CanvasVectorTileLayerRenderer extends CanvasTileLayerRenderer {
 
   /**
    * @param {import("../../VectorRenderTile.js").default} tile Tile.
-   * @param {number} pixelRatio Pixel ratio.
-   * @param {import("../../proj/Projection").default} projection Projection.
-   * @return {boolean|undefined} Tile needs to be rendered.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @param {number} x Left of the tile.
+   * @param {number} y Top of the tile.
+   * @param {number} w Width of the tile.
+   * @param {number} h Height of the tile.
+   * @param {number} gutter Tile gutter.
+   * @param {boolean} transition Apply an alpha transition.
    */
-  prepareTile(tile, pixelRatio, projection) {
-    let render;
-    const state = tile.getState();
-    if (state === TileState.LOADED || state === TileState.ERROR) {
-      this.updateExecutorGroup_(tile, pixelRatio, projection);
-      if (this.tileImageNeedsRender_(tile)) {
-        render = true;
-      }
+  drawTile(tile, frameState, x, y, w, h, gutter, transition) {
+    this.updateExecutorGroup_(
+      tile,
+      frameState.pixelRatio,
+      frameState.viewState.projection,
+    );
+    if (this.tileImageNeedsRender_(tile)) {
+      this.renderTileImage_(tile, frameState);
     }
-    return render;
+    super.drawTile(tile, frameState, x, y, w, h, gutter, transition);
   }
 
   /**
@@ -134,15 +139,18 @@ class CanvasVectorTileLayerRenderer extends CanvasTileLayerRenderer {
    * @param {number} x Tile coordinate x.
    * @param {number} y Tile coordinate y.
    * @param {import("../../Map.js").FrameState} frameState Frame state.
-   * @return {!import("../../Tile.js").default} Tile.
+   * @return {import("../../Tile.js").default|null} Tile (or null if outside source extent).
    */
   getTile(z, x, y, frameState) {
-    const pixelRatio = frameState.pixelRatio;
+    const tile = /** @type {import("../../VectorRenderTile.js").default} */ (
+      this.getOrCreateTile(z, x, y, frameState)
+    );
+    if (!tile) {
+      return null;
+    }
+
     const viewState = frameState.viewState;
     const resolution = viewState.resolution;
-    const projection = viewState.projection;
-    const layer = this.getLayer();
-    const tile = layer.getSource().getTile(z, x, y, pixelRatio, projection);
     const viewHints = frameState.viewHints;
     const hifi = !(
       viewHints[ViewHint.ANIMATING] || viewHints[ViewHint.INTERACTING]
@@ -150,29 +158,7 @@ class CanvasVectorTileLayerRenderer extends CanvasTileLayerRenderer {
     if (hifi || !tile.wantedResolution) {
       tile.wantedResolution = resolution;
     }
-    const render = this.prepareTile(tile, pixelRatio, projection);
-    if (
-      render &&
-      (hifi || Date.now() - frameState.time < 8) &&
-      layer.getRenderMode() !== 'vector'
-    ) {
-      this.renderTileImage_(tile, frameState);
-    }
-    return super.getTile(z, x, y, frameState);
-  }
-
-  /**
-   * @param {import("../../VectorRenderTile.js").default} tile Tile.
-   * @return {boolean} Tile is drawable.
-   */
-  isDrawableTile(tile) {
-    const layer = this.getLayer();
-    return (
-      super.isDrawableTile(tile) &&
-      (layer.getRenderMode() === 'vector'
-        ? getUid(layer) in tile.executorGroups
-        : tile.hasContext(layer))
-    );
+    return tile;
   }
 
   /**
@@ -243,7 +229,7 @@ class CanvasVectorTileLayerRenderer extends CanvasTileLayerRenderer {
       const builderExtent = buffer(
         sharedExtent,
         layer.getRenderBuffer() * resolution,
-        this.tmpExtent,
+        this.tempExtent,
       );
       const bufferedExtent = equals(sourceTileExtent, sharedExtent)
         ? null
@@ -656,7 +642,8 @@ class CanvasVectorTileLayerRenderer extends CanvasTileLayerRenderer {
     const tileCoord = tile.tileCoord;
     const tileExtent = tileGrid.getTileCoordExtent(tile.wrappedTileCoord);
     const worldOffset =
-      tileGrid.getTileCoordExtent(tileCoord, this.tmpExtent)[0] - tileExtent[0];
+      tileGrid.getTileCoordExtent(tileCoord, this.tempExtent)[0] -
+      tileExtent[0];
     const transform = multiply(
       scale(this.inversePixelTransform.slice(), 1 / pixelRatio, 1 / pixelRatio),
       this.getRenderTransform(
@@ -896,7 +883,7 @@ class CanvasVectorTileLayerRenderer extends CanvasTileLayerRenderer {
     const renderPixelRatio =
       (frameState.pixelRatio / tile.wantedResolution) * tileResolution;
     const resolution = tileGrid.getResolution(z);
-    const context = tile.getContext(layer);
+    const context = tile.getContext();
 
     // Increase tile size when overzooming for low pixel ratio, to avoid blurry tiles
     pixelRatio = Math.round(
@@ -911,7 +898,7 @@ class CanvasVectorTileLayerRenderer extends CanvasTileLayerRenderer {
       scaleTransform(canvasTransform, renderScale, renderScale);
       context.setTransform.apply(context, canvasTransform);
     }
-    const tileExtent = tileGrid.getTileCoordExtent(tileCoord, this.tmpExtent);
+    const tileExtent = tileGrid.getTileCoordExtent(tileCoord, this.tempExtent);
     const pixelScale = renderPixelRatio / resolution;
     const transform = resetTransform(this.tmpTransform_);
     scaleTransform(transform, pixelScale, -pixelScale);

package/renderer/webgl/TileLayerBase.d.ts

@@ -129,12 +129,6 @@ declare class WebGLBaseTileLayerRenderer<LayerType extends import("../../layer/B
      * @param {Options} options Options.
      */
     reset(options: Options): void;
-    /**
-     * @param {TileType} tile Tile.
-     * @return {boolean} Tile is drawable.
-     * @private
-     */
-    private isDrawableTile_;
     /**
      * @abstract
      * @param {import("../../webgl/BaseTileRepresentation.js").TileRepresentationOptions<TileType>} options tile representation options

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

@@ -1 +1 @@
-{"version":3,"file":"TileLayerBase.d.ts","sourceRoot":"","sources":["TileLayerBase.js"],"names":[],"mappings":"AAuDA;;GAEG;AACH;;;;GAIG;AAEH;;GAEG;AACH,+CAFY,wBAAwB,CAInC;AA0DD,iEAEC;;;;;;;;;;;;;;yCAzEY,OAAO,uCAAuC,EAAE,OAAO,CAAC,OAAO,eAAe,EAAE,OAAO,CAAC;;;;;aAIvF,IAAI,MAAM,CAAC;;;;;YACJ,MAAM,GAAE,6FAA+B;;;;;;;;;;;;;;;;;;;;;AAsE5D;;;;;;GAMG;AAEH;;GAEG;AAEH;;;;;;;GAOG;AACH;IACE;;;OAGG;IACH,uBAHW,SAAS,WACT,OAAO,EA+DjB;IAvDC;;;OAGG;IACH,gBAFU,OAAO,CAEU;IAE3B;;;;OAIG;IACH,uBAAuC;IAEvC;;;OAGG;IACH,oBAHU,MAAM,MAAM,CAAC,CAGK;IAE5B;;;OAGG;IACH,uBAA+C;IAE/C;;;OAGG;IACH,uBAA8C;IAE9C;;;OAGG;IACH,kBAAuB;IAGvB;;;OAGG;IACH,mCAHU,OAAO,2BAA2B,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAGnB;IAEtD;;;OAGG;IACH,sBAFU,OAAO,cAAc,EAAE,UAAU,GAAC,IAAI,CAE1B;IAEtB;;;OAGG;IACH,oBAA4B;IAG9B;;OAEG;IACH,eAFW,OAAO,QAMjB;IAED;;;;OAIG;IACH,wBASC;IA2BD;;;;;OAKG;IACH,4CAJW,OAAO,uCAAuC,EAAE,yBAAyB,CAAC,QAAQ,CAAC,GAClF,kBAAkB,CAK7B;IAED;;;;;;OAMG;IACH,yBANW,OAAO,cAAc,EAAE,UAAU,UACjC,OAAO,iBAAiB,EAAE,MAAM,YAChC,MAAM,4BACN,wBAAwB,WACxB,MAAM,QAyHhB;IAED;;;;OAIG;IACH,wCAJW,OAAO,cAAc,EAAE,UAAU,kBACjC,OAAO,QAKjB;IAED;;;;OAIG;IACH,4CAJW,OAAO,cAAc,EAAE,UAAU,GAChC,OAAO,CAKlB;IAED;;;;;;;;;;;;;OAaG;IACH,yCAbW,kBAAkB,iBAClB,OAAO,oBAAoB,EAAE,SAAS,cACtC,OAAO,cAAc,EAAE,UAAU,gBACjC,OAAO,iBAAiB,EAAE,MAAM,kBAChC,MAAM,YACN,OAAO,eAAe,EAAE,IAAI,cAC5B,OAAO,qBAAqB,EAAE,UAAU,cACxC,OAAO,iBAAiB,EAAE,MAAM,SAChC,MAAM,UACN,MAAM,SACN,MAAM,QAeb;IAEJ;;;;;;OAMG;IACH,6CANW,kBAAkB,SAClB,MAAM,UACN,OAAO,iBAAiB,EAAE,MAAM,SAChC,MAAM,QAG0C;IAE3D,iIAuEC;IAED;;;;OAIG;IACH,wBAHW,OAAO,cAAc,EAAE,UAAU,GAChC,WAAW,CAqNtB;IAED;;;;;;;;;;OAUG;IACH,sBAsCC;IAED,mBAMC;CAiBF;+BAnzB8B,YAAY"}
+{"version":3,"file":"TileLayerBase.d.ts","sourceRoot":"","sources":["TileLayerBase.js"],"names":[],"mappings":"AAuDA;;GAEG;AACH;;;;GAIG;AAEH;;GAEG;AACH,+CAFY,wBAAwB,CAInC;AA0DD,iEAEC;;;;;;;;;;;;;;yCAzEY,OAAO,uCAAuC,EAAE,OAAO,CAAC,OAAO,eAAe,EAAE,OAAO,CAAC;;;;;aAIvF,IAAI,MAAM,CAAC;;;;;YACJ,MAAM,GAAE,6FAA+B;;;;;;;;;;;;;;;;;;;;;AAsE5D;;;;;;GAMG;AAEH;;GAEG;AAEH;;;;;;;GAOG;AACH;IACE;;;OAGG;IACH,uBAHW,SAAS,WACT,OAAO,EA+DjB;IAvDC;;;OAGG;IACH,gBAFU,OAAO,CAEU;IAE3B;;;;OAIG;IACH,uBAAuC;IAEvC;;;OAGG;IACH,oBAHU,MAAM,MAAM,CAAC,CAGK;IAE5B;;;OAGG;IACH,uBAA+C;IAE/C;;;OAGG;IACH,uBAA8C;IAE9C;;;OAGG;IACH,kBAAuB;IAGvB;;;OAGG;IACH,mCAHU,OAAO,2BAA2B,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAGnB;IAEtD;;;OAGG;IACH,sBAFU,OAAO,cAAc,EAAE,UAAU,GAAC,IAAI,CAE1B;IAEtB;;;OAGG;IACH,oBAA4B;IAG9B;;OAEG;IACH,eAFW,OAAO,QAMjB;IA2BD;;;;;OAKG;IACH,4CAJW,OAAO,uCAAuC,EAAE,yBAAyB,CAAC,QAAQ,CAAC,GAClF,kBAAkB,CAK7B;IAED;;;;;;OAMG;IACH,yBANW,OAAO,cAAc,EAAE,UAAU,UACjC,OAAO,iBAAiB,EAAE,MAAM,YAChC,MAAM,4BACN,wBAAwB,WACxB,MAAM,QAqHhB;IAED;;;;OAIG;IACH,wCAJW,OAAO,cAAc,EAAE,UAAU,kBACjC,OAAO,QAKjB;IAED;;;;OAIG;IACH,4CAJW,OAAO,cAAc,EAAE,UAAU,GAChC,OAAO,CAKlB;IAED;;;;;;;;;;;;;OAaG;IACH,yCAbW,kBAAkB,iBAClB,OAAO,oBAAoB,EAAE,SAAS,cACtC,OAAO,cAAc,EAAE,UAAU,gBACjC,OAAO,iBAAiB,EAAE,MAAM,kBAChC,MAAM,YACN,OAAO,eAAe,EAAE,IAAI,cAC5B,OAAO,qBAAqB,EAAE,UAAU,cACxC,OAAO,iBAAiB,EAAE,MAAM,SAChC,MAAM,UACN,MAAM,SACN,MAAM,QAeb;IAEJ;;;;;;OAMG;IACH,6CANW,kBAAkB,SAClB,MAAM,UACN,OAAO,iBAAiB,EAAE,MAAM,SAChC,MAAM,QAG0C;IAE3D,iIAuEC;IAED;;;;OAIG;IACH,wBAHW,OAAO,cAAc,EAAE,UAAU,GAChC,WAAW,CAwNtB;IAED;;;;;;;;;;OAUG;IACH,sBAsCC;IAED,mBAMC;CAiBF;+BAlyB8B,YAAY"}

package/renderer/webgl/TileLayerBase.js

@@ -226,22 +226,6 @@ class WebGLBaseTileLayerRenderer extends WebGLLayerRenderer {
     });
   }
 
-  /**
-   * @param {TileType} tile Tile.
-   * @return {boolean} Tile is drawable.
-   * @private
-   */
-  isDrawableTile_(tile) {
-    const tileLayer = this.getLayer();
-    const tileState = tile.getState();
-    const useInterimTilesOnError = tileLayer.getUseInterimTilesOnError();
-    return (
-      tileState == TileState.LOADED ||
-      tileState == TileState.EMPTY ||
-      (tileState == TileState.ERROR && !useInterimTilesOnError)
-    );
-  }
-
   /**
    * Determine whether renderFrame should be called.
    * @param {import("../../Map.js").FrameState} frameState Frame state.
@@ -356,6 +340,9 @@ class WebGLBaseTileLayerRenderer extends WebGLLayerRenderer {
               frameState.pixelRatio,
               viewState.projection,
             );
+            if (!tile) {
+              continue;
+            }
           }
 
           if (lookupHasTile(tileRepresentationLookup, tile)) {
@@ -371,14 +358,7 @@ class WebGLBaseTileLayerRenderer extends WebGLLayerRenderer {
             });
             tileRepresentationCache.set(cacheKey, tileRepresentation);
           } else {
-            if (this.isDrawableTile_(tile)) {
-              tileRepresentation.setTile(tile);
-            } else {
-              const interimTile = /** @type {TileType} */ (
-                tile.getInterimTile()
-              );
-              tileRepresentation.setTile(interimTile);
-            }
+            tileRepresentation.setTile(tile);
           }
 
           addTileRepresentationToLookup(
@@ -601,60 +581,62 @@ class WebGLBaseTileLayerRenderer extends WebGLLayerRenderer {
     const time = frameState.time;
     let blend = false;
 
-    // look for cached tiles to use if a target tile is not ready
-    for (const tileRepresentation of tileRepresentationLookup
-      .representationsByZ[z]) {
-      const tile = tileRepresentation.tile;
-      if (
-        (tile instanceof ReprojTile || tile instanceof ReprojDataTile) &&
-        tile.getState() === TileState.EMPTY
-      ) {
-        continue;
-      }
-      const tileCoord = tile.tileCoord;
+    const representationsByZ = tileRepresentationLookup.representationsByZ;
 
-      if (tileRepresentation.ready) {
-        const alpha = tile.getAlpha(uid, time);
-        if (alpha === 1) {
-          // no need to look for alt tiles
-          tile.endTransition(uid);
+    // look for cached tiles to use if a target tile is not ready
+    if (z in representationsByZ) {
+      for (const tileRepresentation of representationsByZ[z]) {
+        const tile = tileRepresentation.tile;
+        if (
+          (tile instanceof ReprojTile || tile instanceof ReprojDataTile) &&
+          tile.getState() === TileState.EMPTY
+        ) {
           continue;
         }
-        blend = true;
-        const tileCoordKey = getTileCoordKey(tileCoord);
-        alphaLookup[tileCoordKey] = alpha;
-      }
-      this.renderComplete = false;
-
-      // first look for child tiles (at z + 1)
-      const coveredByChildren = this.findAltTiles_(
-        tileGrid,
-        tileCoord,
-        z + 1,
-        tileRepresentationLookup,
-      );
+        const tileCoord = tile.tileCoord;
 
-      if (coveredByChildren) {
-        continue;
-      }
+        if (tileRepresentation.ready) {
+          const alpha = tile.getAlpha(uid, time);
+          if (alpha === 1) {
+            // no need to look for alt tiles
+            tile.endTransition(uid);
+            continue;
+          }
+          blend = true;
+          const tileCoordKey = getTileCoordKey(tileCoord);
+          alphaLookup[tileCoordKey] = alpha;
+        }
+        this.renderComplete = false;
 
-      // next look for parent tiles
-      const minZoom = tileGrid.getMinZoom();
-      for (let parentZ = z - 1; parentZ >= minZoom; --parentZ) {
-        const coveredByParent = this.findAltTiles_(
+        // first look for child tiles (at z + 1)
+        const coveredByChildren = this.findAltTiles_(
           tileGrid,
           tileCoord,
-          parentZ,
+          z + 1,
           tileRepresentationLookup,
         );
 
-        if (coveredByParent) {
-          break;
+        if (coveredByChildren) {
+          continue;
+        }
+
+        // next look for parent tiles
+        const minZoom = tileGrid.getMinZoom();
+        for (let parentZ = z - 1; parentZ >= minZoom; --parentZ) {
+          const coveredByParent = this.findAltTiles_(
+            tileGrid,
+            tileCoord,
+            parentZ,
+            tileRepresentationLookup,
+          );
+
+          if (coveredByParent) {
+            break;
+          }
         }
       }
     }
 
-    const representationsByZ = tileRepresentationLookup.representationsByZ;
     const zs = Object.keys(representationsByZ).map(Number).sort(descending);
 
     const renderTileMask = this.beforeTilesMaskRender(frameState);
@@ -703,19 +685,21 @@ class WebGLBaseTileLayerRenderer extends WebGLLayerRenderer {
       }
     }
 
-    for (const tileRepresentation of representationsByZ[z]) {
-      const tileCoord = tileRepresentation.tile.tileCoord;
-      const tileCoordKey = getTileCoordKey(tileCoord);
-      if (tileCoordKey in alphaLookup) {
-        this.drawTile_(
-          frameState,
-          tileRepresentation,
-          z,
-          gutter,
-          extent,
-          alphaLookup,
-          tileGrid,
-        );
+    if (z in representationsByZ) {
+      for (const tileRepresentation of representationsByZ[z]) {
+        const tileCoord = tileRepresentation.tile.tileCoord;
+        const tileCoordKey = getTileCoordKey(tileCoord);
+        if (tileCoordKey in alphaLookup) {
+          this.drawTile_(
+            frameState,
+            tileRepresentation,
+            z,
+            gutter,
+            extent,
+            alphaLookup,
+            tileGrid,
+          );
+        }
       }
     }
 
@@ -741,7 +725,6 @@ class WebGLBaseTileLayerRenderer extends WebGLLayerRenderer {
      * @param {import("../../Map.js").FrameState} frameState Frame state.
      */
     const postRenderFunction = function (map, frameState) {
-      tileSource.updateCacheSize(0.1, frameState.viewState.projection);
       tileSource.expireCache(frameState.viewState.projection, empty);
     };
 

package/reproj/DataTile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DataTile.d.ts","sourceRoot":"","sources":["DataTile.js"],"names":[],"mappings":";gCAoBsB,MAAM,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,KAAI,OAAO,gBAAgB,EAAE,OAAO;;;;;UAK1E,QAAQ;;;;YACR,MAAM;;;;;;gBAKN,OAAO,uBAAuB,EAAE,OAAO;;;;oBACvC,OAAO,yBAAyB,EAAE,OAAO;;;;gBACzC,OAAO,uBAAuB,EAAE,OAAO;;;;oBACvC,OAAO,yBAAyB,EAAE,OAAO;;;;eACzC,OAAO,iBAAiB,EAAE,SAAS;;;;;;;;gBAEnC,MAAM;;;;YACN,MAAM;;;;qBACN,UAAU;;;;;;;;;;;;;;;;AApBxB;;GAEG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;GAKG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAyNjB;IA/MC;;;OAGG;IACH,oBAAqC;IAErC;;;OAGG;IACH,gBAA6B;IAE7B;;;OAGG;IACH,oBAAuB;IAEvB;;;OAGG;IACH,qBAAwB;IAExB;;;OAGG;IACH,oBAA4B;IAE5B;;;OAGG;IACH,wBAA6C;IAE7C;;;OAGG;IACH,wBAA6C;IAE7C;;;OAGG;IACH,0BAAsE;IAEtE;;;OAGG;IACH,qBAAsB;IAEtB;;;OAGG;IACH,6BAAgC;IAEhC;;;OAGG;IACH,iBAAiB;IAMjB;;;OAGG;IACH,oBAIwB;IAmDxB;;;OAGG;IACH,uBAOC;IA6FH;;OAEG;IACH,mBAiLC;IAyDD;;OAEG;IACH,yBAGC;CACF;qBAzhByD,gBAAgB"}
+{"version":3,"file":"DataTile.d.ts","sourceRoot":"","sources":["DataTile.js"],"names":[],"mappings":";gCAoBsB,MAAM,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,KAAI,OAAO,gBAAgB,EAAE,OAAO;;;;;UAK1E,QAAQ;;;;YACR,MAAM;;;;;;gBAKN,OAAO,uBAAuB,EAAE,OAAO;;;;oBACvC,OAAO,yBAAyB,EAAE,OAAO;;;;gBACzC,OAAO,uBAAuB,EAAE,OAAO;;;;oBACvC,OAAO,yBAAyB,EAAE,OAAO;;;;eACzC,OAAO,iBAAiB,EAAE,SAAS;;;;;;;;gBAEnC,MAAM;;;;YACN,MAAM;;;;qBACN,UAAU;;;;;;;;;;;;;;;;AApBxB;;GAEG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;GAKG;AACH;IACE;;OAEG;IACH,qBAFW,OAAO,EAyNjB;IA/MC;;;OAGG;IACH,oBAAqC;IAErC;;;OAGG;IACH,gBAA6B;IAE7B;;;OAGG;IACH,oBAAuB;IAEvB;;;OAGG;IACH,qBAAwB;IAExB;;;OAGG;IACH,oBAA4B;IAE5B;;;OAGG;IACH,wBAA6C;IAE7C;;;OAGG;IACH,wBAA6C;IAE7C;;;OAGG;IACH,0BAAsE;IAEtE;;;OAGG;IACH,qBAAsB;IAEtB;;;OAGG;IACH,6BAAgC;IAEhC;;;OAGG;IACH,iBAAiB;IAMjB;;;OAGG;IACH,oBAIwB;IAmDxB;;;OAGG;IACH,uBAOC;IA6FH;;OAEG;IACH,mBAoLC;IAyDD;;OAEG;IACH,yBAGC;CACF;qBA5hByD,gBAAgB"}

package/reproj/DataTile.js

@@ -58,7 +58,7 @@ class ReprojDataTile extends DataTile {
   constructor(options) {
     super({
       tileCoord: options.tileCoord,
-      loader: () => Promise.resolve(new Uint8Array(4)),
+      loader: () => Promise.resolve(new Uint8ClampedArray(4)),
       interpolate: options.interpolate,
       transition: options.transition,
     });
@@ -301,6 +301,7 @@ class ReprojDataTile extends DataTile {
    */
   reproject_() {
     const dataSources = [];
+    let imageLike = false;
     this.sourceTiles_.forEach((source) => {
       const tile = source.tile;
       if (!tile || tile.getState() !== TileState.LOADED) {
@@ -316,12 +317,13 @@ class ReprojDataTile extends DataTile {
       if (arrayData) {
         tileData = arrayData;
       } else {
+        imageLike = true;
         tileData = toArray(asImageLike(tile.getData()));
       }
       const pixelSize = [size[0] + 2 * gutter, size[1] + 2 * gutter];
       const isFloat = tileData instanceof Float32Array;
       const pixelCount = pixelSize[0] * pixelSize[1];
-      const DataType = isFloat ? Float32Array : Uint8Array;
+      const DataType = isFloat ? Float32Array : Uint8ClampedArray;
       const tileDataR = new DataType(tileData.buffer);
       const bytesPerElement = DataType.BYTES_PER_ELEMENT;
       const bytesPerPixel = (bytesPerElement * tileDataR.length) / pixelCount;
@@ -354,7 +356,7 @@ class ReprojDataTile extends DataTile {
       dataSources.push({
         extent: extent,
         clipExtent: clipExtent,
-        data: new Uint8Array(packedData.buffer),
+        data: new Uint8ClampedArray(packedData.buffer),
         dataType: DataType,
         bytesPerPixel: bytesPerPixel,
         pixelSize: pixelSize,
@@ -364,117 +366,118 @@ class ReprojDataTile extends DataTile {
 
     if (dataSources.length === 0) {
       this.state = TileState.ERROR;
-    } else {
-      const z = this.wrappedTileCoord_[0];
-      const size = this.targetTileGrid_.getTileSize(z);
-      const targetWidth = typeof size === 'number' ? size : size[0];
-      const targetHeight = typeof size === 'number' ? size : size[1];
-      const targetResolution = this.targetTileGrid_.getResolution(z);
-      const sourceResolution = this.sourceTileGrid_.getResolution(
-        this.sourceZ_,
-      );
-
-      const targetExtent = this.targetTileGrid_.getTileCoordExtent(
-        this.wrappedTileCoord_,
-      );
+      this.changed();
+      return;
+    }
 
-      let dataR, dataU;
-
-      const bytesPerPixel = dataSources[0].bytesPerPixel;
-
-      const reprojs = Math.ceil(bytesPerPixel / 3);
-      for (let reproj = reprojs - 1; reproj >= 0; --reproj) {
-        const sources = [];
-        for (let i = 0, len = dataSources.length; i < len; ++i) {
-          const dataSource = dataSources[i];
-          const buffer = dataSource.data;
-          const pixelSize = dataSource.pixelSize;
-          const width = pixelSize[0];
-          const height = pixelSize[1];
-          const context = createCanvasContext2D(width, height, canvasPool);
-          const imageData = context.createImageData(width, height);
-          const data = imageData.data;
-          let offset = reproj * 3;
-          for (let j = 0, len = data.length; j < len; j += 4) {
-            data[j] = buffer[offset];
-            data[j + 1] = buffer[offset + 1];
-            data[j + 2] = buffer[offset + 2];
-            data[j + 3] = 255;
-            offset += bytesPerPixel;
-          }
-          context.putImageData(imageData, 0, 0);
-          sources.push({
-            extent: dataSource.extent,
-            clipExtent: dataSource.clipExtent,
-            image: context.canvas,
-          });
-        }
+    const z = this.wrappedTileCoord_[0];
+    const size = this.targetTileGrid_.getTileSize(z);
+    const targetWidth = typeof size === 'number' ? size : size[0];
+    const targetHeight = typeof size === 'number' ? size : size[1];
+    const targetResolution = this.targetTileGrid_.getResolution(z);
+    const sourceResolution = this.sourceTileGrid_.getResolution(this.sourceZ_);
 
-        const canvas = renderReprojected(
-          targetWidth,
-          targetHeight,
-          this.pixelRatio_,
-          sourceResolution,
-          this.sourceTileGrid_.getExtent(),
-          targetResolution,
-          targetExtent,
-          this.triangulation_,
-          sources,
-          this.gutter_,
-          false,
-          false,
-          false,
-          //true,
-        );
+    const targetExtent = this.targetTileGrid_.getTileCoordExtent(
+      this.wrappedTileCoord_,
+    );
 
-        for (let i = 0, len = sources.length; i < len; ++i) {
-          const canvas = sources[i].image;
-          const context = canvas.getContext('2d');
-          releaseCanvas(context);
-          canvasPool.push(context.canvas);
+    let dataR, dataU;
+
+    const bytesPerPixel = dataSources[0].bytesPerPixel;
+
+    const reprojs = Math.ceil(bytesPerPixel / 3);
+    for (let reproj = reprojs - 1; reproj >= 0; --reproj) {
+      const sources = [];
+      for (let i = 0, len = dataSources.length; i < len; ++i) {
+        const dataSource = dataSources[i];
+        const buffer = dataSource.data;
+        const pixelSize = dataSource.pixelSize;
+        const width = pixelSize[0];
+        const height = pixelSize[1];
+        const context = createCanvasContext2D(width, height, canvasPool);
+        const imageData = context.createImageData(width, height);
+        const data = imageData.data;
+        let offset = reproj * 3;
+        for (let j = 0, len = data.length; j < len; j += 4) {
+          data[j] = buffer[offset];
+          data[j + 1] = buffer[offset + 1];
+          data[j + 2] = buffer[offset + 2];
+          data[j + 3] = 255;
+          offset += bytesPerPixel;
         }
+        context.putImageData(imageData, 0, 0);
+        sources.push({
+          extent: dataSource.extent,
+          clipExtent: dataSource.clipExtent,
+          image: context.canvas,
+        });
+      }
 
-        const context = canvas.getContext('2d');
-        const imageData = context.getImageData(
-          0,
-          0,
-          canvas.width,
-          canvas.height,
-        );
+      const canvas = renderReprojected(
+        targetWidth,
+        targetHeight,
+        this.pixelRatio_,
+        sourceResolution,
+        this.sourceTileGrid_.getExtent(),
+        targetResolution,
+        targetExtent,
+        this.triangulation_,
+        sources,
+        this.gutter_,
+        false,
+        false,
+        false,
+      );
 
+      for (let i = 0, len = sources.length; i < len; ++i) {
+        const canvas = sources[i].image;
+        const context = canvas.getContext('2d');
         releaseCanvas(context);
-        canvasPool.push(canvas);
+        canvasPool.push(context.canvas);
+      }
 
-        if (!dataR) {
-          dataU = new Uint8Array(
-            bytesPerPixel * imageData.width * imageData.height,
-          );
-          dataR = new dataSources[0].dataType(dataU.buffer);
-        }
+      const context = canvas.getContext('2d');
+      const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
 
-        const data = imageData.data;
-        let offset = reproj * 3;
-        for (let i = 0, len = data.length; i < len; i += 4) {
-          if (data[i + 3] === 255) {
-            dataU[offset] = data[i];
-            dataU[offset + 1] = data[i + 1];
-            dataU[offset + 2] = data[i + 2];
-          } else {
-            dataU[offset] = 0;
-            dataU[offset + 1] = 0;
-            dataU[offset + 2] = 0;
-          }
-          offset += bytesPerPixel;
+      releaseCanvas(context);
+      canvasPool.push(canvas);
+
+      if (!dataR) {
+        dataU = new Uint8ClampedArray(
+          bytesPerPixel * imageData.width * imageData.height,
+        );
+        dataR = new dataSources[0].dataType(dataU.buffer);
+      }
+
+      const data = imageData.data;
+      let offset = reproj * 3;
+      for (let i = 0, len = data.length; i < len; i += 4) {
+        if (data[i + 3] === 255) {
+          dataU[offset] = data[i];
+          dataU[offset + 1] = data[i + 1];
+          dataU[offset + 2] = data[i + 2];
+        } else {
+          dataU[offset] = 0;
+          dataU[offset + 1] = 0;
+          dataU[offset + 2] = 0;
         }
+        offset += bytesPerPixel;
       }
+    }
 
+    if (imageLike) {
+      const context = createCanvasContext2D(targetWidth, targetHeight);
+      const imageData = new ImageData(dataR, targetWidth);
+      context.putImageData(imageData, 0, 0);
+      this.reprojData_ = context.canvas;
+    } else {
       this.reprojData_ = dataR;
-      this.reprojSize_ = [
-        Math.round(targetWidth * this.pixelRatio_),
-        Math.round(targetHeight * this.pixelRatio_),
-      ];
-      this.state = TileState.LOADED;
     }
+    this.reprojSize_ = [
+      Math.round(targetWidth * this.pixelRatio_),
+      Math.round(targetHeight * this.pixelRatio_),
+    ];
+    this.state = TileState.LOADED;
     this.changed();
   }