Define how much to slice and how much to scale

src/geo/projection/covering_tiles.ts

@@ -50,11 +50,6 @@ export type CoveringTilesOptionsInternal = CoveringTilesOptions & {
      * its zoom set to the overscaled greater zoom. When false, such tiles will have zoom set to `maxzoom`.
      */
     reparseOverscaled?: boolean;
-    /**
-     * For vector tiles, geojsonvt is used to increase performance by providing sub-tile grids greater than source maxzoom, 
-     * therefore bypassing the need for overscaling past source maxzoom using overscaled tileIDs.
-     */
-    bypassOverscaling?: boolean;
     /**
      * When terrain is present, tile visibility will be computed in regards to the min and max elevations for each tile.
      */
@@ -196,7 +191,7 @@ export function coveringTiles(transform: IReadonlyTransform, options: CoveringTi
 
     const desiredZ = coveringZoomLevel(transform, options);
     const minZoom = options.minzoom || 0;
-    const maxZoom = options.bypassOverscaling ? transform.maxZoom : options.maxzoom ?? transform.maxZoom;
+    const maxZoom = options.maxzoom !== undefined ? options.maxzoom : transform.maxZoom;
     const nominalZ = Math.min(Math.max(0, desiredZ), maxZoom);
 
     const numTiles = Math.pow(2, nominalZ);

src/source/source_cache.ts

@@ -547,12 +547,13 @@ export class SourceCache extends Evented {
             idealTileIDs = coveringTiles(transform, {
                 tileSize: this.usedForTerrain ? this.tileSize : this._source.tileSize,
                 minzoom: this._source.minzoom,
-                maxzoom: this._source.maxzoom,
+                maxzoom: (this._source.type === 'vector' && this.map._overzoomingScalingZoomLevelsNumber)
+                    ? transform.maxZoom - this.map._overzoomingScalingZoomLevelsNumber
+                    : this._source.maxzoom,
                 roundZoom: this.usedForTerrain ? false : this._source.roundZoom,
                 reparseOverscaled: this._source.reparseOverscaled,
                 terrain,
                 calculateTileZoom: this._source.calculateTileZoom,
-                bypassOverscaling: this._source.type === 'vector' && this.map._overzoomingByClippingTiles
             });
 
             if (this._source.hasTile) {

src/source/vector_tile_source.ts

@@ -238,21 +238,23 @@ export class VectorTileSource extends Evented implements Source {
     }
 
     /**
-     * When the requested tile has a higher canonical Z than source maxzoom, pass overzoom parameters so worker can load the
-     * deepest tile at source max zoom to generate sub tiles using geojsonvt for highest performance on vector overscaling
+     * @See {@link WorkerTileParameters.overzoomParameters}
+     * @param tile - The tile being loaded
+     * @returns the overzoom parameters or undefined if not overzooming
      */
     private _getOverzoomParameters(tile: Tile): OverzoomParameters | undefined {
         if (tile.tileID.canonical.z <= this.maxzoom) {
             return undefined;
         }
+        if (this.map._overzoomingScalingZoomLevelsNumber === undefined) {
+            return undefined;
+        }
         const maxZoomTileID = tile.tileID.scaledTo(this.maxzoom).canonical;
         const maxZoomTileUrl = maxZoomTileID.url(this.tiles, this.map.getPixelRatio(), this.scheme);
 
         return {
             maxZoomTileID,
             overzoomRequest: this.map._requestManager.transformRequest(maxZoomTileUrl, ResourceType.Tile),
-            maxOverzoom: this.map.getMaxZoom(),
-            tileSize: this.tileSize
         };
     }
 

src/source/worker_source.ts

@@ -42,8 +42,7 @@ export type WorkerTileParameters = TileParameters & {
     subdivisionGranularity: SubdivisionGranularitySetting;
     /**
      * Provide this property when the requested tile has a higher canonical Z than source maxzoom.
-     * This allows the loading of the deepest source tile at source max zoom, and then using geojsonvt to generate sub tile grids for overzooming.
-     * This provides higher performance on vector layer overscaling.
+     * This allows the worker to know that it needs to overzoom from a source tile.
      */
     overzoomParameters?: OverzoomParameters;
 };
@@ -54,8 +53,6 @@ export type WorkerTileParameters = TileParameters & {
 export type OverzoomParameters = {
     maxZoomTileID: CanonicalTileID;
     overzoomRequest: RequestParameters;
-    maxOverzoom: number;
-    tileSize: number;
 };
 
 /**

src/ui/map.ts

@@ -1,4 +1,4 @@
-import {extend, warnOnce, uniqueId, isImageBitmap, type Complete, pick, type Subscription, isSafari} from '../util/util';
+import {extend, warnOnce, uniqueId, isImageBitmap, type Complete, pick, type Subscription} from '../util/util';
 import {browser} from '../util/browser';
 import {now} from '../util/time_control';
 import {DOM} from '../util/dom';
@@ -372,15 +372,15 @@ export type MapOptions = {
     centerClampedToGround?: boolean;
     /**
      * Allows overzooming using by splitting vector tiles after max zoom.
-     * When set to `true` this has better performance at high zoom levels and prevents Safari from crashing.
-     * The default is `false` for most cases as it changes rendering of polygon features at high zoom levels due to tile splitting.
-     * If `true`, tiles over the source's maxzoom will be split using into subtiles (partitioning).
-     * if `false`, tiles will be overzoomed using scaling.
-     * @defaultValue `true` for Safari to prevent crashes and `false` for other browsers
+     * This will stop this behavior and use overscaling for the given number of zoom levels specified.
+     * For example, if source maxzoom is 10 and map max zoom is 20, with this option set to 3,
+     * tiles will be clipped at zoom 17 and overscaled from there to 20.
+     * This improves performance at high zoom levels and prevents Safari from crashing.
+     * @defaultValue 4
      * This may change or be removed in future versions.
      * @experimental
      */
-    experimentalOverzoomingByClippingTiles?: boolean;
+    experimentalOverzoomingMaxZoomLevels?: number;
 };
 
 export type AddImageOptions = {
@@ -466,7 +466,7 @@ const defaultOptions: Readonly<Partial<MapOptions>> = {
     maxCanvasSize: [4096, 4096],
     cancelPendingTileRequestsWhileZooming: true,
     centerClampedToGround: true,
-    experimentalOverzoomingByClippingTiles: isSafari(globalThis) ? true : false
+    experimentalOverzoomingMaxZoomLevels: 4
 };
 
 /**
@@ -551,7 +551,7 @@ export class Map extends Camera {
     _maxCanvasSize: [number, number];
     _terrainDataCallback: (e: MapStyleDataEvent | MapSourceDataEvent) => void;
     /** @internal */
-    _overzoomingByClippingTiles: boolean;
+    _overzoomingScalingZoomLevelsNumber: number;
     /**
      * @internal
      * image queue throttling handle. To be used later when clean up
@@ -692,7 +692,7 @@ export class Map extends Camera {
         this._clickTolerance = resolvedOptions.clickTolerance;
         this._overridePixelRatio = resolvedOptions.pixelRatio;
         this._maxCanvasSize = resolvedOptions.maxCanvasSize;
-        this._overzoomingByClippingTiles = resolvedOptions.experimentalOverzoomingByClippingTiles === true;
+        this._overzoomingScalingZoomLevelsNumber = resolvedOptions.experimentalOverzoomingMaxZoomLevels;
         this.transformCameraUpdate = resolvedOptions.transformCameraUpdate;
         this.transformConstrain = resolvedOptions.transformConstrain;
         this.cancelPendingTileRequestsWhileZooming = resolvedOptions.cancelPendingTileRequestsWhileZooming === true;