maplibre-gl 6.7.0 → 6.8.0

package/dist/maplibre-gl-dev.mjs

@@ -1,10 +1,10 @@
 /**
 * MapLibre GL JS
-* @license 3-Clause BSD. Full text of license: https://github.com/maplibre/maplibre-gl-js/blob/v6.7.0/LICENSE.txt
+* @license 3-Clause BSD. Full text of license: https://github.com/maplibre/maplibre-gl-js/blob/v6.8.0/LICENSE.txt
 */
-import { $ as maxMercatorHorizonAngle, $n as createVec3f64, $r as multiply$1, $t as DataConstantProperty, A as evaluateSizeForFeature, Ai as multiply, An as getJSON, Ar as rayPlaneIntersection, At as isCircleStyleLayer, Bi as create$2, Bn as isAbortError, Br as uniqueId, Bt as UniformFloatArray, C as isCustomStyleLayer, Ci as copy, Cn as latest, Cr as mapObject, Ct as Texture, D as SymbolBucket, Di as fromScaling, Dn as AJAXError, Dr as pick, Dt as renderColorRamp, E as isSymbolStyleLayer, Ei as exactEquals, En as Evented, Er as parseCacheControl, Et as isHeatmapStyleLayer, F as ImagePosition, Fi as rotateZ, Fn as addProtocol, Fr as scaleZoom, Ft as Uniform2f, Gi as offscreenCanvasSupported, Gn as arrayBufferToImage, Gr as EXTENT, Gt as LineStripIndexArray, H as collisionCircleLayout, Hi as invert, Hr as wrap, Ht as SegmentVector, I as potpack, Ii as scale, In as getProtocol, Ir as sphericalToCartesian, It as Uniform3f, J as calculateTileMatrix, Jn as clamp, Jr as scale$1, Jt as QuadTriangleArray, K as isFillExtrusionStyleLayer, Ki as Point, Kn as arrayBufferToImageBitmap, Kr as create$3, Kt as Pos3dArray, L as isStyleImageWebGLData, Li as translate, Ln as removeProtocol, Lr as subscribe, Lt as Uniform4f, Mi as perspective, Mn as getVideo, Mr as remapSaturate, Mt as toEvaluationFeature, N as getAnchorAlignment, Ni as rotateX, Nn as makeRequest, Nr as rollPitchBearingEqual, Nt as Uniform1f, O as addDynamicAttributes, Oi as identity, On as GLOBAL_DISPATCHER_ID, Or as pointPlaneSignedDistance, Ot as AlphaImage, Pi as rotateY$1, Pn as sameOrigin, Pr as rollPitchBearingToQuat, Pt as Uniform1i, Q as getMercatorHorizon, Qn as createMat4f64, Qr as fromValues, Qt as isRasterStyleLayer, R as renderStyleImage, Ri as create$4, Rn as config, Rr as threePlaneIntersection, Rt as UniformColor, S as createStyleLayer, Si as clone$1, Sn as derefLayers, Sr as lerp, T as isBackgroundStyleLayer, Ti as equals, Tn as Event, Tr as nextPowerOfTwo, Tt as HEATMAP_FULL_RENDER_FBO_KEY, U as isLineStyleLayer, Ui as rotate, Un as MAX_VALID_LATITUDE, Ur as zoomScale, Ut as CollisionBoxArray, V as isCluster, Vi as determinant, Vn as throwIfAborted, Vr as warnOnce, Vt as UniformMatrix4f, Wi as isOffscreenCanvasDistorted, Wn as angleToRotateBetweenVectors2D, Wr as pixelsToTileUnits, Wt as CollisionCircleLayoutArray, X as cameraMercatorCoordinate, Xn as createIdentityMat4f32, Xr as zero, Xt as TriangleIndexArray, Y as cameraDirectionFromPitchBearing, Yn as clone$2, Yr as sqrLen, Yt as RasterBoundsArray, Z as cameraMercatorCoordinateFromCenterAndRotation, Zn as createIdentityMat4f64, Zr as fromEuler, Zt as createLayout, _ as UnwrappedTileID, _i as sub, _n as interpolateFactory, _r as isPointableEvent, _t as NORTH_POLE_Y, a as clipLine, ai as clone, an as codePointUsesLocalIdeographFontFamily, ar as distanceOfAnglesRadians, at as latFromMercatorY, b as isInBoundsForZoomLngLat, bi as transformQuat, bn as ValidationError, br as isTouchableOrPointableType, bt as SubdivisionGranularitySetting, ci as len, cn as SPEC_SOURCE_TYPES, cr as extend, ct as mercatorYfromLat, di as normalize, dn as validateStyle, dr as getAABB, dt as earthRadius, ei as slerp, en as Properties, er as createVec4f64, et as projectToWorldCoordinates, f as GEOJSON_TILE_LAYER_NAME, fi as rotateX$1, fn as validateStyleAndEmit, fr as getAngleDelta, g as OverscaledTileID, gi as scaleAndAdd, gr as isImageBitmap, h as CanonicalTileID, hi as scale$2, hn as featureFilter, hr as getRollPitchBearing, ht as isFillStyleLayer, ii as add, ir as differenceOfAnglesDegrees, it as altitudeFromMercatorZ, j as evaluateSizeForZoom, ji as ortho, jn as getReferrer, jr as readImageUsingVideoFrame, jt as polygonIntersectsPolygon, k as getOverlapMode, ki as invert$1, kn as getArrayBuffer, kr as radiansToDegrees, kt as RGBAImage, li as length$1, ln as emitValidationErrors, lr as filterObject, lt as mercatorZfromAltitude, mi as rotateZ$1, mt as Bounds, ni as scale$3, nn as Transitionable, nr as defaultEasing, nt as unprojectFromWorldCoordinates, oi as cross, on as ZoomHistory, or as ensureError, ot as lngFromMercatorX, pi as rotateY, pn as emptyStyle, pr as getEdgeTiles, pt as EXTENT_BOUNDS, qn as bezier, qr as length, qt as PosArray, r as TextAnchorEnum, ri as transformMat4, rn as EvaluationParameters, rr as degreesToRadians, rt as MercatorCoordinate, s as TileCache, si as dot, sr as evaluateZoomSnap, st as mercatorXfromLng, t as getAnchorJustification, ti as mul, tn as TRANSITION_SUFFIX, tr as deepEqual, tt as tileCoordinatesToMercatorCoordinates, u as GeoJSONFeature, ui as negate, un as validateAndEmit, ur as findLineIntersection, ut as LngLat, v as calculateTileKey, vi as transformMat3, vn as ProjectionDefinition, vr as isSafari, vt as SOUTH_POLE_Y, w as validateCustomStyleLayer, wi as create$1, wn as ErrorEvent, wr as mod, wt as isHillshadeStyleLayer, x as Actor, xi as zero$1, xn as diff, xr as isWorker, xt as isColorReliefStyleLayer, y as compareTileId, yi as transformMat4$1, yn as Color, yr as isTouchableEvent, yt as SubdivisionGranularityExpression, z as parseGlyphPbf, zi as fromRotation, zn as AbortError, zr as translatePosition, zt as UniformColorArray } from "./maplibre-gl-shared-dev.mjs";
+import { $ as unprojectFromWorldCoordinates, $n as degreesToRadians, $r as transformMat4, $t as EvaluationParameters, A as evaluateSizeForZoom, Ai as perspective, An as sameOrigin, Ar as rollPitchBearingToQuat, At as Uniform1i, B as isCluster, Bi as invert, Bn as angleToRotateBetweenVectors2D, Br as pixelsToTileUnits, Bt as CollisionCircleLayoutArray, C as addDynamicAttributes, Ci as equals, Cn as AJAXError, Cr as pick, Ct as renderColorRamp, Di as invert$1, Dn as getReferrer, Dr as readImageUsingVideoFrame, Dt as polygonIntersectsPolygon, E as TextAnchorEnum, Ei as identity, En as getJSON, Er as rayPlaneIntersection, Et as isCircleStyleLayer, F as potpack, Fi as translate, Fn as AbortError, Fr as translatePosition, Ft as UniformColorArray, G as calculateTileMatrix, Gn as clone$2, Gr as sqrLen, Gt as RasterBoundsArray, H as isLineStyleLayer, Hi as isOffscreenCanvasDistorted, Hn as arrayBufferToImageBitmap, Hr as create$3, Ht as Pos3dArray, I as isStyleImageWebGLData, Ii as create$4, In as isAbortError, Ir as uniqueId, It as UniformFloatArray, J as cameraMercatorCoordinateFromCenterAndRotation, Jn as createMat4f64, Jr as fromValues, Jt as isRasterStyleLayer, K as cameraDirectionFromPitchBearing, Kn as createIdentityMat4f32, Kr as zero, Kt as TriangleIndexArray, L as renderStyleImage, Li as fromRotation, Ln as throwIfAborted, Lr as warnOnce, Lt as UniformMatrix4f, M as getAnchorAlignment, Mi as rotateY$1, Mn as getProtocol, Mr as sphericalToCartesian, Mt as Uniform3f, Ni as rotateZ, Nn as removeProtocol, Nr as subscribe, Nt as Uniform4f, O as clipLine, Oi as multiply, On as getVideo, Or as remapSaturate, Ot as toEvaluationFeature, P as ImagePosition, Pi as scale, Pn as config, Pr as threePlaneIntersection, Pt as UniformColor, Q as tileCoordinatesToMercatorCoordinates, Qn as defaultEasing, Qr as scale$2, Qt as Transitionable, R as parseGlyphPbf, Ri as create$2, Rr as wrap, Rt as SegmentVector, S as SymbolBucket, Si as create$1, Sn as Evented, Sr as parseCacheControl, St as isHeatmapStyleLayer, T as getAnchorJustification, Ti as fromScaling, Tn as getArrayBuffer, Tr as radiansToDegrees, Tt as RGBAImage, Ui as offscreenCanvasSupported, Un as bezier, Ur as length$1, Ut as PosArray, V as collisionCircleLayout, Vi as rotate, Vn as arrayBufferToImage, Vr as EXTENT, Vt as LineStripIndexArray, W as isFillExtrusionStyleLayer, Wi as Point, Wn as clamp, Wr as scale$3, Wt as QuadTriangleArray, X as maxMercatorHorizonAngle, Xn as createVec4f64, Xr as slerp, Xt as Properties, Y as getMercatorHorizon, Yn as createVec3f64, Yr as multiply$1, Yt as DataConstantProperty, Z as projectToWorldCoordinates, Zn as deepEqual, Zr as mul, Zt as TRANSITION_SUFFIX, _ as createStyleLayer, _i as transformMat4$1, _n as diff, _r as isWorker, _t as isColorReliefStyleLayer, a as GeoJSONFeature, ai as len, an as emitValidationErrors, ar as filterObject, at as mercatorYfromLat, b as isBackgroundStyleLayer, bi as clone$1, bn as ErrorEvent, br as mod, bt as isHillshadeStyleLayer, ci as normalize, cn as validateStyleAndEmit, cr as getAngleDelta, ct as earthRadius, d as OverscaledTileID, di as rotateZ$1, dn as featureFilter, dr as getRollPitchBearing, dt as Bounds, ei as add, er as differenceOfAnglesDegrees, et as MercatorCoordinate, f as UnwrappedTileID, fi as scale$1, fr as isImageBitmap, ft as isFillStyleLayer, g as Actor, gi as transformMat3, gn as ValidationError, gr as isTouchableOrPointableType, gt as SubdivisionGranularitySetting, h as isInBoundsForZoomLngLat, hi as subtract, hn as Color, hr as isTouchableEvent, ht as SubdivisionGranularityExpression, ii as dot, in as SPEC_SOURCE_TYPES, ir as extend, it as mercatorXfromLng, ji as rotateX, jn as addProtocol, jr as scaleZoom, jt as Uniform2f, k as evaluateSizeForFeature, ki as ortho, kn as makeRequest, kr as rollPitchBearingEqual, kt as Uniform1f, li as rotateX$1, ln as emptyStyle, lr as getEdgeTiles, m as compareTileId, mi as sub, mn as ProjectionDefinition, mr as isSafari, mt as SOUTH_POLE_Y, n as TileCache, ni as cross, nn as ZoomHistory, nr as ensureError, nt as latFromMercatorY, oi as length, on as validateAndEmit, or as findLineIntersection, ot as mercatorZfromAltitude, p as calculateTileKey, pi as scaleAndAdd, pn as interpolateFactory, pr as isPointableEvent, pt as NORTH_POLE_Y, q as cameraMercatorCoordinate, qn as createIdentityMat4f64, qr as fromEuler, qt as createLayout, ri as distance, rr as evaluateZoomSnap, rt as lngFromMercatorX, s as GEOJSON_TILE_LAYER_NAME, si as negate, sn as validateStyle, sr as getAABB, st as LngLat, ti as clone, tn as codePointUsesLocalIdeographFontFamily, tr as distanceOfAnglesRadians, tt as altitudeFromMercatorZ, u as CanonicalTileID, ui as rotateY, ut as EXTENT_BOUNDS, v as isCustomStyleLayer, vi as transformQuat, vn as derefLayers, vr as lerp, w as getOverlapMode, wi as exactEquals, wn as GLOBAL_DISPATCHER_ID, wr as pointPlaneSignedDistance, wt as AlphaImage, x as isSymbolStyleLayer, xi as copy, xn as Event, xr as nextPowerOfTwo, xt as HEATMAP_FULL_RENDER_FBO_KEY, y as validateCustomStyleLayer, yi as zero$1, yn as latest, yr as mapObject, yt as Texture, zi as determinant, zn as MAX_VALID_LATITUDE, zr as zoomScale, zt as CollisionBoxArray } from "./maplibre-gl-shared-dev.mjs";
 //#region package.json
-var version$2 = "6.7.0";
+var version$2 = "6.8.0";
 //#endregion
 //#region src/util/browser.ts
 let linkEl;
@@ -358,6 +358,13 @@ let ImageRequest;
 		if (typeof createImageBitmap === "function") return arrayBufferToImageBitmap(data, imageBitmapOptions);
 		else return arrayBufferToImage(data);
 	};
+	/**
+	* Runs one queued image request.
+	*
+	* An empty response body (e.g. HTTP 204 for a tile without content) resolves with
+	* `data: null`, keeping the expiry headers, so callers can handle the absence
+	* explicitly and re-request when the headers say so.
+	*/
 	const doImageRequest = async (itemInQueue) => {
 		itemInQueue.state = "running";
 		const { requestParameters, supportImageRefresh, imageBitmapOptions, onError, onSuccess, abortController } = itemInQueue;
@@ -369,7 +376,12 @@ let ImageRequest;
 			delete itemInQueue.abortController;
 			itemInQueue.state = "completed";
 			if (response.data instanceof HTMLImageElement || isImageBitmap(response.data)) onSuccess(response);
-			else if (response.data) onSuccess({
+			else if (!response.data || response.data.byteLength === 0) onSuccess({
+				data: null,
+				cacheControl: response.cacheControl,
+				expires: response.expires
+			});
+			else onSuccess({
 				data: await arrayBufferToCanvasImageSource(response.data, imageBitmapOptions),
 				cacheControl: response.cacheControl,
 				expires: response.expires
@@ -731,7 +743,9 @@ async function doOnceCompleted(jsonsMap, imagesMap) {
 	const result = {};
 	for (const spriteName in jsonsMap) {
 		result[spriteName] = {};
-		const context = browser.getImageCanvasContext((await imagesMap[spriteName]).data);
+		const image = (await imagesMap[spriteName]).data;
+		if (!image) throw new Error(`Could not load sprite image for ${spriteName}: the response is empty`);
+		const context = browser.getImageCanvasContext(image);
 		const json = (await jsonsMap[spriteName]).data;
 		for (const id in json) {
 			const { width, height, x, y, sdf, pixelRatio, stretchX, stretchY, content, textFitWidth, textFitHeight } = json[id];
@@ -2878,6 +2892,7 @@ var VectorTileSource = class extends Evented {
 	*/
 	setTiles(tiles) {
 		this.setSourceProperty(() => {
+			this.tiles = tiles;
 			this._options.tiles = tiles;
 		});
 		return this;
@@ -3111,6 +3126,7 @@ var RasterTileSource = class extends Evented {
 	*/
 	setTiles(tiles) {
 		this.setSourceProperty(() => {
+			this.tiles = tiles;
 			this._options.tiles = tiles;
 		});
 		return this;
@@ -3162,14 +3178,17 @@ var RasterTileSource = class extends Evented {
 				tile.state = "unloaded";
 				return;
 			}
-			if (response?.data) {
+			if (response) {
 				if (this.map._refreshExpiredTiles && (response.cacheControl || response.expires)) tile.setExpiryData({
 					cacheControl: response.cacheControl,
 					expires: response.expires
 				});
 				const context = this.map.painter.context;
 				const gl = context.gl;
-				const img = response.data;
+				const img = response.data ?? new RGBAImage({
+					width: 1,
+					height: 1
+				}, /* @__PURE__ */ new Uint8Array(4));
 				tile.texture = this.map.painter.getTileTexture(img.width);
 				if (tile.texture) tile.texture.update(img, {
 					useMipmap: true,
@@ -3247,12 +3266,16 @@ var RasterDEMTileSource = class extends RasterTileSource {
 				tile.state = "unloaded";
 				return;
 			}
-			if (response?.data) {
-				const img = response.data;
+			if (response) {
 				if (this.map._refreshExpiredTiles && (response.cacheControl || response.expires)) tile.setExpiryData({
 					cacheControl: response.cacheControl,
 					expires: response.expires
 				});
+				if (!response.data) {
+					tile.state = "loaded";
+					return;
+				}
+				const img = response.data;
 				const rawImageData = isImageBitmap(img) && offscreenCanvasSupported() ? img : await this.readImageNow(img);
 				const params = {
 					type: this.type,
@@ -3288,16 +3311,16 @@ var RasterDEMTileSource = class extends RasterTileSource {
 	}
 	async readImageNow(img) {
 		if (typeof VideoFrame !== "undefined" && isOffscreenCanvasDistorted()) {
-			const width = img.width + 2;
-			const height = img.height + 2;
+			const width = img.width + 4;
+			const height = img.height + 4;
 			try {
 				return new RGBAImage({
 					width,
 					height
-				}, await readImageUsingVideoFrame(img, -1, -1, width, height));
+				}, await readImageUsingVideoFrame(img, -2, -2, width, height));
 			} catch {}
 		}
-		return browser.getImageData(img, 1);
+		return browser.getImageData(img, 2);
 	}
 	_getNeighboringTiles(tileID) {
 		const canonical = tileID.canonical;
@@ -4379,7 +4402,7 @@ var ImageSource = class extends Evented {
 				this._setImage(image.data);
 				if (newCoordinates) this.coordinates = newCoordinates;
 				this._finishLoading();
-			}
+			} else this.fire(new ErrorEvent(/* @__PURE__ */ new Error(`Could not load image ${this.url}: the response is empty`)));
 		} catch (err) {
 			if (isAbortError(err)) return;
 			this._abortController = null;
@@ -5494,213 +5517,575 @@ var SourceFeatureState = class {
 	}
 };
 //#endregion
-//#region src/geo/projection/covering_tiles.ts
-/**
-* A simple/heuristic function that returns whether the tile is visible under the current transform.
-* @returns an {@link IntersectionResult}.
-*/
-function isTileVisible(frustum, tileBoundingVolume, plane) {
-	const frustumTest = tileBoundingVolume.intersectsFrustum(frustum);
-	if (!plane || frustumTest === 0) return frustumTest;
-	const planeTest = tileBoundingVolume.intersectsPlane(plane);
-	if (planeTest === 0) return 0;
-	if (frustumTest === 2 && planeTest === 2) return 2;
-	return 1;
-}
-/**
-* Definite integral of cos(x)^p. The analytical solution is described in `developer-guides/covering-tiles.md`,
-* but here the integral is evaluated numerically.
-* @param p - the power to raise cos(x) to inside the integral
-* @param x1 - the starting point of the integral.
-* @param x2 - the ending point of the integral.
-* @return the integral of cos(x)^p from x=x1 to x=x2
-*/
-function integralOfCosXByP(p, x1, x2) {
-	const numPoints = 10;
-	let sum = 0;
-	const dx = (x2 - x1) / numPoints;
-	for (let i = 0; i < numPoints; i++) {
-		const x = x1 + (i + .5) / numPoints * (x2 - x1);
-		sum += dx * Math.pow(Math.cos(x), p);
-	}
-	return sum;
-}
-function createCalculateTileZoomFunction(maxZoomLevelsOnScreen, tileCountMaxMinRatio) {
-	return function(requestedCenterZoom, distanceToTile2D, distanceToTileZ, distanceToCenter3D, cameraVerticalFOV) {
-		/**
-		* Controls how tiles are loaded at high pitch angles. Higher numbers cause fewer, lower resolution
-		* tiles to be loaded. Calculate the value that will result in the selected number of zoom levels in
-		* the worst-case condition (when the horizon is at the top of the screen). For more information, see
-		* `developer-guides/covering-tiles.md`
-		*/
-		const pitchTileLoadingBehavior = 2 * ((maxZoomLevelsOnScreen - 1) / scaleZoom(Math.cos(degreesToRadians(maxMercatorHorizonAngle - cameraVerticalFOV)) / Math.cos(degreesToRadians(maxMercatorHorizonAngle))) - 1);
-		const centerPitch = Math.acos(distanceToTileZ / distanceToCenter3D);
-		const tileCountPitch0 = 2 * integralOfCosXByP(pitchTileLoadingBehavior - 1, 0, degreesToRadians(cameraVerticalFOV / 2));
-		const highestPitch = Math.min(degreesToRadians(maxMercatorHorizonAngle), centerPitch + degreesToRadians(cameraVerticalFOV / 2));
-		const lowestPitch = Math.min(highestPitch, centerPitch - degreesToRadians(cameraVerticalFOV / 2));
-		const tileCount = integralOfCosXByP(pitchTileLoadingBehavior - 1, lowestPitch, highestPitch);
-		const thisTilePitch = Math.atan(distanceToTile2D / distanceToTileZ);
-		const distanceToTile3D = Math.hypot(distanceToTile2D, distanceToTileZ);
-		let thisTileDesiredZ = requestedCenterZoom;
-		thisTileDesiredZ = thisTileDesiredZ + scaleZoom(distanceToCenter3D / distanceToTile3D / Math.max(.5, Math.cos(degreesToRadians(cameraVerticalFOV / 2))));
-		thisTileDesiredZ += pitchTileLoadingBehavior * scaleZoom(Math.cos(thisTilePitch)) / 2;
-		thisTileDesiredZ -= scaleZoom(Math.max(1, tileCount / tileCountPitch0 / tileCountMaxMinRatio)) / 2;
-		return thisTileDesiredZ;
-	};
-}
-const defaultCalculateTileZoom = createCalculateTileZoomFunction(9.314, 3);
-/**
-* Return what zoom level of a tile source would most closely cover the tiles displayed by this transform.
-* @param options - The options, most importantly the source's tile size.
-* @returns An integer zoom level at which all tiles will be visible.
-*/
-function coveringZoomLevel(transform, options) {
-	const z = (options.roundZoom ? Math.round : Math.floor)(transform.zoom + scaleZoom(transform.tileSize / options.tileSize));
-	return Math.max(0, z);
-}
-/**
-* Without terrain, `getTileBoundingVolume` has no knowledge of extruded features
-* (eg. 3D buildings): every tile's bounding box is flat at the camera's `elevation`.
-* That's a fine approximation of what's visible for most views, but it breaks down
-* as the frustum's bottom edge approaches horizontal (which depends on both `pitch`
-* and `fov`, not pitch alone) - a tall building can still be poking up into view
-* long after its tile's ground point has dropped out of the frustum.
-*
-* This is an assumed upper bound on real-world feature height (in metres), used to
-* grow the elevation used for tile culling as that bottom edge nears horizontal, so
-* such tiles are not dropped too early. It has no effect away from that edge case.
-*/
-const ASSUMED_MAX_FEATURE_HEIGHT_METERS = 500;
-/**
-* Angle between the frustum's bottom edge and the mercator horizon below which
-* the culling elevation starts to grow.
-*/
-const TILE_CULLING_HORIZON_ONSET_DEGREES = 15;
-/**
-* Returns the elevation to use when computing tile bounding volumes for culling:
-* `transform.elevation`, growing by up to `ASSUMED_MAX_FEATURE_HEIGHT_METERS` as
-* the frustum's bottom edge approaches the horizon, where a ground-level bounding
-* box would cull tiles whose extruded features are still visible.
-*/
-function getElevationForTileCulling(transform) {
-	const bottomEdgeDegreesAboveHorizontal = maxMercatorHorizonAngle - transform.pitch - transform.fov / 2;
-	const proximityToHorizon = clamp((TILE_CULLING_HORIZON_ONSET_DEGREES - bottomEdgeDegreesAboveHorizontal) / TILE_CULLING_HORIZON_ONSET_DEGREES, 0, 1);
-	return transform.elevation + proximityToHorizon * ASSUMED_MAX_FEATURE_HEIGHT_METERS;
-}
-/**
-* Returns a list of tiles that optimally covers the screen. Adapted for globe projection.
-* Correctly handles LOD when moving over the antimeridian.
-* @param transform - The transform instance.
-* @param frustum - The covering frustum.
-* @param plane - The clipping plane used by globe transform, or null.
-* @param cameraCoord - The x, y, z position of the camera in MercatorCoordinates.
-* @param centerCoord - The x, y, z position of the center point in MercatorCoordinates.
-* @param options - Additional coveringTiles options.
-* @param details - Interface to define required helper functions.
-* @returns A list of tile coordinates, ordered by ascending distance from camera.
-*/
-function coveringTiles(transform, options) {
-	const frustum = transform.getCameraFrustum();
-	const plane = transform.getClippingPlane();
-	const cameraCoord = cameraMercatorCoordinate(transform);
-	const centerCoord = MercatorCoordinate.fromLngLat(transform.center, transform.elevation);
-	const elevationForTileCulling = getElevationForTileCulling(transform);
-	const detailsProvider = transform.getCoveringTilesDetailsProvider();
-	const allowVariableZoom = detailsProvider.allowVariableZoom(transform, options);
-	const desiredZ = coveringZoomLevel(transform, options);
-	const minZoom = options.minzoom || 0;
-	const maxZoom = options.maxzoom !== void 0 ? options.maxzoom : transform.maxZoom;
-	const nominalZ = Math.min(Math.max(0, desiredZ), maxZoom);
-	const numTiles = Math.pow(2, nominalZ);
-	const cameraPoint = [
-		numTiles * cameraCoord.x,
-		numTiles * cameraCoord.y,
-		0
-	];
-	const centerPoint = [
-		numTiles * centerCoord.x,
-		numTiles * centerCoord.y,
-		0
-	];
-	const distanceToCenter2d = Math.hypot(centerCoord.x - cameraCoord.x, centerCoord.y - cameraCoord.y);
-	const distanceZ = Math.abs(centerCoord.z - cameraCoord.z);
-	const distanceToCenter3d = Math.hypot(distanceToCenter2d, distanceZ);
-	const newRootTile = (wrap) => {
-		return {
-			zoom: 0,
-			x: 0,
-			y: 0,
-			wrap,
-			fullyVisible: false
-		};
-	};
-	const stack = [];
-	const result = [];
-	if (transform.renderWorldCopies && detailsProvider.allowWorldCopies()) for (let i = 1; i <= 3; i++) {
-		stack.push(newRootTile(-i));
-		stack.push(newRootTile(i));
+//#region src/util/primitives/aabb.ts
+var Aabb = class Aabb {
+	constructor(min_, max_) {
+		this.min = min_;
+		this.max = max_;
+		this.center = scale$1([], add([], this.min, this.max), .5);
 	}
-	stack.push(newRootTile(0));
-	while (stack.length > 0) {
-		const it = stack.pop();
-		const x = it.x;
-		const y = it.y;
-		let fullyVisible = it.fullyVisible;
-		const tileID = {
-			x,
-			y,
-			z: it.zoom
-		};
-		const boundingVolume = detailsProvider.getTileBoundingVolume(tileID, it.wrap, elevationForTileCulling, options);
-		if (!fullyVisible) {
-			const intersectResult = isTileVisible(frustum, boundingVolume, plane);
-			if (intersectResult === 0) continue;
-			fullyVisible = intersectResult === 2;
+	quadrant(index) {
+		const split = [index % 2 === 0, index < 2];
+		const qMin = clone(this.min);
+		const qMax = clone(this.max);
+		for (let axis = 0; axis < split.length; axis++) {
+			qMin[axis] = split[axis] ? this.min[axis] : this.center[axis];
+			qMax[axis] = split[axis] ? this.center[axis] : this.max[axis];
 		}
-		const distToTile2d = detailsProvider.distanceToTile2d(cameraCoord.x, cameraCoord.y, tileID, boundingVolume);
-		let thisTileDesiredZ = desiredZ;
-		if (allowVariableZoom) thisTileDesiredZ = (options.calculateTileZoom || defaultCalculateTileZoom)(transform.zoom + scaleZoom(transform.tileSize / options.tileSize), distToTile2d, distanceZ, distanceToCenter3d, transform.fov);
-		thisTileDesiredZ = (options.roundZoom ? Math.round : Math.floor)(thisTileDesiredZ);
-		thisTileDesiredZ = Math.max(0, thisTileDesiredZ);
-		const z = Math.min(thisTileDesiredZ, maxZoom);
-		it.wrap = detailsProvider.getWrap(centerCoord, tileID, it.wrap);
-		if (it.zoom >= z) {
-			if (it.zoom < minZoom) continue;
-			const dz = nominalZ - it.zoom;
-			const dx = cameraPoint[0] - .5 - (x << dz);
-			const dy = cameraPoint[1] - .5 - (y << dz);
-			const overscaledZ = options.reparseOverscaled ? Math.max(it.zoom, thisTileDesiredZ) : it.zoom;
-			result.push({
-				tileID: new OverscaledTileID(it.zoom === maxZoom ? overscaledZ : it.zoom, it.wrap, it.zoom, x, y),
-				distanceSq: sqrLen([centerPoint[0] - .5 - x, centerPoint[1] - .5 - y]),
-				tileDistanceToCamera: Math.sqrt(dx * dx + dy * dy)
-			});
-			continue;
+		qMax[2] = this.max[2];
+		return new Aabb(qMin, qMax);
+	}
+	distanceX(point) {
+		return Math.max(Math.min(this.max[0], point[0]), this.min[0]) - point[0];
+	}
+	distanceY(point) {
+		return Math.max(Math.min(this.max[1], point[1]), this.min[1]) - point[1];
+	}
+	/**
+	* Performs a frustum-aabb intersection test.
+	*/
+	intersectsFrustum(frustum) {
+		let fullyInside = true;
+		for (const plane of frustum.planes) {
+			const planeIntersection = this.intersectsPlane(plane);
+			if (planeIntersection === 0) return 0;
+			if (planeIntersection === 1) fullyInside = false;
 		}
-		for (let i = 0; i < 4; i++) {
-			const childX = (x << 1) + i % 2;
-			const childY = (y << 1) + (i >> 1);
-			const childZ = it.zoom + 1;
-			stack.push({
-				zoom: childZ,
-				x: childX,
-				y: childY,
-				wrap: it.wrap,
-				fullyVisible
-			});
+		if (fullyInside) return 2;
+		if (frustum.aabb.min[0] > this.max[0] || frustum.aabb.min[1] > this.max[1] || frustum.aabb.min[2] > this.max[2] || frustum.aabb.max[0] < this.min[0] || frustum.aabb.max[1] < this.min[1] || frustum.aabb.max[2] < this.min[2]) return 0;
+		return 1;
+	}
+	/**
+	* Performs a halfspace-aabb intersection test.
+	*/
+	intersectsPlane(plane) {
+		let distMin = plane[3];
+		let distMax = plane[3];
+		for (let i = 0; i < 3; i++) if (plane[i] > 0) {
+			distMin += plane[i] * this.min[i];
+			distMax += plane[i] * this.max[i];
+		} else {
+			distMax += plane[i] * this.min[i];
+			distMin += plane[i] * this.max[i];
 		}
+		if (distMin >= 0) return 2;
+		if (distMax < 0) return 0;
+		return 1;
 	}
-	return result.sort((a, b) => a.distanceSq - b.distanceSq).map((a) => a.tileID);
-}
+};
 //#endregion
-//#region src/tile/tile_manager_raster.ts
-function isRasterType(type) {
-	return type === "raster" || type === "image" || type === "video";
-}
-/**
-* Designate fading bases and parents using a many-to-one relationship where the lower children fade in/out
-* with their parents. Raster shaders are not currently designed for a one-to-many fade relationship.
-*
+//#region src/util/primitives/frustum.ts
+var Frustum = class Frustum {
+	constructor(points, planes, aabb) {
+		this.points = points;
+		this.planes = planes;
+		this.aabb = aabb;
+	}
+	static fromInvProjectionMatrix(invProj, worldSize = 1, zoom = 0, horizonPlane, flippedNearFar) {
+		const clipSpaceCorners = [
+			[
+				-1,
+				1,
+				-1,
+				1
+			],
+			[
+				1,
+				1,
+				-1,
+				1
+			],
+			[
+				1,
+				-1,
+				-1,
+				1
+			],
+			[
+				-1,
+				-1,
+				-1,
+				1
+			],
+			[
+				-1,
+				1,
+				1,
+				1
+			],
+			[
+				1,
+				1,
+				1,
+				1
+			],
+			[
+				1,
+				-1,
+				1,
+				1
+			],
+			[
+				-1,
+				-1,
+				1,
+				1
+			]
+		];
+		const frustumPlanePointIndices = flippedNearFar ? [
+			[
+				6,
+				5,
+				4
+			],
+			[
+				0,
+				1,
+				2
+			],
+			[
+				0,
+				3,
+				7
+			],
+			[
+				2,
+				1,
+				5
+			],
+			[
+				3,
+				2,
+				6
+			],
+			[
+				0,
+				4,
+				5
+			]
+		] : [
+			[
+				0,
+				1,
+				2
+			],
+			[
+				6,
+				5,
+				4
+			],
+			[
+				0,
+				3,
+				7
+			],
+			[
+				2,
+				1,
+				5
+			],
+			[
+				3,
+				2,
+				6
+			],
+			[
+				0,
+				4,
+				5
+			]
+		];
+		const scale = Math.pow(2, zoom);
+		const frustumCoords = clipSpaceCorners.map((v) => unprojectClipSpacePoint(v, invProj, worldSize, scale));
+		if (horizonPlane) adjustFarPlaneByHorizonPlane(frustumCoords, frustumPlanePointIndices[0], horizonPlane, flippedNearFar);
+		const frustumPlanes = frustumPlanePointIndices.map((p) => {
+			const a = sub([], frustumCoords[p[0]], frustumCoords[p[1]]);
+			const b = sub([], frustumCoords[p[2]], frustumCoords[p[1]]);
+			const n = normalize([], cross([], a, b));
+			const d = -dot(n, frustumCoords[p[1]]);
+			return n.concat(d);
+		});
+		const min = [
+			Number.POSITIVE_INFINITY,
+			Number.POSITIVE_INFINITY,
+			Number.POSITIVE_INFINITY
+		];
+		const max = [
+			Number.NEGATIVE_INFINITY,
+			Number.NEGATIVE_INFINITY,
+			Number.NEGATIVE_INFINITY
+		];
+		for (const p of frustumCoords) for (let i = 0; i < 3; i++) {
+			min[i] = Math.min(min[i], p[i]);
+			max[i] = Math.max(max[i], p[i]);
+		}
+		return new Frustum(frustumCoords, frustumPlanes, new Aabb(min, max));
+	}
+};
+function unprojectClipSpacePoint(point, invProj, worldSize, scale) {
+	const v = transformMat4([], point, invProj);
+	const s = 1 / v[3] / worldSize * scale;
+	return mul(v, v, [
+		s,
+		s,
+		1 / v[3],
+		s
+	]);
+}
+/**
+* Modifies points in the supplied `frustumCoords` array so that the frustum's far plane only lies as far as the horizon,
+* which improves frustum culling effectiveness.
+* @param frustumCoords - Points of the frustum.
+* @param nearPlanePointsIndices - Which indices in the `frustumCoords` form the near plane.
+* @param horizonPlane - The horizon plane.
+*/
+function adjustFarPlaneByHorizonPlane(frustumCoords, nearPlanePointsIndices, horizonPlane, flippedNearFar) {
+	const nearPlanePointsOffset = flippedNearFar ? 4 : 0;
+	const farPlanePointsOffset = flippedNearFar ? 0 : 4;
+	let maxDist = 0;
+	const cornerRayLengths = [];
+	const cornerRayNormalizedDirections = [];
+	for (let i = 0; i < 4; i++) {
+		const dir = sub([], frustumCoords[i + farPlanePointsOffset], frustumCoords[i + nearPlanePointsOffset]);
+		const len = length(dir);
+		scale$1(dir, dir, 1 / len);
+		cornerRayLengths.push(len);
+		cornerRayNormalizedDirections.push(dir);
+	}
+	for (let i = 0; i < 4; i++) {
+		const dist = rayPlaneIntersection(frustumCoords[i + nearPlanePointsOffset], cornerRayNormalizedDirections[i], horizonPlane);
+		if (dist !== null && dist >= 0) maxDist = Math.max(maxDist, dist);
+		else maxDist = Math.max(maxDist, cornerRayLengths[i]);
+	}
+	const nearPlaneNormalized = getNormalizedNearPlane(frustumCoords, nearPlanePointsIndices);
+	const idealFarPlaneDistanceFromNearPlane = getIdealNearFarPlaneDistance(horizonPlane, nearPlaneNormalized);
+	if (idealFarPlaneDistanceFromNearPlane !== null) {
+		const idealCornerRayLength = idealFarPlaneDistanceFromNearPlane / dot(cornerRayNormalizedDirections[0], nearPlaneNormalized);
+		maxDist = Math.min(maxDist, idealCornerRayLength);
+	}
+	for (let i = 0; i < 4; i++) {
+		const targetLength = Math.min(maxDist, cornerRayLengths[i]);
+		frustumCoords[i + farPlanePointsOffset] = [
+			frustumCoords[i + nearPlanePointsOffset][0] + cornerRayNormalizedDirections[i][0] * targetLength,
+			frustumCoords[i + nearPlanePointsOffset][1] + cornerRayNormalizedDirections[i][1] * targetLength,
+			frustumCoords[i + nearPlanePointsOffset][2] + cornerRayNormalizedDirections[i][2] * targetLength,
+			1
+		];
+	}
+}
+/**
+* Returns the near plane equation with unit length direction.
+* @param frustumCoords - Points of the frustum.
+* @param nearPlanePointsIndices - Which indices in the `frustumCoords` form the near plane.
+*/
+function getNormalizedNearPlane(frustumCoords, nearPlanePointsIndices) {
+	const nearPlaneA = sub([], frustumCoords[nearPlanePointsIndices[0]], frustumCoords[nearPlanePointsIndices[1]]);
+	const nearPlaneB = sub([], frustumCoords[nearPlanePointsIndices[2]], frustumCoords[nearPlanePointsIndices[1]]);
+	const nearPlaneNormalized = [
+		0,
+		0,
+		0,
+		0
+	];
+	normalize(nearPlaneNormalized, cross([], nearPlaneA, nearPlaneB));
+	nearPlaneNormalized[3] = -dot(nearPlaneNormalized, frustumCoords[nearPlanePointsIndices[0]]);
+	return nearPlaneNormalized;
+}
+/**
+* Returns the ideal distance between the frustum's near and far plane so that the far plane only lies as far as the horizon.
+*/
+function getIdealNearFarPlaneDistance(horizonPlane, nearPlaneNormalized) {
+	const horizonPlaneLen = len(horizonPlane);
+	const normalizedHorizonPlane = scale$2([], horizonPlane, 1 / horizonPlaneLen);
+	const projectedViewDirection = sub([], nearPlaneNormalized, scale$1([], normalizedHorizonPlane, dot(nearPlaneNormalized, normalizedHorizonPlane)));
+	const projectedViewLength = len(projectedViewDirection);
+	if (projectedViewLength > 0) {
+		const horizonCircleRadius = Math.sqrt(1 - normalizedHorizonPlane[3] * normalizedHorizonPlane[3]);
+		const horizonCircleCenter = scale$1([], normalizedHorizonPlane, -normalizedHorizonPlane[3]);
+		const pointFurthestOnHorizonCircle = add([], horizonCircleCenter, scale$1([], projectedViewDirection, horizonCircleRadius / projectedViewLength));
+		return pointPlaneSignedDistance(nearPlaneNormalized, pointFurthestOnHorizonCircle);
+	} else return null;
+}
+//#endregion
+//#region src/geo/projection/covering_tiles.ts
+/**
+* A simple/heuristic function that returns whether the tile is visible under the current transform.
+* @returns an {@link IntersectionResult}.
+*/
+function isTileVisible(frustum, tileBoundingVolume, plane) {
+	const frustumTest = tileBoundingVolume.intersectsFrustum(frustum);
+	if (!plane || frustumTest === 0) return frustumTest;
+	const planeTest = tileBoundingVolume.intersectsPlane(plane);
+	if (planeTest === 0) return 0;
+	if (frustumTest === 2 && planeTest === 2) return 2;
+	return 1;
+}
+/**
+* Definite integral of cos(x)^p. The analytical solution is described in `developer-guides/covering-tiles.md`,
+* but here the integral is evaluated numerically.
+* @param p - the power to raise cos(x) to inside the integral
+* @param x1 - the starting point of the integral.
+* @param x2 - the ending point of the integral.
+* @return the integral of cos(x)^p from x=x1 to x=x2
+*/
+function integralOfCosXByP(p, x1, x2) {
+	const numPoints = 10;
+	let sum = 0;
+	const dx = (x2 - x1) / numPoints;
+	for (let i = 0; i < numPoints; i++) {
+		const x = x1 + (i + .5) / numPoints * (x2 - x1);
+		sum += dx * Math.pow(Math.cos(x), p);
+	}
+	return sum;
+}
+function createCalculateTileZoomFunction(maxZoomLevelsOnScreen, tileCountMaxMinRatio) {
+	return function(requestedCenterZoom, distanceToTile2D, distanceToTileZ, distanceToCenter3D, cameraVerticalFOV) {
+		/**
+		* Controls how tiles are loaded at high pitch angles. Higher numbers cause fewer, lower resolution
+		* tiles to be loaded. Calculate the value that will result in the selected number of zoom levels in
+		* the worst-case condition (when the horizon is at the top of the screen). For more information, see
+		* `developer-guides/covering-tiles.md`
+		*/
+		const pitchTileLoadingBehavior = 2 * ((maxZoomLevelsOnScreen - 1) / scaleZoom(Math.cos(degreesToRadians(maxMercatorHorizonAngle - cameraVerticalFOV)) / Math.cos(degreesToRadians(maxMercatorHorizonAngle))) - 1);
+		const centerPitch = Math.acos(distanceToTileZ / distanceToCenter3D);
+		const tileCountPitch0 = 2 * integralOfCosXByP(pitchTileLoadingBehavior - 1, 0, degreesToRadians(cameraVerticalFOV / 2));
+		const highestPitch = Math.min(degreesToRadians(maxMercatorHorizonAngle), centerPitch + degreesToRadians(cameraVerticalFOV / 2));
+		const lowestPitch = Math.min(highestPitch, centerPitch - degreesToRadians(cameraVerticalFOV / 2));
+		const tileCount = integralOfCosXByP(pitchTileLoadingBehavior - 1, lowestPitch, highestPitch);
+		const thisTilePitch = Math.atan(distanceToTile2D / distanceToTileZ);
+		const distanceToTile3D = Math.hypot(distanceToTile2D, distanceToTileZ);
+		let thisTileDesiredZ = requestedCenterZoom;
+		thisTileDesiredZ = thisTileDesiredZ + scaleZoom(distanceToCenter3D / distanceToTile3D / Math.max(.5, Math.cos(degreesToRadians(cameraVerticalFOV / 2))));
+		thisTileDesiredZ += pitchTileLoadingBehavior * scaleZoom(Math.cos(thisTilePitch)) / 2;
+		thisTileDesiredZ -= scaleZoom(Math.max(1, tileCount / tileCountPitch0 / tileCountMaxMinRatio)) / 2;
+		return thisTileDesiredZ;
+	};
+}
+const defaultCalculateTileZoom = createCalculateTileZoomFunction(9.314, 3);
+/**
+* Return what zoom level of a tile source would most closely cover the tiles displayed by this transform.
+* @param options - The options, most importantly the source's tile size.
+* @returns An integer zoom level at which all tiles will be visible.
+*/
+function coveringZoomLevel(transform, options) {
+	const z = (options.roundZoom ? Math.round : Math.floor)(transform.zoom + scaleZoom(transform.tileSize / options.tileSize));
+	return Math.max(0, z);
+}
+/**
+* Without terrain, `getTileBoundingVolume` has no knowledge of extruded features
+* (eg. 3D buildings): every tile's bounding box is flat at the camera's `elevation`.
+* That's a fine approximation of what's visible for most views, but it breaks down
+* as the frustum's bottom edge approaches horizontal (which depends on both `pitch`
+* and `fov`, not pitch alone) - a tall building can still be poking up into view
+* long after its tile's ground point has dropped out of the frustum.
+*
+* This is an assumed upper bound on real-world feature height (in metres), used to
+* grow the elevation used for tile culling as that bottom edge nears horizontal, so
+* such tiles are not dropped too early. It has no effect away from that edge case.
+*/
+const ASSUMED_MAX_FEATURE_HEIGHT_METERS = 500;
+/**
+* Angle between the frustum's bottom edge and the mercator horizon below which
+* the culling elevation starts to grow.
+*/
+const TILE_CULLING_HORIZON_ONSET_DEGREES = 15;
+/**
+* Returns the elevation to use when computing tile bounding volumes for culling:
+* `transform.elevation`, growing by up to the greater of
+* `ASSUMED_MAX_FEATURE_HEIGHT_METERS` and `maxContentElevation` (when provided)
+* as the frustum's bottom edge approaches the horizon, where a ground-level
+* bounding box would cull tiles whose extruded features are still visible.
+*/
+function getElevationForTileCulling(transform, maxContentElevation) {
+	const bottomEdgeDegreesAboveHorizontal = maxMercatorHorizonAngle - transform.pitch - transform.fov / 2;
+	const proximityToHorizon = clamp((TILE_CULLING_HORIZON_ONSET_DEGREES - bottomEdgeDegreesAboveHorizontal) / TILE_CULLING_HORIZON_ONSET_DEGREES, 0, 1);
+	const maxFeatureHeight = Math.max(ASSUMED_MAX_FEATURE_HEIGHT_METERS, maxContentElevation ?? 0);
+	return transform.elevation + proximityToHorizon * maxFeatureHeight;
+}
+/**
+* Returns a copy of the frustum with its far plane moved away from the camera by `distance`.
+* Each far corner travels along its own camera ray until it reaches the pushed plane, so the
+* result stays a pyramid and the corners stay consistent with the side planes. The globe
+* frustum's far plane is fitted to the surface horizon, so elevated content beyond it would
+* otherwise be culled while still visible.
+*/
+function pushFrustumFarPlane(frustum, distance, cameraPos) {
+	const far = frustum.planes[1];
+	const points = frustum.points.map((p) => {
+		const distanceToFar = far[0] * p[0] + far[1] * p[1] + far[2] * p[2] + far[3];
+		if (Math.abs(distanceToFar) > 1e-6) return p;
+		const ray = [
+			p[0] - cameraPos[0],
+			p[1] - cameraPos[1],
+			p[2] - cameraPos[2]
+		];
+		const rayDotNormal = far[0] * ray[0] + far[1] * ray[1] + far[2] * ray[2];
+		if (rayDotNormal >= -1e-9) return p;
+		const scale = distance / -rayDotNormal;
+		return [
+			p[0] + ray[0] * scale,
+			p[1] + ray[1] * scale,
+			p[2] + ray[2] * scale,
+			p[3]
+		];
+	});
+	const planes = frustum.planes.map((p, i) => i === 1 ? [
+		p[0],
+		p[1],
+		p[2],
+		p[3] + distance
+	] : p);
+	const min = [
+		Number.POSITIVE_INFINITY,
+		Number.POSITIVE_INFINITY,
+		Number.POSITIVE_INFINITY
+	];
+	const max = [
+		Number.NEGATIVE_INFINITY,
+		Number.NEGATIVE_INFINITY,
+		Number.NEGATIVE_INFINITY
+	];
+	for (const p of points) for (let i = 0; i < 3; i++) {
+		min[i] = Math.min(min[i], p[i]);
+		max[i] = Math.max(max[i], p[i]);
+	}
+	return new Frustum(points, planes, new Aabb(min, max));
+}
+/**
+* Returns a list of tiles that optimally covers the screen. Adapted for globe projection.
+* Correctly handles LOD when moving over the antimeridian.
+*
+* The horizon culling plane and the frustum's far plane both assume content sits on the
+* surface. When `options.maxContentElevation` is set, a point elevated to radius r (in planet
+* radii) stays visible up to acos(1/r) beyond the surface horizon and up to sqrt(r^2-1)
+* farther away, so both are pushed back accordingly; without this, tiles under highly
+* elevated symbols would be dropped while the symbols are still in view.
+* @param transform - The transform instance.
+* @param frustum - The covering frustum.
+* @param plane - The clipping plane used by globe transform, or null.
+* @param cameraCoord - The x, y, z position of the camera in MercatorCoordinates.
+* @param centerCoord - The x, y, z position of the center point in MercatorCoordinates.
+* @param options - Additional coveringTiles options.
+* @param details - Interface to define required helper functions.
+* @returns A list of tile coordinates, ordered by ascending distance from camera.
+*/
+function coveringTiles(transform, options) {
+	let frustum = transform.getCameraFrustum();
+	let plane = transform.getClippingPlane();
+	if (plane && options.maxContentElevation > 0) {
+		const len = Math.hypot(plane[0], plane[1], plane[2]);
+		if (len > 0) {
+			const shellRadius = 1 + options.maxContentElevation / earthRadius;
+			const horizonCos = clamp(-plane[3] / len, -1, 1);
+			const shellCos = Math.cos(Math.acos(horizonCos) + Math.acos(1 / shellRadius));
+			plane = [
+				plane[0],
+				plane[1],
+				plane[2],
+				-shellCos * len
+			];
+			frustum = pushFrustumFarPlane(frustum, Math.sqrt(shellRadius * shellRadius - 1), transform.cameraPosition);
+		}
+	}
+	const cameraCoord = cameraMercatorCoordinate(transform);
+	const centerCoord = MercatorCoordinate.fromLngLat(transform.center, transform.elevation);
+	const elevationForTileCulling = getElevationForTileCulling(transform, options.maxContentElevation);
+	const detailsProvider = transform.getCoveringTilesDetailsProvider();
+	const allowVariableZoom = detailsProvider.allowVariableZoom(transform, options);
+	const desiredZ = coveringZoomLevel(transform, options);
+	const minZoom = options.minzoom || 0;
+	const maxZoom = options.maxzoom !== void 0 ? options.maxzoom : transform.maxZoom;
+	const nominalZ = Math.min(Math.max(0, desiredZ), maxZoom);
+	const numTiles = Math.pow(2, nominalZ);
+	const cameraPoint = [
+		numTiles * cameraCoord.x,
+		numTiles * cameraCoord.y,
+		0
+	];
+	const centerPoint = [
+		numTiles * centerCoord.x,
+		numTiles * centerCoord.y,
+		0
+	];
+	const distanceToCenter2d = Math.hypot(centerCoord.x - cameraCoord.x, centerCoord.y - cameraCoord.y);
+	const distanceZ = Math.abs(centerCoord.z - cameraCoord.z);
+	const distanceToCenter3d = Math.hypot(distanceToCenter2d, distanceZ);
+	const newRootTile = (wrap) => {
+		return {
+			zoom: 0,
+			x: 0,
+			y: 0,
+			wrap,
+			fullyVisible: false
+		};
+	};
+	const stack = [];
+	const result = [];
+	if (transform.renderWorldCopies && detailsProvider.allowWorldCopies()) for (let i = 1; i <= 3; i++) {
+		stack.push(newRootTile(-i));
+		stack.push(newRootTile(i));
+	}
+	stack.push(newRootTile(0));
+	while (stack.length > 0) {
+		const it = stack.pop();
+		const x = it.x;
+		const y = it.y;
+		let fullyVisible = it.fullyVisible;
+		const tileID = {
+			x,
+			y,
+			z: it.zoom
+		};
+		const boundingVolume = detailsProvider.getTileBoundingVolume(tileID, it.wrap, elevationForTileCulling, options);
+		if (!fullyVisible) {
+			const intersectResult = isTileVisible(frustum, boundingVolume, plane);
+			if (intersectResult === 0) continue;
+			fullyVisible = intersectResult === 2;
+		}
+		const distToTile2d = detailsProvider.distanceToTile2d(cameraCoord.x, cameraCoord.y, tileID, boundingVolume);
+		let thisTileDesiredZ = desiredZ;
+		if (allowVariableZoom) thisTileDesiredZ = (options.calculateTileZoom || defaultCalculateTileZoom)(transform.zoom + scaleZoom(transform.tileSize / options.tileSize), distToTile2d, distanceZ, distanceToCenter3d, transform.fov);
+		thisTileDesiredZ = (options.roundZoom ? Math.round : Math.floor)(thisTileDesiredZ);
+		thisTileDesiredZ = Math.max(0, thisTileDesiredZ);
+		const z = Math.min(thisTileDesiredZ, maxZoom);
+		it.wrap = detailsProvider.getWrap(centerCoord, tileID, it.wrap);
+		if (it.zoom >= z) {
+			if (it.zoom < minZoom) continue;
+			const dz = nominalZ - it.zoom;
+			const dx = cameraPoint[0] - .5 - (x << dz);
+			const dy = cameraPoint[1] - .5 - (y << dz);
+			const overscaledZ = options.reparseOverscaled ? Math.max(it.zoom, thisTileDesiredZ) : it.zoom;
+			result.push({
+				tileID: new OverscaledTileID(it.zoom === maxZoom ? overscaledZ : it.zoom, it.wrap, it.zoom, x, y),
+				distanceSq: sqrLen([centerPoint[0] - .5 - x, centerPoint[1] - .5 - y]),
+				tileDistanceToCamera: Math.sqrt(dx * dx + dy * dy)
+			});
+			continue;
+		}
+		for (let i = 0; i < 4; i++) {
+			const childX = (x << 1) + i % 2;
+			const childY = (y << 1) + (i >> 1);
+			const childZ = it.zoom + 1;
+			stack.push({
+				zoom: childZ,
+				x: childX,
+				y: childY,
+				wrap: it.wrap,
+				fullyVisible
+			});
+		}
+	}
+	return result.sort((a, b) => a.distanceSq - b.distanceSq).map((a) => a.tileID);
+}
+//#endregion
+//#region src/tile/tile_manager_raster.ts
+function isRasterType(type) {
+	return type === "raster" || type === "image" || type === "video";
+}
+/**
+* Designate fading bases and parents using a many-to-one relationship where the lower children fade in/out
+* with their parents. Raster shaders are not currently designed for a one-to-many fade relationship.
+*
 * Tiles that are candidates for fading out must be loaded and rendered tiles, as loading a tile to then
 * fade it out would not appear smoothly. The first source of truth for tile fading always starts at the
 * ideal tile, which continually changes on map adjustment. The state of the previously rendered ideal
@@ -5946,6 +6331,7 @@ var TileManager = class TileManager extends Evented {
 	}
 	constructor(id, options, dispatcher) {
 		super();
+		this._maxContentElevationSeen = 0;
 		this.id = id;
 		this.dispatcher = dispatcher;
 		this.on("data", (e) => {
@@ -6211,6 +6597,33 @@ var TileManager = class TileManager extends Evented {
 		}
 	}
 	/**
+	* The highest elevation this source's symbols may reach, in meters: `symbol-height-offset`
+	* constants read from the visible symbol layers, data-driven maxima tracked by the loaded
+	* buckets at layout time. The value is a high-water mark: a maximum seen once is kept even
+	* after its tile unloads, otherwise dropping the tile would also drop the reason to keep it,
+	* and the tile could not come back while its content is still visible. The mark resets with
+	* the tiles in `clearTiles`.
+	*/
+	_updateMaxContentElevation() {
+		let maxElevation = this._maxContentElevationSeen;
+		const layers = this.map?.style?._layers;
+		if (!layers) return maxElevation;
+		const tiles = this._inViewTiles.getAllTiles();
+		for (const layerId in layers) {
+			const layer = layers[layerId];
+			if (layer.type !== "symbol" || layer.source !== this.id || layer.isHidden(this.transform.zoom)) continue;
+			const symbolLayer = layer;
+			if (!symbolLayer.layout) continue;
+			maxElevation = Math.max(maxElevation, symbolLayer.layout.get("symbol-height-offset").constantOr(0));
+			for (const tile of tiles) {
+				const bucket = tile.getBucket(layer);
+				if (bucket && bucket.maxHeightOffset > maxElevation) maxElevation = bucket.maxHeightOffset;
+			}
+		}
+		this._maxContentElevationSeen = maxElevation;
+		return maxElevation;
+	}
+	/**
 	* Removes tiles that are outside the viewport and adds new tiles that
 	* are inside the viewport.
 	*/
@@ -6231,7 +6644,8 @@ var TileManager = class TileManager extends Evented {
 				roundZoom: this.usedForTerrain ? false : this._source.roundZoom,
 				reparseOverscaled: this._source.reparseOverscaled,
 				terrain,
-				calculateTileZoom: this._source.calculateTileZoom
+				calculateTileZoom: this._source.calculateTileZoom,
+				maxContentElevation: this._updateMaxContentElevation()
 			});
 			if (this._source.hasTile) idealTileIDs = idealTileIDs.filter((coord) => this._source.hasTile(coord));
 		}
@@ -6424,11 +6838,20 @@ var TileManager = class TileManager extends Evented {
 		this._didEmitContent = true;
 	}
 	/**
+	* Forgets the recorded maximum content elevation, so the next update recomputes it from the
+	* current layers and loaded tiles. Called when a symbol layer is removed, since the removed
+	* layer's heights would otherwise keep expanding tile coverage.
+	*/
+	resetMaxContentElevation() {
+		this._maxContentElevationSeen = 0;
+	}
+	/**
 	* Remove all tiles from this pyramid
 	*/
 	clearTiles() {
 		this._shouldReloadOnResume = false;
 		this._paused = false;
+		this.resetMaxContentElevation();
 		for (const id of this._inViewTiles.getAllIds()) this._removeTile(id);
 		this._outOfViewCache.reset();
 	}
@@ -6967,15 +7390,15 @@ function getTileSkewVectors(transform) {
 	const vecSouth = create$3();
 	vecSouth[0] = -cosBearing * cosPitch * sinRoll - sinBearing * cosRoll;
 	vecSouth[1] = -sinBearing * cosPitch * sinRoll + cosBearing * cosRoll;
-	const vecSouthLen = length(vecSouth);
+	const vecSouthLen = length$1(vecSouth);
 	if (vecSouthLen < 1e-9) zero(vecSouth);
-	else scale$1(vecSouth, vecSouth, 1 / vecSouthLen);
+	else scale$3(vecSouth, vecSouth, 1 / vecSouthLen);
 	const vecEast = create$3();
 	vecEast[0] = cosBearing * cosPitch * cosRoll - sinBearing * sinRoll;
 	vecEast[1] = sinBearing * cosPitch * cosRoll + cosBearing * sinRoll;
-	const vecEastLen = length(vecEast);
+	const vecEastLen = length$1(vecEast);
 	if (vecEastLen < 1e-9) zero(vecEast);
-	else scale$1(vecEast, vecEast, 1 / vecEastLen);
+	else scale$3(vecEast, vecEast, 1 / vecEastLen);
 	return {
 		vecEast,
 		vecSouth
@@ -9035,10 +9458,10 @@ var CrossTileSymbolIndex = class {
 };
 //#endregion
 //#region src/shaders/glsl/_prelude.fragment.glsl.g.ts
-var _prelude_fragment_glsl_g_default = "#ifdef GL_ES\nprecision mediump float;\n#else\n#if !defined(lowp)\n#define lowp\n#endif\n#if !defined(mediump)\n#define mediump\n#endif\n#if !defined(highp)\n#define highp\n#endif\n#endif\nout highp vec4 fragColor;";
+var _prelude_fragment_glsl_g_default = "#ifdef GL_ES\nprecision mediump float;\n#else\n#if !defined(lowp)\n#define lowp\n#endif\n#if !defined(mediump)\n#define mediump\n#endif\n#if !defined(highp)\n#define highp\n#endif\n#endif\nout highp vec4 fragColor;layout(std140) uniform ProjectionUBO {highp mat4 u_projection_matrix;highp mat4 u_projection_fallback_matrix;highp vec4 u_projection_tile_mercator_coords;highp vec4 u_projection_clipping_plane;highp float u_projection_transition;highp int u_projection_clip_antimeridian;};layout(std140) uniform FrameUBO {highp vec2 u_units_to_pixels;highp vec2 u_world_size;highp float u_camera_to_center_distance;highp float u_symbol_fade_change;highp float u_aspect_ratio;highp float u_device_pixel_ratio;highp vec2 u_viewport_size;highp vec2 u_pixel_extrude_scale;highp float u_pitch;};";
 //#endregion
 //#region src/shaders/glsl/_prelude.vertex.glsl.g.ts
-var _prelude_vertex_glsl_g_default = "#ifdef GL_ES\nprecision highp float;\n#else\n#if !defined(lowp)\n#define lowp\n#endif\n#if !defined(mediump)\n#define mediump\n#endif\n#if !defined(highp)\n#define highp\n#endif\n#endif\nvec2 unpack_float(const float packedValue) {int packedIntValue=int(packedValue);int v0=packedIntValue/256;return vec2(v0,packedIntValue-v0*256);}vec2 unpack_opacity(const uint packedOpacity) {return vec2(float(packedOpacity >> 1u)/127.0,float(packedOpacity & 1u));}vec4 decode_color(const vec2 encodedColor) {return vec4(unpack_float(encodedColor[0])/255.0,unpack_float(encodedColor[1])/255.0\n);}float unpack_mix_vec2(const vec2 packedValue,const float t) {return mix(packedValue[0],packedValue[1],t);}vec4 unpack_mix_color(const vec4 packedColors,const float t) {vec4 minColor=decode_color(vec2(packedColors[0],packedColors[1]));vec4 maxColor=decode_color(vec2(packedColors[2],packedColors[3]));return mix(minColor,maxColor,t);}vec2 get_pattern_pos(const vec2 pixel_coord_upper,const vec2 pixel_coord_lower,const vec2 pattern_size,const float tile_units_to_pixels,const vec2 pos) {vec2 offset=mod(mod(mod(pixel_coord_upper,pattern_size)*256.0,pattern_size)*256.0+pixel_coord_lower,pattern_size);return (tile_units_to_pixels*pos+offset)/pattern_size;}mat3 rotationMatrixFromAxisAngle(vec3 u,float angle) {float c=cos(angle);float s=sin(angle);float c2=1.0-c;return mat3(u.x*u.x*c2+      c,u.x*u.y*c2-u.z*s,u.x*u.z*c2+u.y*s,u.y*u.x*c2+u.z*s,u.y*u.y*c2+    c,u.y*u.z*c2-u.x*s,u.z*u.x*c2-u.y*s,u.z*u.y*c2+u.x*s,u.z*u.z*c2+    c\n);}\n#ifdef TERRAIN3D\nuniform sampler2D u_terrain;uniform float u_terrain_dim;uniform mat4 u_terrain_matrix;uniform vec4 u_terrain_unpack;uniform float u_terrain_exaggeration;uniform highp sampler2D u_depth;\n#endif\nconst highp vec4 bitSh=vec4(256.*256.*256.,256.*256.,256.,1.);const highp vec4 bitShifts=vec4(1.)/bitSh;highp float unpack(highp vec4 color) {return dot(color,bitShifts);}highp float depthOpacity(vec3 frag) {\n#ifdef TERRAIN3D\nhighp float d=unpack(texture(u_depth,frag.xy*0.5+0.5))+0.0001-frag.z;return 1.0-max(0.0,min(1.0,-d*500.0));\n#else\nreturn 1.0;\n#endif\n}float calculate_visibility(vec4 pos) {\n#ifdef TERRAIN3D\nvec3 frag=pos.xyz/pos.w;highp float d=depthOpacity(frag);if (d > 0.95) return 1.0;return (d+depthOpacity(frag+vec3(0.0,0.01,0.0)))/2.0;\n#else\nreturn 1.0;\n#endif\n}float ele(ivec2 pos) {\n#ifdef TERRAIN3D\nvec4 rgb=(texelFetch(u_terrain,pos,0)*255.0)*u_terrain_unpack;return rgb.r+rgb.g+rgb.b-u_terrain_unpack.a;\n#else\nreturn 0.0;\n#endif\n}float get_elevation(vec2 pos) {\n#ifdef TERRAIN3D\n#ifdef GLOBE\nif ((pos.y <-32767.5) || (pos.y > 32766.5)) {return 0.0;}\n#endif\nvec2 coord=(u_terrain_matrix*vec4(pos,0.0,1.0)).xy*u_terrain_dim+1.0;vec2 f=fract(coord);ivec2 c=ivec2(floor(coord));ivec2 hi=textureSize(u_terrain,0)-1;float tl=ele(clamp(c,ivec2(0),hi));float tr=ele(clamp(c+ivec2(1,0),ivec2(0),hi));float bl=ele(clamp(c+ivec2(0,1),ivec2(0),hi));float br=ele(clamp(c+ivec2(1,1),ivec2(0),hi));float elevation=mix(mix(tl,tr,f.x),mix(bl,br,f.x),f.y);return elevation*u_terrain_exaggeration;\n#else\nreturn 0.0;\n#endif\n}const float PI=3.141592653589793;uniform mat4 u_projection_matrix;";
+var _prelude_vertex_glsl_g_default = "#ifdef GL_ES\nprecision highp float;\n#else\n#if !defined(lowp)\n#define lowp\n#endif\n#if !defined(mediump)\n#define mediump\n#endif\n#if !defined(highp)\n#define highp\n#endif\n#endif\nvec2 unpack_float(const float packedValue) {int packedIntValue=int(packedValue);int v0=packedIntValue/256;return vec2(v0,packedIntValue-v0*256);}vec2 unpack_opacity(const uint packedOpacity) {return vec2(float(packedOpacity >> 1u)/127.0,float(packedOpacity & 1u));}vec4 decode_color(const vec2 encodedColor) {return vec4(unpack_float(encodedColor[0])/255.0,unpack_float(encodedColor[1])/255.0\n);}float unpack_mix_vec2(const vec2 packedValue,const float t) {return mix(packedValue[0],packedValue[1],t);}vec4 unpack_mix_color(const vec4 packedColors,const float t) {vec4 minColor=decode_color(vec2(packedColors[0],packedColors[1]));vec4 maxColor=decode_color(vec2(packedColors[2],packedColors[3]));return mix(minColor,maxColor,t);}vec2 get_pattern_pos(const vec2 pixel_coord_upper,const vec2 pixel_coord_lower,const vec2 pattern_size,const float tile_units_to_pixels,const vec2 pos) {vec2 offset=mod(mod(mod(pixel_coord_upper,pattern_size)*256.0,pattern_size)*256.0+pixel_coord_lower,pattern_size);return (tile_units_to_pixels*pos+offset)/pattern_size;}mat3 rotationMatrixFromAxisAngle(vec3 u,float angle) {float c=cos(angle);float s=sin(angle);float c2=1.0-c;return mat3(u.x*u.x*c2+      c,u.x*u.y*c2-u.z*s,u.x*u.z*c2+u.y*s,u.y*u.x*c2+u.z*s,u.y*u.y*c2+    c,u.y*u.z*c2-u.x*s,u.z*u.x*c2-u.y*s,u.z*u.y*c2+u.x*s,u.z*u.z*c2+    c\n);}\n#ifdef TERRAIN3D\nuniform sampler2D u_terrain;uniform highp sampler2D u_depth;layout(std140) uniform TerrainUBO {highp mat4 u_terrain_matrix;highp vec4 u_terrain_unpack;highp float u_terrain_dim;highp float u_terrain_exaggeration;};\n#endif\nconst highp vec4 bitSh=vec4(256.*256.*256.,256.*256.,256.,1.);const highp vec4 bitShifts=vec4(1.)/bitSh;highp float unpack(highp vec4 color) {return dot(color,bitShifts);}highp float depthOpacity(vec3 frag) {\n#ifdef TERRAIN3D\nhighp float d=unpack(texture(u_depth,frag.xy*0.5+0.5))+0.0001-frag.z;return 1.0-max(0.0,min(1.0,-d*500.0));\n#else\nreturn 1.0;\n#endif\n}float calculate_visibility(vec4 pos) {\n#ifdef TERRAIN3D\nvec3 frag=pos.xyz/pos.w;highp float d=depthOpacity(frag);if (d > 0.95) return 1.0;return (d+depthOpacity(frag+vec3(0.0,0.01,0.0)))/2.0;\n#else\nreturn 1.0;\n#endif\n}float ele(ivec2 pos) {\n#ifdef TERRAIN3D\nvec4 rgb=(texelFetch(u_terrain,pos,0)*255.0)*u_terrain_unpack;return rgb.r+rgb.g+rgb.b-u_terrain_unpack.a;\n#else\nreturn 0.0;\n#endif\n}float get_elevation(vec2 pos) {\n#ifdef TERRAIN3D\n#ifdef GLOBE\nif ((pos.y <-32767.5) || (pos.y > 32766.5)) {return 0.0;}\n#endif\nvec2 coord=(u_terrain_matrix*vec4(pos,0.0,1.0)).xy*u_terrain_dim+2.0;vec2 f=fract(coord);ivec2 c=ivec2(floor(coord));ivec2 hi=textureSize(u_terrain,0)-1;float tl=ele(clamp(c,ivec2(0),hi));float tr=ele(clamp(c+ivec2(1,0),ivec2(0),hi));float bl=ele(clamp(c+ivec2(0,1),ivec2(0),hi));float br=ele(clamp(c+ivec2(1,1),ivec2(0),hi));float elevation=mix(mix(tl,tr,f.x),mix(bl,br,f.x),f.y);return elevation*u_terrain_exaggeration;\n#else\nreturn 0.0;\n#endif\n}const float PI=3.141592653589793;\n#define PROJECTION_UBO\nlayout(std140) uniform ProjectionUBO {highp mat4 u_projection_matrix;highp mat4 u_projection_fallback_matrix;highp vec4 u_projection_tile_mercator_coords;highp vec4 u_projection_clipping_plane;highp float u_projection_transition;highp int u_projection_clip_antimeridian;};layout(std140) uniform FrameUBO {highp vec2 u_units_to_pixels;highp vec2 u_world_size;highp float u_camera_to_center_distance;highp float u_symbol_fade_change;highp float u_aspect_ratio;highp float u_device_pixel_ratio;highp vec2 u_viewport_size;highp vec2 u_pixel_extrude_scale;highp float u_pitch;};";
 //#endregion
 //#region src/shaders/glsl/background.fragment.glsl.g.ts
 var background_fragment_glsl_g_default = "uniform vec4 u_color;uniform float u_opacity;void main() {fragColor=u_color*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}";
@@ -9056,7 +9479,7 @@ var background_pattern_vertex_glsl_g_default = "uniform vec2 u_pattern_size_a;un
 var circle_fragment_glsl_g_default = "in vec3 v_data;flat in float v_visibility;\n#pragma maplibre: define highp vec4 color\n#pragma maplibre: define mediump float radius\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define highp vec4 stroke_color\n#pragma maplibre: define mediump float stroke_width\n#pragma maplibre: define lowp float stroke_opacity\nvoid main() {\n#pragma maplibre: initialize highp vec4 color\n#pragma maplibre: initialize mediump float radius\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize highp vec4 stroke_color\n#pragma maplibre: initialize mediump float stroke_width\n#pragma maplibre: initialize lowp float stroke_opacity\nvec2 extrude=v_data.xy;float extrude_length=length(extrude);float antialiased_blur=v_data.z;float opacity_t=smoothstep(0.0,antialiased_blur,extrude_length-1.0);float color_t=stroke_width < 0.01 ? 0.0 : smoothstep(antialiased_blur,0.0,extrude_length-radius/(radius+stroke_width));fragColor=v_visibility*opacity_t*mix(color*opacity,stroke_color*stroke_opacity,color_t);const float epsilon=0.5/255.0;if (fragColor.r < epsilon && fragColor.g < epsilon && fragColor.b < epsilon && fragColor.a < epsilon) {discard;}\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}";
 //#endregion
 //#region src/shaders/glsl/circle.vertex.glsl.g.ts
-var circle_vertex_glsl_g_default = "uniform bool u_scale_with_map;uniform bool u_pitch_with_map;uniform vec2 u_extrude_scale;uniform highp float u_globe_extrude_scale;uniform lowp float u_device_pixel_ratio;uniform highp float u_camera_to_center_distance;uniform vec2 u_translate;layout(location=0) in ivec2 a_pos;out vec3 v_data;flat out float v_visibility;\n#pragma maplibre: define highp vec4 color\n#pragma maplibre: define mediump float radius\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define highp vec4 stroke_color\n#pragma maplibre: define mediump float stroke_width\n#pragma maplibre: define lowp float stroke_opacity\nvoid main(void) {\n#pragma maplibre: initialize highp vec4 color\n#pragma maplibre: initialize mediump float radius\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize highp vec4 stroke_color\n#pragma maplibre: initialize mediump float stroke_width\n#pragma maplibre: initialize lowp float stroke_opacity\nivec2 pos_raw=a_pos+32768;vec2 extrude=vec2(pos_raw & 7)/7.0*2.0-1.0;vec2 circle_center=vec2(pos_raw >> 3)+u_translate;float ele=get_elevation(circle_center);v_visibility=calculate_visibility(projectTileWithElevation(circle_center,ele));if (u_pitch_with_map) {\n#ifdef GLOBE\nvec3 center_vector=projectToSphere(circle_center);\n#endif\nfloat angle_scale=u_globe_extrude_scale;vec2 corner_position=circle_center;if (u_scale_with_map) {angle_scale*=(radius+stroke_width);corner_position+=extrude*u_extrude_scale*(radius+stroke_width);} else {\n#ifdef GLOBE\nvec4 projected_center=interpolateProjection(circle_center,center_vector,ele);\n#else\nvec4 projected_center=projectTileWithElevation(circle_center,ele);\n#endif\ncorner_position+=extrude*u_extrude_scale*(radius+stroke_width)*(projected_center.w/u_camera_to_center_distance);angle_scale*=(radius+stroke_width)*(projected_center.w/u_camera_to_center_distance);}\n#ifdef GLOBE\nvec2 angles=extrude*angle_scale;vec3 corner_vector=globeRotateVector(center_vector,angles);gl_Position=interpolateProjection(corner_position,corner_vector,ele);\n#else\ngl_Position=projectTileWithElevation(corner_position,ele);\n#endif\n} else {gl_Position=projectTileWithElevation(circle_center,ele);if (gl_Position.z/gl_Position.w > 1.0) {gl_Position.xy=vec2(10000.0);}if (u_scale_with_map) {gl_Position.xy+=extrude*(radius+stroke_width)*u_extrude_scale*u_camera_to_center_distance;} else {gl_Position.xy+=extrude*(radius+stroke_width)*u_extrude_scale*gl_Position.w;}}float antialiasblur=-max(1.0/u_device_pixel_ratio/(radius+stroke_width),blur);v_data=vec3(extrude.x,extrude.y,antialiasblur);}";
+var circle_vertex_glsl_g_default = "uniform bool u_scale_with_map;uniform bool u_pitch_with_map;uniform vec2 u_extrude_scale;uniform highp float u_globe_extrude_scale;uniform vec2 u_translate;layout(location=0) in ivec2 a_pos;out vec3 v_data;flat out float v_visibility;\n#pragma maplibre: define highp vec4 color\n#pragma maplibre: define mediump float radius\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define highp vec4 stroke_color\n#pragma maplibre: define mediump float stroke_width\n#pragma maplibre: define lowp float stroke_opacity\nvoid main(void) {\n#pragma maplibre: initialize highp vec4 color\n#pragma maplibre: initialize mediump float radius\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize highp vec4 stroke_color\n#pragma maplibre: initialize mediump float stroke_width\n#pragma maplibre: initialize lowp float stroke_opacity\nivec2 pos_raw=a_pos+32768;vec2 extrude=vec2(pos_raw & 7)/7.0*2.0-1.0;vec2 circle_center=vec2(pos_raw >> 3)+u_translate;float ele=get_elevation(circle_center);v_visibility=calculate_visibility(projectTileWithElevation(circle_center,ele));if (u_pitch_with_map) {\n#ifdef GLOBE\nvec3 center_vector=projectToSphere(circle_center);\n#endif\nfloat angle_scale=u_globe_extrude_scale;vec2 corner_position=circle_center;if (u_scale_with_map) {angle_scale*=(radius+stroke_width);corner_position+=extrude*u_extrude_scale*(radius+stroke_width);} else {\n#ifdef GLOBE\nvec4 projected_center=interpolateProjection(circle_center,center_vector,ele);\n#else\nvec4 projected_center=projectTileWithElevation(circle_center,ele);\n#endif\ncorner_position+=extrude*u_extrude_scale*(radius+stroke_width)*(projected_center.w/u_camera_to_center_distance);angle_scale*=(radius+stroke_width)*(projected_center.w/u_camera_to_center_distance);}\n#ifdef GLOBE\nvec2 angles=extrude*angle_scale;vec3 corner_vector=globeRotateVector(center_vector,angles);gl_Position=interpolateProjection(corner_position,corner_vector,ele);\n#else\ngl_Position=projectTileWithElevation(corner_position,ele);\n#endif\n} else {gl_Position=projectTileWithElevation(circle_center,ele);if (gl_Position.z/gl_Position.w > 1.0) {gl_Position.xy=vec2(10000.0);}if (u_scale_with_map) {gl_Position.xy+=extrude*(radius+stroke_width)*u_extrude_scale*u_camera_to_center_distance;} else {gl_Position.xy+=extrude*(radius+stroke_width)*u_extrude_scale*gl_Position.w;}}float antialiasblur=-max(1.0/u_device_pixel_ratio/(radius+stroke_width),blur);v_data=vec3(extrude.x,extrude.y,antialiasblur);}";
 //#endregion
 //#region src/shaders/glsl/clipping_mask.fragment.glsl.g.ts
 var clipping_mask_fragment_glsl_g_default = "void main() {fragColor=vec4(1.0);}";
@@ -9065,40 +9488,40 @@ var clipping_mask_fragment_glsl_g_default = "void main() {fragColor=vec4(1.0);}"
 const shaders = {
 	prelude: prepare(_prelude_fragment_glsl_g_default, _prelude_vertex_glsl_g_default),
 	projectionMercator: prepare("\nvoid clipAntimeridian() {}", "float projectLineThickness(float tileY) {return 1.0;}float projectCircleRadius(float tileY) {return 1.0;}vec4 projectTile(vec2 p) {vec4 result=u_projection_matrix*vec4(p,0.0,1.0);return result;}vec4 projectTile(vec2 p,vec2 rawPos) {vec4 result=u_projection_matrix*vec4(p,0.0,1.0);if (rawPos.y <-32767.5 || rawPos.y > 32766.5) {result.z=-10000000.0;}return result;}vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return u_projection_matrix*vec4(posInTile,elevation,1.0);}vec4 projectTileFor3D(vec2 posInTile,float elevation) {return projectTileWithElevation(posInTile,elevation);}"),
-	projectionGlobe: prepare("uniform bool u_projection_clip_antimeridian;in highp float v_projection_tile_x;void clipAntimeridian() {if (u_projection_clip_antimeridian && (v_projection_tile_x < 0.0 || v_projection_tile_x >=8192.0)) {discard;}}", "#define GLOBE_RADIUS 6371008.8\nuniform highp vec4 u_projection_tile_mercator_coords;uniform highp vec4 u_projection_clipping_plane;uniform highp float u_projection_transition;uniform mat4 u_projection_fallback_matrix;out highp float v_projection_tile_x;vec3 globeRotateVector(vec3 vec,vec2 angles) {vec3 axisRight=vec3(vec.z,0.0,-vec.x);vec3 axisUp=cross(axisRight,vec);axisRight=normalize(axisRight);axisUp=normalize(axisUp);vec2 t=tan(angles);return normalize(vec+axisRight*t.x+axisUp*t.y);}mat3 globeGetRotationMatrix(vec3 spherePos) {vec3 axisRight=vec3(spherePos.z,0.0,-spherePos.x);vec3 axisDown=cross(axisRight,spherePos);axisRight=normalize(axisRight);axisDown=normalize(axisDown);return mat3(axisRight,axisDown,spherePos\n);}float circumferenceRatioAtTileY(float tileY) {float mercator_pos_y=u_projection_tile_mercator_coords.y+u_projection_tile_mercator_coords.w*tileY;float t=exp(PI-(mercator_pos_y*PI*2.0));return (2.0*t)/(t*t+1.0);}float projectLineThickness(float tileY) {float thickness=1.0/circumferenceRatioAtTileY(tileY);if (u_projection_transition < 0.999) {return mix(1.0,thickness,u_projection_transition);} else {return thickness;}}vec3 projectToSphere(vec2 translatedPos,vec2 rawPos) {vec2 mercator_pos=u_projection_tile_mercator_coords.xy+u_projection_tile_mercator_coords.zw*translatedPos;float spherical_x=mercator_pos.x*PI*2.0+PI;float t=exp(PI-(mercator_pos.y*PI*2.0));float t2=t*t;float denom=t2+1.0;float sin_sy=(t2-1.0)/denom;float cos_sy=(2.0*t)/denom;vec3 pos=vec3(sin(spherical_x)*cos_sy,sin_sy,cos(spherical_x)*cos_sy\n);if (rawPos.y <-32767.5) {pos=vec3(0.0,1.0,0.0);}if (rawPos.y > 32766.5) {pos=vec3(0.0,-1.0,0.0);}return pos;}vec3 projectToSphere(vec2 posInTile) {return projectToSphere(posInTile,vec2(0.0,0.0));}float globeComputeClippingZ(vec3 spherePos) {return (1.0-(dot(spherePos,u_projection_clipping_plane.xyz)+u_projection_clipping_plane.w));}vec4 interpolateProjection(vec2 posInTile,vec3 spherePos,float elevation) {v_projection_tile_x=posInTile.x;vec3 elevatedPos=spherePos*(1.0+elevation/GLOBE_RADIUS);vec4 globePosition=u_projection_matrix*vec4(elevatedPos,1.0);globePosition.z=globeComputeClippingZ(elevatedPos)*globePosition.w;if (u_projection_transition > 0.999) {return globePosition;}vec4 flatPosition=u_projection_fallback_matrix*vec4(posInTile,elevation,1.0);const float z_globeness_threshold=0.2;vec4 result=globePosition;result.z=mix(0.0,globePosition.z,clamp((u_projection_transition-z_globeness_threshold)/(1.0-z_globeness_threshold),0.0,1.0));result.xyw=mix(flatPosition.xyw,globePosition.xyw,u_projection_transition);if ((posInTile.y <-32767.5) || (posInTile.y > 32766.5)) {result=globePosition;const float poles_hidden_anim_percentage=0.02;result.z=mix(globePosition.z,100.0,pow(max((1.0-u_projection_transition)/poles_hidden_anim_percentage,0.0),8.0));}return result;}vec4 interpolateProjectionFor3D(vec2 posInTile,vec3 spherePos,float elevation) {v_projection_tile_x=posInTile.x;vec3 elevatedPos=spherePos*(1.0+elevation/GLOBE_RADIUS);vec4 globePosition=u_projection_matrix*vec4(elevatedPos,1.0);if (u_projection_transition > 0.999) {return globePosition;}vec4 fallbackPosition=u_projection_fallback_matrix*vec4(posInTile,elevation,1.0);return mix(fallbackPosition,globePosition,u_projection_transition);}vec4 projectTile(vec2 posInTile) {return interpolateProjection(posInTile,projectToSphere(posInTile),0.0);}vec4 projectTile(vec2 posInTile,vec2 rawPos) {return interpolateProjection(posInTile,projectToSphere(posInTile,rawPos),0.0);}vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return interpolateProjection(posInTile,projectToSphere(posInTile),elevation);}vec4 projectTileFor3D(vec2 posInTile,float elevation) {vec3 spherePos=projectToSphere(posInTile,posInTile);return interpolateProjectionFor3D(posInTile,spherePos,elevation);}"),
+	projectionGlobe: prepare("in highp float v_projection_tile_x;void clipAntimeridian() {if (u_projection_clip_antimeridian !=0 && (v_projection_tile_x < 0.0 || v_projection_tile_x >=8192.0)) {discard;}}", "#define GLOBE_RADIUS 6371008.8\n#ifndef PROJECTION_UBO\nuniform highp vec4 u_projection_tile_mercator_coords;uniform highp vec4 u_projection_clipping_plane;uniform highp float u_projection_transition;uniform mat4 u_projection_fallback_matrix;\n#endif\nout highp float v_projection_tile_x;vec3 globeRotateVector(vec3 vec,vec2 angles) {vec3 axisRight=vec3(vec.z,0.0,-vec.x);vec3 axisUp=cross(axisRight,vec);axisRight=normalize(axisRight);axisUp=normalize(axisUp);vec2 t=tan(angles);return normalize(vec+axisRight*t.x+axisUp*t.y);}mat3 globeGetRotationMatrix(vec3 spherePos) {vec3 axisRight=vec3(spherePos.z,0.0,-spherePos.x);vec3 axisDown=cross(axisRight,spherePos);axisRight=normalize(axisRight);axisDown=normalize(axisDown);return mat3(axisRight,axisDown,spherePos\n);}float circumferenceRatioAtTileY(float tileY) {float mercator_pos_y=u_projection_tile_mercator_coords.y+u_projection_tile_mercator_coords.w*tileY;float t=exp(PI-(mercator_pos_y*PI*2.0));return (2.0*t)/(t*t+1.0);}float projectLineThickness(float tileY) {float thickness=1.0/circumferenceRatioAtTileY(tileY);if (u_projection_transition < 0.999) {return mix(1.0,thickness,u_projection_transition);} else {return thickness;}}vec3 projectToSphere(vec2 translatedPos,vec2 rawPos) {vec2 mercator_pos=u_projection_tile_mercator_coords.xy+u_projection_tile_mercator_coords.zw*translatedPos;float spherical_x=mercator_pos.x*PI*2.0+PI;float t=exp(PI-(mercator_pos.y*PI*2.0));float t2=t*t;float denom=t2+1.0;float sin_sy=(t2-1.0)/denom;float cos_sy=(2.0*t)/denom;vec3 pos=vec3(sin(spherical_x)*cos_sy,sin_sy,cos(spherical_x)*cos_sy\n);if (rawPos.y <-32767.5) {pos=vec3(0.0,1.0,0.0);}if (rawPos.y > 32766.5) {pos=vec3(0.0,-1.0,0.0);}return pos;}vec3 projectToSphere(vec2 posInTile) {return projectToSphere(posInTile,vec2(0.0,0.0));}float globeComputeClippingZ(vec3 spherePos) {return (1.0-(dot(spherePos,u_projection_clipping_plane.xyz)+u_projection_clipping_plane.w));}vec4 interpolateProjection(vec2 posInTile,vec3 spherePos,float elevation) {v_projection_tile_x=posInTile.x;vec3 elevatedPos=spherePos*(1.0+elevation/GLOBE_RADIUS);vec4 globePosition=u_projection_matrix*vec4(elevatedPos,1.0);globePosition.z=globeComputeClippingZ(elevatedPos)*globePosition.w;if (u_projection_transition > 0.999) {return globePosition;}vec4 flatPosition=u_projection_fallback_matrix*vec4(posInTile,elevation,1.0);const float z_globeness_threshold=0.2;vec4 result=globePosition;result.z=mix(0.0,globePosition.z,clamp((u_projection_transition-z_globeness_threshold)/(1.0-z_globeness_threshold),0.0,1.0));result.xyw=mix(flatPosition.xyw,globePosition.xyw,u_projection_transition);if ((posInTile.y <-32767.5) || (posInTile.y > 32766.5)) {result=globePosition;const float poles_hidden_anim_percentage=0.02;result.z=mix(globePosition.z,100.0,pow(max((1.0-u_projection_transition)/poles_hidden_anim_percentage,0.0),8.0));}return result;}vec4 interpolateProjectionFor3D(vec2 posInTile,vec3 spherePos,float elevation) {v_projection_tile_x=posInTile.x;vec3 elevatedPos=spherePos*(1.0+elevation/GLOBE_RADIUS);vec4 globePosition=u_projection_matrix*vec4(elevatedPos,1.0);if (u_projection_transition > 0.999) {return globePosition;}vec4 fallbackPosition=u_projection_fallback_matrix*vec4(posInTile,elevation,1.0);return mix(fallbackPosition,globePosition,u_projection_transition);}vec4 projectTile(vec2 posInTile) {return interpolateProjection(posInTile,projectToSphere(posInTile),0.0);}vec4 projectTile(vec2 posInTile,vec2 rawPos) {return interpolateProjection(posInTile,projectToSphere(posInTile,rawPos),0.0);}vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return interpolateProjection(posInTile,projectToSphere(posInTile),elevation);}vec4 projectTileFor3D(vec2 posInTile,float elevation) {vec3 spherePos=projectToSphere(posInTile,posInTile);return interpolateProjectionFor3D(posInTile,spherePos,elevation);}"),
 	background: prepare(background_fragment_glsl_g_default, background_vertex_glsl_g_default),
 	backgroundPattern: prepare(background_pattern_fragment_glsl_g_default, background_pattern_vertex_glsl_g_default),
 	circle: prepare(circle_fragment_glsl_g_default, circle_vertex_glsl_g_default),
 	clippingMask: prepare(clipping_mask_fragment_glsl_g_default, "layout(location=0) in vec2 a_pos;void main() {gl_Position=projectTile(a_pos);}"),
 	heatmap: prepare("uniform highp float u_intensity;in vec2 v_extrude;\n#pragma maplibre: define highp float weight\n#define GAUSS_COEF 0.3989422804014327\nvoid main() {\n#pragma maplibre: initialize highp float weight\nfloat d=-0.5*3.0*3.0*dot(v_extrude,v_extrude);float val=weight*u_intensity*GAUSS_COEF*exp(d);fragColor=vec4(val,1.0,1.0,1.0);\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform float u_extrude_scale;uniform float u_opacity;uniform float u_intensity;uniform highp float u_globe_extrude_scale;layout(location=0) in ivec2 a_pos;out vec2 v_extrude;\n#pragma maplibre: define highp float weight\n#pragma maplibre: define mediump float radius\nconst highp float ZERO=1.0/255.0/16.0;\n#define GAUSS_COEF 0.3989422804014327\nvoid main(void) {\n#pragma maplibre: initialize highp float weight\n#pragma maplibre: initialize mediump float radius\nivec2 pos_raw=a_pos+32768;vec2 unscaled_extrude=vec2(pos_raw & 7)/7.0*2.0-1.0;float S=sqrt(-2.0*log(ZERO/weight/u_intensity/GAUSS_COEF))/3.0;v_extrude=S*unscaled_extrude;vec2 extrude=v_extrude*radius*u_extrude_scale;vec2 circle_center=vec2(pos_raw >> 3);\n#ifdef GLOBE\nvec2 angles=v_extrude*radius*u_globe_extrude_scale;vec3 center_vector=projectToSphere(circle_center);vec3 corner_vector=globeRotateVector(center_vector,angles);gl_Position=interpolateProjection(circle_center+extrude,corner_vector,0.0);\n#else\ngl_Position=projectTileFor3D(circle_center+extrude,get_elevation(circle_center));\n#endif\n}"),
-	heatmapTexture: prepare("uniform sampler2D u_image;uniform sampler2D u_color_ramp;uniform float u_opacity;in vec2 v_pos;void main() {float t=texture(u_image,v_pos).r;vec4 color=texture(u_color_ramp,vec2(t,0.5));fragColor=color*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(0.0);\n#endif\n}", "uniform mat4 u_matrix;uniform vec2 u_world;layout(location=0) in vec2 a_pos;out vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos*u_world,0,1);v_pos.x=a_pos.x;v_pos.y=1.0-a_pos.y;}"),
-	collisionBox: prepare("flat in float v_placed;flat in float v_notUsed;void main() {float alpha=0.5;fragColor=vec4(1.0,0.0,0.0,1.0)*alpha;if (v_placed > 0.5) {fragColor=vec4(0.0,0.0,1.0,0.5)*alpha;}if (v_notUsed > 0.5) {fragColor*=.1;}}", "layout(location=0) in vec2 a_anchor_pos;layout(location=1) in vec2 a_placed;layout(location=2) in vec2 a_box_real;uniform vec2 u_pixel_extrude_scale;flat out float v_placed;flat out float v_notUsed;void main() {gl_Position=projectTileWithElevation(a_anchor_pos,get_elevation(a_anchor_pos));gl_Position.xy=((a_box_real+0.5)*u_pixel_extrude_scale*2.0-1.0)*vec2(1.0,-1.0)*gl_Position.w;if (gl_Position.z/gl_Position.w < 1.1) {gl_Position.z=0.5;}v_placed=a_placed.x;v_notUsed=a_placed.y;}"),
-	collisionCircle: prepare("flat in float v_radius;in vec2 v_extrude;flat in float v_collision;void main() {float alpha=0.5;float stroke_radius=0.9;float distance_to_center=length(v_extrude);float distance_to_edge=abs(distance_to_center-v_radius);float opacity_t=smoothstep(-stroke_radius,0.0,-distance_to_edge);vec4 color=mix(vec4(0.0,0.0,1.0,0.5),vec4(1.0,0.0,0.0,1.0),v_collision);fragColor=color*alpha*opacity_t;}", "layout(location=0) in vec2 a_pos;layout(location=1) in float a_radius;layout(location=2) in vec2 a_flags;uniform vec2 u_viewport_size;flat out float v_radius;out vec2 v_extrude;flat out float v_collision;void main() {float radius=a_radius;float collision=a_flags.x;float vertexIdx=a_flags.y;vec2 quadVertexOffset=vec2(mix(-1.0,1.0,float(vertexIdx >=2.0)),mix(-1.0,1.0,float(vertexIdx >=1.0 && vertexIdx <=2.0)));vec2 quadVertexExtent=quadVertexOffset*radius;float padding_factor=1.2;v_radius=radius;v_extrude=quadVertexExtent*padding_factor;v_collision=collision;gl_Position=vec4((a_pos/u_viewport_size*2.0-1.0)*vec2(1.0,-1.0),0.0,1.0)+vec4(quadVertexExtent*padding_factor/u_viewport_size*2.0,0.0,0.0);}"),
-	colorRelief: prepare("#ifdef GL_ES\nprecision highp float;\n#endif\nuniform sampler2D u_image;uniform vec4 u_unpack;uniform sampler2D u_elevation_stops;uniform sampler2D u_color_stops;uniform int u_color_ramp_size;uniform float u_opacity;in vec2 v_pos;float getElevation(vec2 coord) {vec4 data=texture(u_image,coord)*255.0;data.a=-1.0;return dot(data,u_unpack);}float getElevationStop(int stop) {vec4 data=texelFetch(u_elevation_stops,ivec2(stop,0),0)*255.0;data.a=-1.0;return dot(data,u_unpack);}void main() {float el=getElevation(v_pos);int r=(u_color_ramp_size-1);int l=0;float el_l=getElevationStop(l);float el_r=getElevationStop(r);while(r-l > 1){int m=(r+l)/2;float el_m=getElevationStop(m);if(el < el_m){r=m;el_r=el_m;}else\n{l=m;el_l=el_m;}}float x=(float(l)+(el-el_l)/(el_r-el_l)+0.5)/float(u_color_ramp_size);fragColor=u_opacity*texture(u_color_stops,vec2(x,0));\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_dimension;layout(location=0) in vec2 a_pos;out vec2 v_pos;void main() {gl_Position=projectTile(a_pos,a_pos);highp vec2 epsilon=1.0/u_dimension;float scale=(u_dimension.x-2.0)/u_dimension.x;v_pos=(a_pos/8192.0)*scale+epsilon;if (a_pos.y <-32767.5) {v_pos.y=0.0;}if (a_pos.y > 32766.5) {v_pos.y=1.0;}}"),
+	heatmapTexture: prepare("uniform sampler2D u_image;uniform sampler2D u_color_ramp;uniform float u_opacity;in vec2 v_pos;void main() {float t=texture(u_image,v_pos).r;vec4 color=texture(u_color_ramp,vec2(t,0.5));fragColor=color*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(0.0);\n#endif\n}", "uniform mat4 u_matrix;layout(location=0) in vec2 a_pos;out vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos*u_world_size,0,1);v_pos.x=a_pos.x;v_pos.y=1.0-a_pos.y;}"),
+	collisionBox: prepare("flat in float v_placed;flat in float v_notUsed;void main() {float alpha=0.5;fragColor=vec4(1.0,0.0,0.0,1.0)*alpha;if (v_placed > 0.5) {fragColor=vec4(0.0,0.0,1.0,0.5)*alpha;}if (v_notUsed > 0.5) {fragColor*=.1;}}", "layout(location=0) in vec2 a_anchor_pos;layout(location=1) in vec2 a_placed;layout(location=2) in vec2 a_box_real;flat out float v_placed;flat out float v_notUsed;void main() {gl_Position=projectTileWithElevation(a_anchor_pos,get_elevation(a_anchor_pos));gl_Position.xy=((a_box_real+0.5)*u_pixel_extrude_scale*2.0-1.0)*vec2(1.0,-1.0)*gl_Position.w;if (gl_Position.z/gl_Position.w < 1.1) {gl_Position.z=0.5;}v_placed=a_placed.x;v_notUsed=a_placed.y;}"),
+	collisionCircle: prepare("flat in float v_radius;in vec2 v_extrude;flat in float v_collision;void main() {float alpha=0.5;float stroke_radius=0.9;float distance_to_center=length(v_extrude);float distance_to_edge=abs(distance_to_center-v_radius);float opacity_t=smoothstep(-stroke_radius,0.0,-distance_to_edge);vec4 color=mix(vec4(0.0,0.0,1.0,0.5),vec4(1.0,0.0,0.0,1.0),v_collision);fragColor=color*alpha*opacity_t;}", "layout(location=0) in vec2 a_pos;layout(location=1) in float a_radius;layout(location=2) in vec2 a_flags;flat out float v_radius;out vec2 v_extrude;flat out float v_collision;void main() {float radius=a_radius;float collision=a_flags.x;float vertexIdx=a_flags.y;vec2 quadVertexOffset=vec2(mix(-1.0,1.0,float(vertexIdx >=2.0)),mix(-1.0,1.0,float(vertexIdx >=1.0 && vertexIdx <=2.0)));vec2 quadVertexExtent=quadVertexOffset*radius;float padding_factor=1.2;v_radius=radius;v_extrude=quadVertexExtent*padding_factor;v_collision=collision;gl_Position=vec4((a_pos/u_viewport_size*2.0-1.0)*vec2(1.0,-1.0),0.0,1.0)+vec4(quadVertexExtent*padding_factor/u_viewport_size*2.0,0.0,0.0);}"),
+	colorRelief: prepare("#ifdef GL_ES\nprecision highp float;\n#endif\nuniform sampler2D u_image;uniform vec4 u_unpack;uniform sampler2D u_elevation_stops;uniform sampler2D u_color_stops;uniform int u_color_ramp_size;uniform float u_opacity;in vec2 v_pos;float getElevation(vec2 coord) {vec4 data=texture(u_image,coord)*255.0;data.a=-1.0;return dot(data,u_unpack);}float getElevationStop(int stop) {vec4 data=texelFetch(u_elevation_stops,ivec2(stop,0),0)*255.0;data.a=-1.0;return dot(data,u_unpack);}void main() {float el=getElevation(v_pos);int r=(u_color_ramp_size-1);int l=0;float el_l=getElevationStop(l);float el_r=getElevationStop(r);while(r-l > 1){int m=(r+l)/2;float el_m=getElevationStop(m);if(el < el_m){r=m;el_r=el_m;}else\n{l=m;el_l=el_m;}}float x=(float(l)+(el-el_l)/(el_r-el_l)+0.5)/float(u_color_ramp_size);fragColor=u_opacity*texture(u_color_stops,vec2(x,0));\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_dimension;layout(location=0) in vec2 a_pos;out vec2 v_pos;void main() {gl_Position=projectTile(a_pos,a_pos);highp vec2 epsilon=2.0/u_dimension;float scale=(u_dimension.x-4.0)/u_dimension.x;v_pos=(a_pos/8192.0)*scale+epsilon;if (a_pos.y <-32767.5) {v_pos.y=0.0;}if (a_pos.y > 32766.5) {v_pos.y=1.0;}}"),
 	debug: prepare("uniform highp vec4 u_color;uniform sampler2D u_overlay;in vec2 v_uv;void main() {vec4 overlay_color=texture(u_overlay,v_uv);fragColor=mix(u_color,overlay_color,overlay_color.a);}", "layout(location=0) in vec2 a_pos;out vec2 v_uv;uniform float u_overlay_scale;void main() {v_uv=a_pos/8192.0;gl_Position=projectTileWithElevation(a_pos*u_overlay_scale,get_elevation(a_pos));}"),
 	depth: prepare(clipping_mask_fragment_glsl_g_default, "layout(location=0) in vec2 a_pos;void main() {\n#ifdef GLOBE\ngl_Position=projectTileFor3D(a_pos,0.0);\n#else\ngl_Position=u_projection_matrix*vec4(a_pos,0.0,1.0);\n#endif\n}"),
 	fill: prepare("#pragma maplibre: define highp vec4 color\n#pragma maplibre: define lowp float opacity\nvoid main() {\n#pragma maplibre: initialize highp vec4 color\n#pragma maplibre: initialize lowp float opacity\nfragColor=color*opacity;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_fill_translate;layout(location=0) in vec2 a_pos;\n#pragma maplibre: define highp vec4 color\n#pragma maplibre: define lowp float opacity\nvoid main() {\n#pragma maplibre: initialize highp vec4 color\n#pragma maplibre: initialize lowp float opacity\nif (opacity < 0.01) {gl_Position=vec4(-2.0,-2.0,-2.0,1.0);return;}gl_Position=projectTile(a_pos+u_fill_translate,a_pos);}"),
-	fillOutline: prepare("in vec2 v_pos;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define highp vec4 outline_color\n#pragma maplibre: define lowp float opacity\nvoid main() {\n#pragma maplibre: initialize highp vec4 outline_color\n#pragma maplibre: initialize lowp float opacity\nfloat dist=length(v_pos-gl_FragCoord.xy);float alpha=1.0-smoothstep(0.0,1.0,dist);fragColor=outline_color*(alpha*opacity);\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_world;uniform vec2 u_fill_translate;layout(location=0) in vec2 a_pos;out vec2 v_pos;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma maplibre: define highp vec4 outline_color\n#pragma maplibre: define lowp float opacity\nvoid main() {\n#pragma maplibre: initialize highp vec4 outline_color\n#pragma maplibre: initialize lowp float opacity\nif (opacity < 0.01) {gl_Position=vec4(-2.0,-2.0,-2.0,1.0);return;}gl_Position=projectTile(a_pos+u_fill_translate,a_pos);v_pos=(gl_Position.xy/gl_Position.w+1.0)/2.0*u_world;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n}"),
-	fillOutlinePattern: prepare("uniform vec2 u_texsize;uniform sampler2D u_image;uniform float u_fade;in vec2 v_pos_a;in vec2 v_pos_b;in vec2 v_pos;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define lowp vec4 pattern_from\n#pragma maplibre: define lowp vec4 pattern_to\nvoid main() {\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize mediump vec4 pattern_from\n#pragma maplibre: initialize mediump vec4 pattern_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture(u_image,pos2);float dist=length(v_pos-gl_FragCoord.xy);float alpha=1.0-smoothstep(0.0,1.0,dist);fragColor=mix(color1,color2,u_fade)*alpha*opacity;\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_world;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform vec3 u_scale;uniform vec2 u_fill_translate;layout(location=0) in vec2 a_pos;out vec2 v_pos_a;out vec2 v_pos_b;out vec2 v_pos;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define lowp vec4 pattern_from\n#pragma maplibre: define lowp vec4 pattern_to\n#pragma maplibre: define lowp float pixel_ratio_from\n#pragma maplibre: define lowp float pixel_ratio_to\nvoid main() {\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize mediump vec4 pattern_from\n#pragma maplibre: initialize mediump vec4 pattern_to\n#pragma maplibre: initialize lowp float pixel_ratio_from\n#pragma maplibre: initialize lowp float pixel_ratio_to\nif (opacity < 0.01) {gl_Position=vec4(-2.0,-2.0,-2.0,1.0);return;}vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;gl_Position=projectTile(a_pos+u_fill_translate,a_pos);vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileRatio,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileRatio,a_pos);v_pos=(gl_Position.xy/gl_Position.w+1.0)/2.0*u_world;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n}"),
-	fillPattern: prepare("#ifdef GL_ES\nprecision highp float;\n#endif\nuniform vec2 u_texsize;uniform float u_fade;uniform sampler2D u_image;in vec2 v_pos_a;in vec2 v_pos_b;\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define lowp vec4 pattern_from\n#pragma maplibre: define lowp vec4 pattern_to\nvoid main() {\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize mediump vec4 pattern_from\n#pragma maplibre: initialize mediump vec4 pattern_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture(u_image,pos2);fragColor=mix(color1,color2,u_fade)*opacity;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform vec3 u_scale;uniform vec2 u_fill_translate;layout(location=0) in vec2 a_pos;out vec2 v_pos_a;out vec2 v_pos_b;\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define lowp vec4 pattern_from\n#pragma maplibre: define lowp vec4 pattern_to\n#pragma maplibre: define lowp float pixel_ratio_from\n#pragma maplibre: define lowp float pixel_ratio_to\nvoid main() {\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize mediump vec4 pattern_from\n#pragma maplibre: initialize mediump vec4 pattern_to\n#pragma maplibre: initialize lowp float pixel_ratio_from\n#pragma maplibre: initialize lowp float pixel_ratio_to\nif (opacity < 0.01) {gl_Position=vec4(-2.0,-2.0,-2.0,1.0);return;}vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileZoomRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;gl_Position=projectTile(a_pos+u_fill_translate,a_pos);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileZoomRatio,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileZoomRatio,a_pos);}"),
+	fillOutline: prepare("in vec2 v_pos;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define highp vec4 outline_color\n#pragma maplibre: define lowp float opacity\nvoid main() {\n#pragma maplibre: initialize highp vec4 outline_color\n#pragma maplibre: initialize lowp float opacity\nfloat dist=length(v_pos-gl_FragCoord.xy);float alpha=1.0-smoothstep(0.0,1.0,dist);fragColor=outline_color*(alpha*opacity);\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_fill_translate;layout(location=0) in vec2 a_pos;out vec2 v_pos;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma maplibre: define highp vec4 outline_color\n#pragma maplibre: define lowp float opacity\nvoid main() {\n#pragma maplibre: initialize highp vec4 outline_color\n#pragma maplibre: initialize lowp float opacity\nif (opacity < 0.01) {gl_Position=vec4(-2.0,-2.0,-2.0,1.0);return;}gl_Position=projectTile(a_pos+u_fill_translate,a_pos);v_pos=(gl_Position.xy/gl_Position.w+1.0)/2.0*u_world_size;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n}"),
+	fillOutlinePattern: prepare("uniform vec2 u_texsize;uniform sampler2D u_image;uniform float u_fade;uniform bool u_sdf_pattern;in vec2 v_pos_a;in vec2 v_pos_b;in vec2 v_pos;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define highp vec4 color\n#pragma maplibre: define lowp vec4 pattern_from\n#pragma maplibre: define lowp vec4 pattern_to\nvoid main() {\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize highp vec4 color\n#pragma maplibre: initialize mediump vec4 pattern_from\n#pragma maplibre: initialize mediump vec4 pattern_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture(u_image,pos2);float dist=length(v_pos-gl_FragCoord.xy);float alpha=1.0-smoothstep(0.0,1.0,dist);if (u_sdf_pattern) {highp float sdf_edge=(256.0-64.0)/256.0;highp float sdf_gamma_a=max(fwidth(color1.a)*0.5,1.0/255.0/16.0);highp float sdf_gamma_b=max(fwidth(color2.a)*0.5,1.0/255.0/16.0);float sdf_alpha_a=smoothstep(sdf_edge-sdf_gamma_a,sdf_edge+sdf_gamma_a,color1.a);float sdf_alpha_b=smoothstep(sdf_edge-sdf_gamma_b,sdf_edge+sdf_gamma_b,color2.a);fragColor=mix(color*sdf_alpha_a,color*sdf_alpha_b,u_fade)*alpha*opacity;} else {fragColor=mix(color1,color2,u_fade)*alpha*opacity;}\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform vec3 u_scale;uniform vec2 u_fill_translate;layout(location=0) in vec2 a_pos;out vec2 v_pos_a;out vec2 v_pos_b;out vec2 v_pos;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define highp vec4 color\n#pragma maplibre: define lowp vec4 pattern_from\n#pragma maplibre: define lowp vec4 pattern_to\n#pragma maplibre: define lowp float pixel_ratio_from\n#pragma maplibre: define lowp float pixel_ratio_to\nvoid main() {\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize highp vec4 color\n#pragma maplibre: initialize mediump vec4 pattern_from\n#pragma maplibre: initialize mediump vec4 pattern_to\n#pragma maplibre: initialize lowp float pixel_ratio_from\n#pragma maplibre: initialize lowp float pixel_ratio_to\nif (opacity < 0.01) {gl_Position=vec4(-2.0,-2.0,-2.0,1.0);return;}vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;gl_Position=projectTile(a_pos+u_fill_translate,a_pos);vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileRatio,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileRatio,a_pos);v_pos=(gl_Position.xy/gl_Position.w+1.0)/2.0*u_world_size;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n}"),
+	fillPattern: prepare("#ifdef GL_ES\nprecision highp float;\n#endif\nuniform vec2 u_texsize;uniform float u_fade;uniform bool u_sdf_pattern;uniform sampler2D u_image;in vec2 v_pos_a;in vec2 v_pos_b;\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define highp vec4 color\n#pragma maplibre: define lowp vec4 pattern_from\n#pragma maplibre: define lowp vec4 pattern_to\nvoid main() {\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize highp vec4 color\n#pragma maplibre: initialize mediump vec4 pattern_from\n#pragma maplibre: initialize mediump vec4 pattern_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture(u_image,pos2);if (u_sdf_pattern) {highp float sdf_edge=(256.0-64.0)/256.0;highp float sdf_gamma_a=max(fwidth(color1.a)*0.5,1.0/255.0/16.0);highp float sdf_gamma_b=max(fwidth(color2.a)*0.5,1.0/255.0/16.0);float sdf_alpha_a=smoothstep(sdf_edge-sdf_gamma_a,sdf_edge+sdf_gamma_a,color1.a);float sdf_alpha_b=smoothstep(sdf_edge-sdf_gamma_b,sdf_edge+sdf_gamma_b,color2.a);fragColor=mix(color*sdf_alpha_a,color*sdf_alpha_b,u_fade)*opacity;} else {fragColor=mix(color1,color2,u_fade)*opacity;}\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform vec3 u_scale;uniform vec2 u_fill_translate;layout(location=0) in vec2 a_pos;out vec2 v_pos_a;out vec2 v_pos_b;\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define highp vec4 color\n#pragma maplibre: define lowp vec4 pattern_from\n#pragma maplibre: define lowp vec4 pattern_to\n#pragma maplibre: define lowp float pixel_ratio_from\n#pragma maplibre: define lowp float pixel_ratio_to\nvoid main() {\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize highp vec4 color\n#pragma maplibre: initialize mediump vec4 pattern_from\n#pragma maplibre: initialize mediump vec4 pattern_to\n#pragma maplibre: initialize lowp float pixel_ratio_from\n#pragma maplibre: initialize lowp float pixel_ratio_to\nif (opacity < 0.01) {gl_Position=vec4(-2.0,-2.0,-2.0,1.0);return;}vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileZoomRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;gl_Position=projectTile(a_pos+u_fill_translate,a_pos);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileZoomRatio,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileZoomRatio,a_pos);}"),
 	fillExtrusion: prepare("in vec4 v_color;void main() {fragColor=v_color;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec3 u_lightcolor;uniform lowp vec3 u_lightpos;uniform lowp vec3 u_lightpos_globe;uniform lowp float u_lightintensity;uniform float u_vertical_gradient;uniform lowp float u_opacity;uniform vec2 u_fill_translate;layout(location=0) in vec2 a_pos;layout(location=1) in ivec4 a_normal_ed;\n#ifdef TERRAIN3D\nlayout(location=2) in vec2 a_centroid;\n#endif\nout vec4 v_color;\n#pragma maplibre: define highp float base\n#pragma maplibre: define highp float height\n#pragma maplibre: define highp vec4 color\nvoid main() {\n#pragma maplibre: initialize highp float base\n#pragma maplibre: initialize highp float height\n#pragma maplibre: initialize highp vec4 color\nvec3 normal=vec3(a_normal_ed.xyz);\n#ifdef TERRAIN3D\nfloat height_terrain3d_offset=get_elevation(a_centroid);float base_terrain3d_offset=height_terrain3d_offset-(base > 0.0 ? 0.0 : 10.0);\n#else\nfloat height_terrain3d_offset=0.0;float base_terrain3d_offset=0.0;\n#endif\nbase=max(0.0,base)+base_terrain3d_offset;height=max(0.0,height)+height_terrain3d_offset;float t=float(a_normal_ed.x & 1);float elevation=t > 0.0 ? height : base;vec2 posInTile=a_pos+u_fill_translate;\n#ifdef GLOBE\nvec3 spherePos=projectToSphere(posInTile,a_pos);gl_Position=interpolateProjectionFor3D(posInTile,spherePos,elevation);\n#else\ngl_Position=u_projection_matrix*vec4(posInTile,elevation,1.0);\n#endif\nfloat colorvalue=color.r*0.2126+color.g*0.7152+color.b*0.0722;v_color=vec4(0.0,0.0,0.0,1.0);vec4 ambientlight=vec4(0.03,0.03,0.03,1.0);color+=ambientlight;vec3 normalForLighting=normal/16384.0;float directional=clamp(dot(normalForLighting,u_lightpos),0.0,1.0);\n#ifdef GLOBE\nmat3 rotMatrix=globeGetRotationMatrix(spherePos);normalForLighting=rotMatrix*normalForLighting;directional=mix(directional,clamp(dot(normalForLighting,u_lightpos_globe),0.0,1.0),u_projection_transition);\n#endif\ndirectional=mix((1.0-u_lightintensity),max((1.0-colorvalue+u_lightintensity),1.0),directional);if (normal.y !=0.0) {directional*=((1.0-u_vertical_gradient)+(u_vertical_gradient*clamp((t+base)*pow(height/150.0,0.5),mix(0.7,0.98,1.0-u_lightintensity),1.0)));}v_color.r+=clamp(color.r*directional*u_lightcolor.r,mix(0.0,0.3,1.0-u_lightcolor.r),1.0);v_color.g+=clamp(color.g*directional*u_lightcolor.g,mix(0.0,0.3,1.0-u_lightcolor.g),1.0);v_color.b+=clamp(color.b*directional*u_lightcolor.b,mix(0.0,0.3,1.0-u_lightcolor.b),1.0);v_color*=u_opacity;}"),
 	fillExtrusionPattern: prepare("uniform vec2 u_texsize;uniform float u_fade;uniform sampler2D u_image;in vec2 v_pos_a;in vec2 v_pos_b;in vec4 v_lighting;\n#pragma maplibre: define lowp float base\n#pragma maplibre: define lowp float height\n#pragma maplibre: define lowp vec4 pattern_from\n#pragma maplibre: define lowp vec4 pattern_to\n#pragma maplibre: define lowp float pixel_ratio_from\n#pragma maplibre: define lowp float pixel_ratio_to\nvoid main() {\n#pragma maplibre: initialize lowp float base\n#pragma maplibre: initialize lowp float height\n#pragma maplibre: initialize mediump vec4 pattern_from\n#pragma maplibre: initialize mediump vec4 pattern_to\n#pragma maplibre: initialize lowp float pixel_ratio_from\n#pragma maplibre: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture(u_image,pos2);vec4 mixedColor=mix(color1,color2,u_fade);fragColor=mixedColor*v_lighting;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform float u_height_factor;uniform vec3 u_scale;uniform float u_vertical_gradient;uniform lowp float u_opacity;uniform vec2 u_fill_translate;uniform vec3 u_lightcolor;uniform lowp vec3 u_lightpos;uniform lowp vec3 u_lightpos_globe;uniform lowp float u_lightintensity;layout(location=0) in vec2 a_pos;layout(location=1) in ivec4 a_normal_ed;\n#ifdef TERRAIN3D\nlayout(location=2) in vec2 a_centroid;\n#endif\n#ifdef GLOBE\nout vec3 v_sphere_pos;\n#endif\nout vec2 v_pos_a;out vec2 v_pos_b;out vec4 v_lighting;\n#pragma maplibre: define lowp float base\n#pragma maplibre: define lowp float height\n#pragma maplibre: define lowp vec4 pattern_from\n#pragma maplibre: define lowp vec4 pattern_to\n#pragma maplibre: define lowp float pixel_ratio_from\n#pragma maplibre: define lowp float pixel_ratio_to\nvoid main() {\n#pragma maplibre: initialize lowp float base\n#pragma maplibre: initialize lowp float height\n#pragma maplibre: initialize mediump vec4 pattern_from\n#pragma maplibre: initialize mediump vec4 pattern_to\n#pragma maplibre: initialize lowp float pixel_ratio_from\n#pragma maplibre: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec3 normal=vec3(a_normal_ed.xyz);float edgedistance=float(a_normal_ed.w);vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;\n#ifdef TERRAIN3D\nfloat height_terrain3d_offset=get_elevation(a_centroid);float base_terrain3d_offset=height_terrain3d_offset-(base > 0.0 ? 0.0 : 10.0);\n#else\nfloat height_terrain3d_offset=0.0;float base_terrain3d_offset=0.0;\n#endif\nbase=max(0.0,base)+base_terrain3d_offset;height=max(0.0,height)+height_terrain3d_offset;float t=float(a_normal_ed.x & 1);float elevation=t > 0.0 ? height : base;vec2 posInTile=a_pos+u_fill_translate;\n#ifdef GLOBE\nvec3 spherePos=projectToSphere(posInTile,a_pos);vec3 elevatedPos=spherePos*(1.0+elevation/GLOBE_RADIUS);v_sphere_pos=elevatedPos;gl_Position=interpolateProjectionFor3D(posInTile,spherePos,elevation);\n#else\ngl_Position=u_projection_matrix*vec4(posInTile,elevation,1.0);\n#endif\nvec2 pos=a_normal_ed.x==1 && a_normal_ed.y==0 && a_normal_ed.z==16384\n? a_pos\n: vec2(edgedistance,elevation*u_height_factor);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileRatio,pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileRatio,pos);v_lighting=vec4(0.0,0.0,0.0,1.0);float directional=clamp(dot(normal/16383.0,u_lightpos),0.0,1.0);directional=mix((1.0-u_lightintensity),max((0.5+u_lightintensity),1.0),directional);if (normal.y !=0.0) {directional*=((1.0-u_vertical_gradient)+(u_vertical_gradient*clamp((t+base)*pow(height/150.0,0.5),mix(0.7,0.98,1.0-u_lightintensity),1.0)));}v_lighting.rgb+=clamp(directional*u_lightcolor,mix(vec3(0.0),vec3(0.3),1.0-u_lightcolor),vec3(1.0));v_lighting*=u_opacity;}"),
-	hillshadePrepare: prepare("#ifdef GL_ES\nprecision highp float;\n#endif\nuniform sampler2D u_image;in vec2 v_pos;uniform vec2 u_dimension;uniform float u_zoom;uniform vec4 u_unpack;float getElevation(ivec2 texel) {vec4 data=texelFetch(u_image,texel,0)*255.0;data.a=-1.0;return dot(data,u_unpack);}void main() {ivec2 pos=ivec2(gl_FragCoord.xy)+ivec2(1);float tileSize=u_dimension.x-2.0;float a=getElevation(pos+ivec2(-1,-1));float b=getElevation(pos+ivec2(0,-1));float c=getElevation(pos+ivec2(1,-1));float d=getElevation(pos+ivec2(-1,0));float e=getElevation(pos);float f=getElevation(pos+ivec2(1,0));float g=getElevation(pos+ivec2(-1,1));float h=getElevation(pos+ivec2(0,1));float i=getElevation(pos+ivec2(1,1));float exaggerationFactor=u_zoom < 2.0 ? 0.4 : u_zoom < 4.5 ? 0.35 : 0.3;float exaggeration=u_zoom < 15.0 ? (u_zoom-15.0)*exaggerationFactor : 0.0;vec2 deriv=vec2((c+f+f+i)-(a+d+d+g),(g+h+h+i)-(a+b+b+c))*tileSize/pow(2.0,exaggeration+(28.2562-u_zoom));fragColor=clamp(vec4(deriv.x/8.0+0.5,deriv.y/8.0+0.5,1.0,1.0),0.0,1.0);\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform mat4 u_matrix;uniform vec2 u_dimension;layout(location=0) in vec2 a_pos;layout(location=1) in vec2 a_texture_pos;out vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);highp vec2 epsilon=1.0/u_dimension;float scale=(u_dimension.x-2.0)/u_dimension.x;v_pos=(a_texture_pos/8192.0)*scale+epsilon;}"),
-	hillshade: prepare("uniform sampler2D u_image;in vec2 v_pos;uniform vec2 u_latrange;uniform float u_exaggeration;uniform vec4 u_accent;uniform int u_method;uniform float u_altitudes[NUM_ILLUMINATION_SOURCES];uniform float u_azimuths[NUM_ILLUMINATION_SOURCES];uniform vec4 u_shadows[NUM_ILLUMINATION_SOURCES];uniform vec4 u_highlights[NUM_ILLUMINATION_SOURCES];\n#define PI 3.141592653589793\n#define STANDARD 0\n#define COMBINED 1\n#define IGOR 2\n#define MULTIDIRECTIONAL 3\n#define BASIC 4\nfloat get_aspect(vec2 deriv){return deriv.x !=0.0 ? atan(deriv.y,-deriv.x) : PI/2.0*(deriv.y > 0.0 ? 1.0 :-1.0);}void igor_hillshade(vec2 deriv){deriv=deriv*u_exaggeration*2.0;float aspect=get_aspect(deriv);float azimuth=u_azimuths[0]+PI;float slope_stength=atan(length(deriv))*2.0/PI;float aspect_strength=1.0-abs(mod((aspect+azimuth)/PI+0.5,2.0)-1.0);float shadow_strength=slope_stength*aspect_strength;float highlight_strength=slope_stength*(1.0-aspect_strength);fragColor=u_shadows[0]*shadow_strength+u_highlights[0]*highlight_strength;}void standard_hillshade(vec2 deriv){float azimuth=u_azimuths[0]+PI;float slope=atan(0.625*length(deriv));float aspect=get_aspect(deriv);float intensity=u_exaggeration;float base=1.875-intensity*1.75;float maxValue=0.5*PI;float scaledSlope=intensity !=0.5 ? ((pow(base,slope)-1.0)/(pow(base,maxValue)-1.0))*maxValue : slope;float accent=cos(scaledSlope);vec4 accent_color=(1.0-accent)*u_accent*clamp(intensity*2.0,0.0,1.0);float shade=abs(mod((aspect+azimuth)/PI+0.5,2.0)-1.0);vec4 shade_color=mix(u_shadows[0],u_highlights[0],shade)*sin(scaledSlope)*clamp(intensity*2.0,0.0,1.0);fragColor=accent_color*(1.0-shade_color.a)+shade_color;}void basic_hillshade(vec2 deriv){deriv=deriv*u_exaggeration*2.0;float azimuth=u_azimuths[0]+PI;float cos_az=cos(azimuth);float sin_az=sin(azimuth);float cos_alt=cos(u_altitudes[0]);float sin_alt=sin(u_altitudes[0]);float cang=(sin_alt-(deriv.y*cos_az*cos_alt-deriv.x*sin_az*cos_alt))/sqrt(1.0+dot(deriv,deriv));float shade=clamp(cang,0.0,1.0);if(shade > 0.5){fragColor=u_highlights[0]*(2.0*shade-1.0);}else\n{fragColor=u_shadows[0]*(1.0-2.0*shade);}}void multidirectional_hillshade(vec2 deriv){deriv=deriv*u_exaggeration*2.0;fragColor=vec4(0,0,0,0);for(int i=0; i < NUM_ILLUMINATION_SOURCES; i++){float cos_alt=cos(u_altitudes[i]);float sin_alt=sin(u_altitudes[i]);float cos_az=-cos(u_azimuths[i]);float sin_az=-sin(u_azimuths[i]);float cang=(sin_alt-(deriv.y*cos_az*cos_alt-deriv.x*sin_az*cos_alt))/sqrt(1.0+dot(deriv,deriv));float shade=clamp(cang,0.0,1.0);if(shade > 0.5){fragColor+=u_highlights[i]*(2.0*shade-1.0)/float(NUM_ILLUMINATION_SOURCES);}else\n{fragColor+=u_shadows[i]*(1.0-2.0*shade)/float(NUM_ILLUMINATION_SOURCES);}}}void combined_hillshade(vec2 deriv){deriv=deriv*u_exaggeration*2.0;float azimuth=u_azimuths[0]+PI;float cos_az=cos(azimuth);float sin_az=sin(azimuth);float cos_alt=cos(u_altitudes[0]);float sin_alt=sin(u_altitudes[0]);float cang=acos((sin_alt-(deriv.y*cos_az*cos_alt-deriv.x*sin_az*cos_alt))/sqrt(1.0+dot(deriv,deriv)));cang=clamp(cang,0.0,PI/2.0);float shade=cang*atan(length(deriv))*4.0/PI/PI;float highlight=(PI/2.0-cang)*atan(length(deriv))*4.0/PI/PI;fragColor=u_shadows[0]*shade+u_highlights[0]*highlight;}void main() {vec4 pixel=texture(u_image,v_pos);float scaleFactor=cos(radians((u_latrange[0]-u_latrange[1])*(1.0-v_pos.y)+u_latrange[1]));vec2 deriv=((pixel.rg*8.0)-4.0)/scaleFactor;if (u_method==BASIC) {basic_hillshade(deriv);} else if (u_method==COMBINED) {combined_hillshade(deriv);} else if (u_method==IGOR) {igor_hillshade(deriv);} else if (u_method==MULTIDIRECTIONAL) {multidirectional_hillshade(deriv);} else if (u_method==STANDARD) {standard_hillshade(deriv);} else {standard_hillshade(deriv);}\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform mat4 u_matrix;layout(location=0) in vec2 a_pos;out vec2 v_pos;void main() {gl_Position=projectTile(a_pos,a_pos);v_pos=a_pos/8192.0;if (a_pos.y <-32767.5) {v_pos.y=0.0;}if (a_pos.y > 32766.5) {v_pos.y=1.0;}}"),
-	line: prepare("uniform lowp float u_device_pixel_ratio;flat in vec2 v_width2;in vec2 v_normal;in float v_gamma_scale;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define highp vec4 color\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\nvoid main() {\n#pragma maplibre: initialize highp vec4 color\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\nclipAntimeridian();float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);fragColor=color*(alpha*opacity);\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "\n#define scale 0.015873016\nlayout(location=0) in ivec2 a_pos_normal;layout(location=1) in uvec4 a_data;uniform vec2 u_translation;uniform mediump float u_ratio;uniform vec2 u_units_to_pixels;uniform lowp float u_device_pixel_ratio;out vec2 v_normal;flat out vec2 v_width2;out float v_gamma_scale;out highp float v_linesofar;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma maplibre: define highp vec4 color\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define mediump float gapwidth\n#pragma maplibre: define lowp float offset\n#pragma maplibre: define mediump float width\nvoid main() {\n#pragma maplibre: initialize highp vec4 color\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize mediump float gapwidth\n#pragma maplibre: initialize lowp float offset\n#pragma maplibre: initialize mediump float width\nif (opacity < 0.01) {gl_Position=vec4(-2.0,-2.0,-2.0,1.0);return;}float ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=vec2(ivec2(a_data.xy)-128);float a_direction=float(int(a_data.z & 3u)-1);v_linesofar=float((a_data.z >> 2u)+a_data.w*64u)*2.0;vec2 pos=vec2(a_pos_normal >> 1);mediump vec2 normal=vec2(a_pos_normal & 1);normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);float adjustedThickness=projectLineThickness(pos.y);vec4 projected_no_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation);vec4 projected_with_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation+dist/u_ratio*adjustedThickness);gl_Position=projected_with_extrude;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length((projected_with_extrude.xy-projected_no_extrude.xy)/projected_with_extrude.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nv_width2=vec2(outset,inset);}"),
-	lineGradient: prepare("uniform lowp float u_device_pixel_ratio;uniform sampler2D u_image;flat in vec2 v_width2;in vec2 v_normal;in float v_gamma_scale;in highp vec2 v_uv;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\nvoid main() {\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\nclipAntimeridian();float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);vec4 color=texture(u_image,v_uv);fragColor=color*(alpha*opacity);\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "\n#define scale 0.015873016\nlayout(location=0) in ivec2 a_pos_normal;layout(location=1) in uvec4 a_data;layout(location=2) in float a_uv_x;layout(location=3) in float a_split_index;uniform vec2 u_translation;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;uniform vec2 u_units_to_pixels;uniform float u_image_height;out vec2 v_normal;flat out vec2 v_width2;out float v_gamma_scale;out highp vec2 v_uv;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define mediump float gapwidth\n#pragma maplibre: define lowp float offset\n#pragma maplibre: define mediump float width\nvoid main() {\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize mediump float gapwidth\n#pragma maplibre: initialize lowp float offset\n#pragma maplibre: initialize mediump float width\nif (opacity < 0.01) {gl_Position=vec4(-2.0,-2.0,-2.0,1.0);return;}float ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=vec2(ivec2(a_data.xy)-128);float a_direction=float(int(a_data.z & 3u)-1);highp float texel_height=1.0/u_image_height;highp float half_texel_height=0.5*texel_height;v_uv=vec2(a_uv_x,a_split_index*texel_height-half_texel_height);vec2 pos=vec2(a_pos_normal >> 1);mediump vec2 normal=vec2(a_pos_normal & 1);normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);float adjustedThickness=projectLineThickness(pos.y);vec4 projected_no_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation);vec4 projected_with_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation+dist/u_ratio*adjustedThickness);gl_Position=projected_with_extrude;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length((projected_with_extrude.xy-projected_no_extrude.xy)/projected_with_extrude.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nv_width2=vec2(outset,inset);}"),
-	linePattern: prepare("#ifdef GL_ES\nprecision highp float;\n#endif\nuniform lowp float u_device_pixel_ratio;uniform vec2 u_texsize;uniform float u_fade;uniform mediump vec3 u_scale;uniform sampler2D u_image;in vec2 v_normal;flat in vec2 v_width2;in float v_linesofar;in float v_gamma_scale;flat in float v_width;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define lowp vec4 pattern_from\n#pragma maplibre: define lowp vec4 pattern_to\n#pragma maplibre: define lowp float pixel_ratio_from\n#pragma maplibre: define lowp float pixel_ratio_to\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\nvoid main() {\n#pragma maplibre: initialize mediump vec4 pattern_from\n#pragma maplibre: initialize mediump vec4 pattern_to\n#pragma maplibre: initialize lowp float pixel_ratio_from\n#pragma maplibre: initialize lowp float pixel_ratio_to\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\nclipAntimeridian();vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileZoomRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;vec2 pattern_size_a=vec2(display_size_a.x*fromScale/tileZoomRatio,display_size_a.y);vec2 pattern_size_b=vec2(display_size_b.x*toScale/tileZoomRatio,display_size_b.y);float aspect_a=display_size_a.y/v_width;float aspect_b=display_size_b.y/v_width;float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);float x_a=mod(v_linesofar/pattern_size_a.x*aspect_a,1.0);float x_b=mod(v_linesofar/pattern_size_b.x*aspect_b,1.0);float y=0.5*v_normal.y+0.5;vec2 texel_size=1.0/u_texsize;vec2 pos_a=mix(pattern_tl_a*texel_size-texel_size,pattern_br_a*texel_size+texel_size,vec2(x_a,y));vec2 pos_b=mix(pattern_tl_b*texel_size-texel_size,pattern_br_b*texel_size+texel_size,vec2(x_b,y));vec4 color=mix(texture(u_image,pos_a),texture(u_image,pos_b),u_fade);fragColor=color*alpha*opacity;\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "\n#define scale 0.015873016\n#define LINE_DISTANCE_SCALE 2.0\nlayout(location=0) in ivec2 a_pos_normal;layout(location=1) in uvec4 a_data;uniform vec2 u_translation;uniform vec2 u_units_to_pixels;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;out vec2 v_normal;flat out vec2 v_width2;out float v_linesofar;out float v_gamma_scale;flat out float v_width;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define lowp float offset\n#pragma maplibre: define mediump float gapwidth\n#pragma maplibre: define mediump float width\n#pragma maplibre: define lowp float floorwidth\n#pragma maplibre: define lowp vec4 pattern_from\n#pragma maplibre: define lowp vec4 pattern_to\n#pragma maplibre: define lowp float pixel_ratio_from\n#pragma maplibre: define lowp float pixel_ratio_to\nvoid main() {\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize lowp float offset\n#pragma maplibre: initialize mediump float gapwidth\n#pragma maplibre: initialize mediump float width\n#pragma maplibre: initialize lowp float floorwidth\n#pragma maplibre: initialize mediump vec4 pattern_from\n#pragma maplibre: initialize mediump vec4 pattern_to\n#pragma maplibre: initialize lowp float pixel_ratio_from\n#pragma maplibre: initialize lowp float pixel_ratio_to\nif (opacity < 0.01) {gl_Position=vec4(-2.0,-2.0,-2.0,1.0);return;}float ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=vec2(ivec2(a_data.xy)-128);float a_direction=float(int(a_data.z & 3u)-1);float a_linesofar=float((a_data.z >> 2u)+a_data.w*64u)*LINE_DISTANCE_SCALE;vec2 pos=vec2(a_pos_normal >> 1);mediump vec2 normal=vec2(a_pos_normal & 1);normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);float adjustedThickness=projectLineThickness(pos.y);vec4 projected_no_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation);vec4 projected_with_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation+dist/u_ratio*adjustedThickness);gl_Position=projected_with_extrude;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length((projected_with_extrude.xy-projected_no_extrude.xy)/projected_with_extrude.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nv_linesofar=a_linesofar;v_width2=vec2(outset,inset);v_width=floorwidth;}"),
-	lineSDF: prepare("uniform lowp float u_device_pixel_ratio;uniform lowp float u_lineatlas_width;uniform sampler2D u_image;uniform float u_mix;in vec2 v_normal;flat in vec2 v_width2;in vec2 v_tex_a;in vec2 v_tex_b;in float v_gamma_scale;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define highp vec4 color\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define mediump float width\n#pragma maplibre: define lowp float floorwidth\n#pragma maplibre: define mediump vec4 dasharray_from\n#pragma maplibre: define mediump vec4 dasharray_to\nvoid main() {\n#pragma maplibre: initialize highp vec4 color\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize mediump float width\n#pragma maplibre: initialize lowp float floorwidth\n#pragma maplibre: initialize mediump vec4 dasharray_from\n#pragma maplibre: initialize mediump vec4 dasharray_to\nclipAntimeridian();float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);float sdfdist_a=texture(u_image,v_tex_a).a;float sdfdist_b=texture(u_image,v_tex_b).a;float sdfdist=mix(sdfdist_a,sdfdist_b,u_mix);float sdfgamma=(u_lineatlas_width/256.0/u_device_pixel_ratio)/min(dasharray_from.w,dasharray_to.w);alpha*=smoothstep(0.5-sdfgamma/floorwidth,0.5+sdfgamma/floorwidth,sdfdist);fragColor=color*(alpha*opacity);\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "\n#define scale 0.015873016\n#define LINE_DISTANCE_SCALE 2.0\nlayout(location=0) in ivec2 a_pos_normal;layout(location=1) in uvec4 a_data;uniform vec2 u_translation;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;uniform vec2 u_units_to_pixels;uniform float u_tileratio;uniform float u_crossfade_from;uniform float u_crossfade_to;uniform float u_lineatlas_height;out vec2 v_normal;flat out vec2 v_width2;out vec2 v_tex_a;out vec2 v_tex_b;out float v_gamma_scale;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma maplibre: define highp vec4 color\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define mediump float gapwidth\n#pragma maplibre: define lowp float offset\n#pragma maplibre: define mediump float width\n#pragma maplibre: define lowp float floorwidth\n#pragma maplibre: define mediump vec4 dasharray_from\n#pragma maplibre: define mediump vec4 dasharray_to\nvoid main() {\n#pragma maplibre: initialize highp vec4 color\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize mediump float gapwidth\n#pragma maplibre: initialize lowp float offset\n#pragma maplibre: initialize mediump float width\n#pragma maplibre: initialize lowp float floorwidth\n#pragma maplibre: initialize mediump vec4 dasharray_from\n#pragma maplibre: initialize mediump vec4 dasharray_to\nif (opacity < 0.01) {gl_Position=vec4(-2.0,-2.0,-2.0,1.0);return;}float ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=vec2(ivec2(a_data.xy)-128);float a_direction=float(int(a_data.z & 3u)-1);float a_linesofar=float((a_data.z >> 2u)+a_data.w*64u)*LINE_DISTANCE_SCALE;vec2 pos=vec2(a_pos_normal >> 1);mediump vec2 normal=vec2(a_pos_normal & 1);normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);float adjustedThickness=projectLineThickness(pos.y);vec4 projected_no_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation);vec4 projected_with_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation+dist/u_ratio*adjustedThickness);gl_Position=projected_with_extrude;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length((projected_with_extrude.xy-projected_no_extrude.xy)/projected_with_extrude.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nfloat u_patternscale_a_x=u_tileratio/dasharray_from.w/u_crossfade_from;float u_patternscale_a_y=-dasharray_from.z/2.0/u_lineatlas_height;float u_patternscale_b_x=u_tileratio/dasharray_to.w/u_crossfade_to;float u_patternscale_b_y=-dasharray_to.z/2.0/u_lineatlas_height;v_tex_a=vec2(a_linesofar*u_patternscale_a_x/floorwidth,normal.y*u_patternscale_a_y+(float(dasharray_from.y)+0.5)/u_lineatlas_height);v_tex_b=vec2(a_linesofar*u_patternscale_b_x/floorwidth,normal.y*u_patternscale_b_y+(float(dasharray_to.y)+0.5)/u_lineatlas_height);v_width2=vec2(outset,inset);}"),
-	lineGradientSDF: prepare("uniform lowp float u_device_pixel_ratio;uniform sampler2D u_image;uniform sampler2D u_image_dash;uniform float u_mix;uniform lowp float u_lineatlas_width;in vec2 v_normal;flat in vec2 v_width2;in vec2 v_tex_a;in vec2 v_tex_b;in float v_gamma_scale;in highp vec2 v_uv;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define mediump float width\n#pragma maplibre: define lowp float floorwidth\n#pragma maplibre: define mediump vec4 dasharray_from\n#pragma maplibre: define mediump vec4 dasharray_to\nvoid main() {\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize mediump float width\n#pragma maplibre: initialize lowp float floorwidth\n#pragma maplibre: initialize mediump vec4 dasharray_from\n#pragma maplibre: initialize mediump vec4 dasharray_to\nclipAntimeridian();float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);vec4 color=texture(u_image,v_uv);float sdfdist_a=texture(u_image_dash,v_tex_a).a;float sdfdist_b=texture(u_image_dash,v_tex_b).a;float sdfdist=mix(sdfdist_a,sdfdist_b,u_mix);float sdfgamma=(u_lineatlas_width/256.0)/min(dasharray_from.w,dasharray_to.w);float dash_alpha=smoothstep(0.5-sdfgamma/floorwidth,0.5+sdfgamma/floorwidth,sdfdist);fragColor=color*(alpha*dash_alpha*opacity);\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "\n#define scale 0.015873016\n#define LINE_DISTANCE_SCALE 2.0\nlayout(location=0) in ivec2 a_pos_normal;layout(location=1) in uvec4 a_data;layout(location=2) in float a_uv_x;layout(location=3) in float a_split_index;uniform vec2 u_translation;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;uniform vec2 u_units_to_pixels;uniform float u_image_height;uniform float u_tileratio;uniform float u_crossfade_from;uniform float u_crossfade_to;uniform float u_lineatlas_height;out vec2 v_normal;flat out vec2 v_width2;out float v_gamma_scale;out highp vec2 v_uv;out vec2 v_tex_a;out vec2 v_tex_b;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define mediump float gapwidth\n#pragma maplibre: define lowp float offset\n#pragma maplibre: define mediump float width\n#pragma maplibre: define lowp float floorwidth\n#pragma maplibre: define mediump vec4 dasharray_from\n#pragma maplibre: define mediump vec4 dasharray_to\nvoid main() {\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize mediump float gapwidth\n#pragma maplibre: initialize lowp float offset\n#pragma maplibre: initialize mediump float width\n#pragma maplibre: initialize lowp float floorwidth\n#pragma maplibre: initialize mediump vec4 dasharray_from\n#pragma maplibre: initialize mediump vec4 dasharray_to\nif (opacity < 0.01) {gl_Position=vec4(-2.0,-2.0,-2.0,1.0);return;}float ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=vec2(ivec2(a_data.xy)-128);float a_direction=float(int(a_data.z & 3u)-1);float a_linesofar=float((a_data.z >> 2u)+a_data.w*64u)*LINE_DISTANCE_SCALE;float texel_height=1.0/u_image_height;float half_texel_height=0.5*texel_height;v_uv=vec2(a_uv_x,a_split_index*texel_height-half_texel_height);vec2 pos=vec2(a_pos_normal >> 1);mediump vec2 normal=vec2(a_pos_normal & 1);normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);float adjustedThickness=projectLineThickness(pos.y);vec4 projected_no_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation);vec4 projected_with_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation+dist/u_ratio*adjustedThickness);gl_Position=projected_with_extrude;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length((projected_with_extrude.xy-projected_no_extrude.xy)/projected_with_extrude.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nfloat u_patternscale_a_x=u_tileratio/dasharray_from.w/u_crossfade_from;float u_patternscale_a_y=-dasharray_from.z/2.0/u_lineatlas_height;float u_patternscale_b_x=u_tileratio/dasharray_to.w/u_crossfade_to;float u_patternscale_b_y=-dasharray_to.z/2.0/u_lineatlas_height;v_tex_a=vec2(a_linesofar*u_patternscale_a_x/floorwidth,normal.y*u_patternscale_a_y+(float(dasharray_from.y)+0.5)/u_lineatlas_height);v_tex_b=vec2(a_linesofar*u_patternscale_b_x/floorwidth,normal.y*u_patternscale_b_y+(float(dasharray_to.y)+0.5)/u_lineatlas_height);v_width2=vec2(outset,inset);}"),
+	hillshadePrepare: prepare("#ifdef GL_ES\nprecision highp float;\n#endif\nuniform sampler2D u_image;in vec2 v_pos;uniform vec2 u_dimension;uniform float u_zoom;uniform vec4 u_unpack;float getElevation(ivec2 texel) {vec4 data=texelFetch(u_image,texel,0)*255.0;data.a=-1.0;return dot(data,u_unpack);}void main() {ivec2 pos=ivec2(gl_FragCoord.xy)+ivec2(1);float tileSize=u_dimension.x-4.0;float a=getElevation(pos+ivec2(-1,-1));float b=getElevation(pos+ivec2(0,-1));float c=getElevation(pos+ivec2(1,-1));float d=getElevation(pos+ivec2(-1,0));float e=getElevation(pos);float f=getElevation(pos+ivec2(1,0));float g=getElevation(pos+ivec2(-1,1));float h=getElevation(pos+ivec2(0,1));float i=getElevation(pos+ivec2(1,1));float exaggerationFactor=u_zoom < 2.0 ? 0.4 : u_zoom < 4.5 ? 0.35 : 0.3;float exaggeration=u_zoom < 15.0 ? (u_zoom-15.0)*exaggerationFactor : 0.0;vec2 deriv=vec2((c+f+f+i)-(a+d+d+g),(g+h+h+i)-(a+b+b+c))*tileSize/pow(2.0,exaggeration+(28.2562-u_zoom));fragColor=clamp(vec4(deriv.x/8.0+0.5,deriv.y/8.0+0.5,1.0,1.0),0.0,1.0);\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform mat4 u_matrix;uniform vec2 u_dimension;layout(location=0) in vec2 a_pos;layout(location=1) in vec2 a_texture_pos;out vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);highp vec2 epsilon=1.0/u_dimension;float scale=(u_dimension.x-2.0)/u_dimension.x;v_pos=(a_texture_pos/8192.0)*scale+epsilon;}"),
+	hillshade: prepare("uniform sampler2D u_image;in vec2 v_pos;uniform vec2 u_latrange;uniform float u_exaggeration;uniform vec4 u_accent;uniform int u_method;uniform float u_altitudes[NUM_ILLUMINATION_SOURCES];uniform float u_azimuths[NUM_ILLUMINATION_SOURCES];uniform vec4 u_shadows[NUM_ILLUMINATION_SOURCES];uniform vec4 u_highlights[NUM_ILLUMINATION_SOURCES];\n#define PI 3.141592653589793\n#define STANDARD 0\n#define COMBINED 1\n#define IGOR 2\n#define MULTIDIRECTIONAL 3\n#define BASIC 4\nfloat get_aspect(vec2 deriv){return deriv.x !=0.0 ? atan(deriv.y,-deriv.x) : PI/2.0*(deriv.y > 0.0 ? 1.0 :-1.0);}void igor_hillshade(vec2 deriv){deriv=deriv*u_exaggeration*2.0;float aspect=get_aspect(deriv);float azimuth=u_azimuths[0]+PI;float slope_stength=atan(length(deriv))*2.0/PI;float aspect_strength=1.0-abs(mod((aspect+azimuth)/PI+0.5,2.0)-1.0);float shadow_strength=slope_stength*aspect_strength;float highlight_strength=slope_stength*(1.0-aspect_strength);fragColor=u_shadows[0]*shadow_strength+u_highlights[0]*highlight_strength;}void standard_hillshade(vec2 deriv){float azimuth=u_azimuths[0]+PI;float slope=atan(0.625*length(deriv));float aspect=get_aspect(deriv);float intensity=u_exaggeration;float base=1.875-intensity*1.75;float maxValue=0.5*PI;float scaledSlope=intensity !=0.5 ? ((pow(base,slope)-1.0)/(pow(base,maxValue)-1.0))*maxValue : slope;float accent=cos(scaledSlope);vec4 accent_color=(1.0-accent)*u_accent*clamp(intensity*2.0,0.0,1.0);float shade=abs(mod((aspect+azimuth)/PI+0.5,2.0)-1.0);vec4 shade_color=mix(u_shadows[0],u_highlights[0],shade)*sin(scaledSlope)*clamp(intensity*2.0,0.0,1.0);fragColor=accent_color*(1.0-shade_color.a)+shade_color;}void basic_hillshade(vec2 deriv){deriv=deriv*u_exaggeration*2.0;float azimuth=u_azimuths[0]+PI;float cos_az=cos(azimuth);float sin_az=sin(azimuth);float cos_alt=cos(u_altitudes[0]);float sin_alt=sin(u_altitudes[0]);float cang=(sin_alt-(deriv.y*cos_az*cos_alt-deriv.x*sin_az*cos_alt))/sqrt(1.0+dot(deriv,deriv));float shade=clamp(cang,0.0,1.0);if(shade > 0.5){fragColor=u_highlights[0]*(2.0*shade-1.0);}else\n{fragColor=u_shadows[0]*(1.0-2.0*shade);}}void multidirectional_hillshade(vec2 deriv){deriv=deriv*u_exaggeration*2.0;fragColor=vec4(0,0,0,0);for(int i=0; i < NUM_ILLUMINATION_SOURCES; i++){float cos_alt=cos(u_altitudes[i]);float sin_alt=sin(u_altitudes[i]);float cos_az=-cos(u_azimuths[i]);float sin_az=-sin(u_azimuths[i]);float cang=(sin_alt-(deriv.y*cos_az*cos_alt-deriv.x*sin_az*cos_alt))/sqrt(1.0+dot(deriv,deriv));float shade=clamp(cang,0.0,1.0);if(shade > 0.5){fragColor+=u_highlights[i]*(2.0*shade-1.0)/float(NUM_ILLUMINATION_SOURCES);}else\n{fragColor+=u_shadows[i]*(1.0-2.0*shade)/float(NUM_ILLUMINATION_SOURCES);}}}void combined_hillshade(vec2 deriv){deriv=deriv*u_exaggeration*2.0;float azimuth=u_azimuths[0]+PI;float cos_az=cos(azimuth);float sin_az=sin(azimuth);float cos_alt=cos(u_altitudes[0]);float sin_alt=sin(u_altitudes[0]);float cang=acos((sin_alt-(deriv.y*cos_az*cos_alt-deriv.x*sin_az*cos_alt))/sqrt(1.0+dot(deriv,deriv)));cang=clamp(cang,0.0,PI/2.0);float shade=cang*atan(length(deriv))*4.0/PI/PI;float highlight=(PI/2.0-cang)*atan(length(deriv))*4.0/PI/PI;fragColor=u_shadows[0]*shade+u_highlights[0]*highlight;}void main() {vec2 size=vec2(textureSize(u_image,0));vec2 texturePos=(v_pos*(size-2.0)+1.0)/size;vec4 pixel=texture(u_image,texturePos);float scaleFactor=cos(radians((u_latrange[0]-u_latrange[1])*(1.0-v_pos.y)+u_latrange[1]));vec2 deriv=((pixel.rg*8.0)-4.0)/scaleFactor;if (u_method==BASIC) {basic_hillshade(deriv);} else if (u_method==COMBINED) {combined_hillshade(deriv);} else if (u_method==IGOR) {igor_hillshade(deriv);} else if (u_method==MULTIDIRECTIONAL) {multidirectional_hillshade(deriv);} else if (u_method==STANDARD) {standard_hillshade(deriv);} else {standard_hillshade(deriv);}\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform mat4 u_matrix;layout(location=0) in vec2 a_pos;out vec2 v_pos;void main() {gl_Position=projectTile(a_pos,a_pos);v_pos=a_pos/8192.0;if (a_pos.y <-32767.5) {v_pos.y=0.0;}if (a_pos.y > 32766.5) {v_pos.y=1.0;}}"),
+	line: prepare("flat in vec2 v_width2;in vec2 v_normal;in float v_gamma_scale;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define highp vec4 color\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\nvoid main() {\n#pragma maplibre: initialize highp vec4 color\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\nclipAntimeridian();float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);fragColor=color*(alpha*opacity);\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "\n#define scale 0.015873016\nlayout(location=0) in ivec2 a_pos_normal;layout(location=1) in uvec4 a_data;uniform vec2 u_translation;uniform mediump float u_ratio;out vec2 v_normal;flat out vec2 v_width2;out float v_gamma_scale;out highp float v_linesofar;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma maplibre: define highp vec4 color\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define mediump float gapwidth\n#pragma maplibre: define lowp float offset\n#pragma maplibre: define mediump float width\nvoid main() {\n#pragma maplibre: initialize highp vec4 color\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize mediump float gapwidth\n#pragma maplibre: initialize lowp float offset\n#pragma maplibre: initialize mediump float width\nif (opacity < 0.01) {gl_Position=vec4(-2.0,-2.0,-2.0,1.0);return;}float ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=vec2(ivec2(a_data.xy)-128);float a_direction=float(int(a_data.z & 3u)-1);v_linesofar=float((a_data.z >> 2u)+a_data.w*64u)*2.0;vec2 pos=vec2(a_pos_normal >> 1);mediump vec2 normal=vec2(a_pos_normal & 1);normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);float adjustedThickness=projectLineThickness(pos.y);vec4 projected_no_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation);vec4 projected_with_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation+dist/u_ratio*adjustedThickness);gl_Position=projected_with_extrude;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length((projected_with_extrude.xy-projected_no_extrude.xy)/projected_with_extrude.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nv_width2=vec2(outset,inset);}"),
+	lineGradient: prepare("uniform sampler2D u_image;flat in vec2 v_width2;in vec2 v_normal;in float v_gamma_scale;in highp vec2 v_uv;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\nvoid main() {\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\nclipAntimeridian();float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);vec4 color=texture(u_image,v_uv);fragColor=color*(alpha*opacity);\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "\n#define scale 0.015873016\nlayout(location=0) in ivec2 a_pos_normal;layout(location=1) in uvec4 a_data;layout(location=2) in float a_uv_x;layout(location=3) in float a_split_index;uniform vec2 u_translation;uniform mediump float u_ratio;uniform float u_image_height;out vec2 v_normal;flat out vec2 v_width2;out float v_gamma_scale;out highp vec2 v_uv;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define mediump float gapwidth\n#pragma maplibre: define lowp float offset\n#pragma maplibre: define mediump float width\nvoid main() {\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize mediump float gapwidth\n#pragma maplibre: initialize lowp float offset\n#pragma maplibre: initialize mediump float width\nif (opacity < 0.01) {gl_Position=vec4(-2.0,-2.0,-2.0,1.0);return;}float ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=vec2(ivec2(a_data.xy)-128);float a_direction=float(int(a_data.z & 3u)-1);highp float texel_height=1.0/u_image_height;highp float half_texel_height=0.5*texel_height;v_uv=vec2(a_uv_x,a_split_index*texel_height-half_texel_height);vec2 pos=vec2(a_pos_normal >> 1);mediump vec2 normal=vec2(a_pos_normal & 1);normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);float adjustedThickness=projectLineThickness(pos.y);vec4 projected_no_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation);vec4 projected_with_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation+dist/u_ratio*adjustedThickness);gl_Position=projected_with_extrude;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length((projected_with_extrude.xy-projected_no_extrude.xy)/projected_with_extrude.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nv_width2=vec2(outset,inset);}"),
+	linePattern: prepare("#ifdef GL_ES\nprecision highp float;\n#endif\nuniform vec2 u_texsize;uniform float u_fade;uniform mediump vec3 u_scale;uniform sampler2D u_image;in vec2 v_normal;flat in vec2 v_width2;in float v_linesofar;in float v_gamma_scale;flat in float v_width;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define lowp vec4 pattern_from\n#pragma maplibre: define lowp vec4 pattern_to\n#pragma maplibre: define lowp float pixel_ratio_from\n#pragma maplibre: define lowp float pixel_ratio_to\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\nvoid main() {\n#pragma maplibre: initialize mediump vec4 pattern_from\n#pragma maplibre: initialize mediump vec4 pattern_to\n#pragma maplibre: initialize lowp float pixel_ratio_from\n#pragma maplibre: initialize lowp float pixel_ratio_to\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\nclipAntimeridian();vec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileZoomRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;vec2 pattern_size_a=vec2(display_size_a.x*fromScale/tileZoomRatio,display_size_a.y);vec2 pattern_size_b=vec2(display_size_b.x*toScale/tileZoomRatio,display_size_b.y);float aspect_a=display_size_a.y/v_width;float aspect_b=display_size_b.y/v_width;float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);float x_a=mod(v_linesofar/pattern_size_a.x*aspect_a,1.0);float x_b=mod(v_linesofar/pattern_size_b.x*aspect_b,1.0);float y=0.5*v_normal.y+0.5;vec2 texel_size=1.0/u_texsize;vec2 pos_a=mix(pattern_tl_a*texel_size-texel_size,pattern_br_a*texel_size+texel_size,vec2(x_a,y));vec2 pos_b=mix(pattern_tl_b*texel_size-texel_size,pattern_br_b*texel_size+texel_size,vec2(x_b,y));vec4 color=mix(texture(u_image,pos_a),texture(u_image,pos_b),u_fade);fragColor=color*alpha*opacity;\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "\n#define scale 0.015873016\n#define LINE_DISTANCE_SCALE 2.0\nlayout(location=0) in ivec2 a_pos_normal;layout(location=1) in uvec4 a_data;uniform vec2 u_translation;uniform mediump float u_ratio;out vec2 v_normal;flat out vec2 v_width2;out float v_linesofar;out float v_gamma_scale;flat out float v_width;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define lowp float offset\n#pragma maplibre: define mediump float gapwidth\n#pragma maplibre: define mediump float width\n#pragma maplibre: define lowp float floorwidth\n#pragma maplibre: define lowp vec4 pattern_from\n#pragma maplibre: define lowp vec4 pattern_to\n#pragma maplibre: define lowp float pixel_ratio_from\n#pragma maplibre: define lowp float pixel_ratio_to\nvoid main() {\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize lowp float offset\n#pragma maplibre: initialize mediump float gapwidth\n#pragma maplibre: initialize mediump float width\n#pragma maplibre: initialize lowp float floorwidth\n#pragma maplibre: initialize mediump vec4 pattern_from\n#pragma maplibre: initialize mediump vec4 pattern_to\n#pragma maplibre: initialize lowp float pixel_ratio_from\n#pragma maplibre: initialize lowp float pixel_ratio_to\nif (opacity < 0.01) {gl_Position=vec4(-2.0,-2.0,-2.0,1.0);return;}float ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=vec2(ivec2(a_data.xy)-128);float a_direction=float(int(a_data.z & 3u)-1);float a_linesofar=float((a_data.z >> 2u)+a_data.w*64u)*LINE_DISTANCE_SCALE;vec2 pos=vec2(a_pos_normal >> 1);mediump vec2 normal=vec2(a_pos_normal & 1);normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);float adjustedThickness=projectLineThickness(pos.y);vec4 projected_no_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation);vec4 projected_with_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation+dist/u_ratio*adjustedThickness);gl_Position=projected_with_extrude;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length((projected_with_extrude.xy-projected_no_extrude.xy)/projected_with_extrude.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nv_linesofar=a_linesofar;v_width2=vec2(outset,inset);v_width=floorwidth;}"),
+	lineSDF: prepare("uniform lowp float u_lineatlas_width;uniform sampler2D u_image;uniform float u_mix;in vec2 v_normal;flat in vec2 v_width2;in vec2 v_tex_a;in vec2 v_tex_b;in float v_gamma_scale;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define highp vec4 color\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define mediump float width\n#pragma maplibre: define lowp float floorwidth\n#pragma maplibre: define mediump vec4 dasharray_from\n#pragma maplibre: define mediump vec4 dasharray_to\nvoid main() {\n#pragma maplibre: initialize highp vec4 color\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize mediump float width\n#pragma maplibre: initialize lowp float floorwidth\n#pragma maplibre: initialize mediump vec4 dasharray_from\n#pragma maplibre: initialize mediump vec4 dasharray_to\nclipAntimeridian();float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);float sdfdist_a=texture(u_image,v_tex_a).a;float sdfdist_b=texture(u_image,v_tex_b).a;float sdfdist=mix(sdfdist_a,sdfdist_b,u_mix);float sdfgamma=(u_lineatlas_width/256.0/u_device_pixel_ratio)/min(dasharray_from.w,dasharray_to.w);alpha*=smoothstep(0.5-sdfgamma/floorwidth,0.5+sdfgamma/floorwidth,sdfdist);fragColor=color*(alpha*opacity);\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "\n#define scale 0.015873016\n#define LINE_DISTANCE_SCALE 2.0\nlayout(location=0) in ivec2 a_pos_normal;layout(location=1) in uvec4 a_data;uniform vec2 u_translation;uniform mediump float u_ratio;uniform float u_tileratio;uniform float u_crossfade_from;uniform float u_crossfade_to;uniform float u_lineatlas_height;out vec2 v_normal;flat out vec2 v_width2;out vec2 v_tex_a;out vec2 v_tex_b;out float v_gamma_scale;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma maplibre: define highp vec4 color\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define mediump float gapwidth\n#pragma maplibre: define lowp float offset\n#pragma maplibre: define mediump float width\n#pragma maplibre: define lowp float floorwidth\n#pragma maplibre: define mediump vec4 dasharray_from\n#pragma maplibre: define mediump vec4 dasharray_to\nvoid main() {\n#pragma maplibre: initialize highp vec4 color\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize mediump float gapwidth\n#pragma maplibre: initialize lowp float offset\n#pragma maplibre: initialize mediump float width\n#pragma maplibre: initialize lowp float floorwidth\n#pragma maplibre: initialize mediump vec4 dasharray_from\n#pragma maplibre: initialize mediump vec4 dasharray_to\nif (opacity < 0.01) {gl_Position=vec4(-2.0,-2.0,-2.0,1.0);return;}float ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=vec2(ivec2(a_data.xy)-128);float a_direction=float(int(a_data.z & 3u)-1);float a_linesofar=float((a_data.z >> 2u)+a_data.w*64u)*LINE_DISTANCE_SCALE;vec2 pos=vec2(a_pos_normal >> 1);mediump vec2 normal=vec2(a_pos_normal & 1);normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);float adjustedThickness=projectLineThickness(pos.y);vec4 projected_no_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation);vec4 projected_with_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation+dist/u_ratio*adjustedThickness);gl_Position=projected_with_extrude;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length((projected_with_extrude.xy-projected_no_extrude.xy)/projected_with_extrude.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nfloat u_patternscale_a_x=u_tileratio/dasharray_from.w/u_crossfade_from;float u_patternscale_a_y=-dasharray_from.z/2.0/u_lineatlas_height;float u_patternscale_b_x=u_tileratio/dasharray_to.w/u_crossfade_to;float u_patternscale_b_y=-dasharray_to.z/2.0/u_lineatlas_height;v_tex_a=vec2(a_linesofar*u_patternscale_a_x/floorwidth,normal.y*u_patternscale_a_y+(float(dasharray_from.y)+0.5)/u_lineatlas_height);v_tex_b=vec2(a_linesofar*u_patternscale_b_x/floorwidth,normal.y*u_patternscale_b_y+(float(dasharray_to.y)+0.5)/u_lineatlas_height);v_width2=vec2(outset,inset);}"),
+	lineGradientSDF: prepare("uniform sampler2D u_image;uniform sampler2D u_image_dash;uniform float u_mix;uniform lowp float u_lineatlas_width;in vec2 v_normal;flat in vec2 v_width2;in vec2 v_tex_a;in vec2 v_tex_b;in float v_gamma_scale;in highp vec2 v_uv;\n#ifdef GLOBE\nin float v_depth;\n#endif\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define mediump float width\n#pragma maplibre: define lowp float floorwidth\n#pragma maplibre: define mediump vec4 dasharray_from\n#pragma maplibre: define mediump vec4 dasharray_to\nvoid main() {\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize mediump float width\n#pragma maplibre: initialize lowp float floorwidth\n#pragma maplibre: initialize mediump vec4 dasharray_from\n#pragma maplibre: initialize mediump vec4 dasharray_to\nclipAntimeridian();float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);vec4 color=texture(u_image,v_uv);float sdfdist_a=texture(u_image_dash,v_tex_a).a;float sdfdist_b=texture(u_image_dash,v_tex_b).a;float sdfdist=mix(sdfdist_a,sdfdist_b,u_mix);float sdfgamma=(u_lineatlas_width/256.0)/min(dasharray_from.w,dasharray_to.w);float dash_alpha=smoothstep(0.5-sdfgamma/floorwidth,0.5+sdfgamma/floorwidth,sdfdist);fragColor=color*(alpha*dash_alpha*opacity);\n#ifdef GLOBE\nif (v_depth > 1.0) {discard;}\n#endif\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "\n#define scale 0.015873016\n#define LINE_DISTANCE_SCALE 2.0\nlayout(location=0) in ivec2 a_pos_normal;layout(location=1) in uvec4 a_data;layout(location=2) in float a_uv_x;layout(location=3) in float a_split_index;uniform vec2 u_translation;uniform mediump float u_ratio;uniform float u_image_height;uniform float u_tileratio;uniform float u_crossfade_from;uniform float u_crossfade_to;uniform float u_lineatlas_height;out vec2 v_normal;flat out vec2 v_width2;out float v_gamma_scale;out highp vec2 v_uv;out vec2 v_tex_a;out vec2 v_tex_b;\n#ifdef GLOBE\nout float v_depth;\n#endif\n#pragma maplibre: define lowp float blur\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define mediump float gapwidth\n#pragma maplibre: define lowp float offset\n#pragma maplibre: define mediump float width\n#pragma maplibre: define lowp float floorwidth\n#pragma maplibre: define mediump vec4 dasharray_from\n#pragma maplibre: define mediump vec4 dasharray_to\nvoid main() {\n#pragma maplibre: initialize lowp float blur\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize mediump float gapwidth\n#pragma maplibre: initialize lowp float offset\n#pragma maplibre: initialize mediump float width\n#pragma maplibre: initialize lowp float floorwidth\n#pragma maplibre: initialize mediump vec4 dasharray_from\n#pragma maplibre: initialize mediump vec4 dasharray_to\nif (opacity < 0.01) {gl_Position=vec4(-2.0,-2.0,-2.0,1.0);return;}float ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=vec2(ivec2(a_data.xy)-128);float a_direction=float(int(a_data.z & 3u)-1);float a_linesofar=float((a_data.z >> 2u)+a_data.w*64u)*LINE_DISTANCE_SCALE;float texel_height=1.0/u_image_height;float half_texel_height=0.5*texel_height;v_uv=vec2(a_uv_x,a_split_index*texel_height-half_texel_height);vec2 pos=vec2(a_pos_normal >> 1);mediump vec2 normal=vec2(a_pos_normal & 1);normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);float adjustedThickness=projectLineThickness(pos.y);vec4 projected_no_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation);vec4 projected_with_extrude=projectTile(pos+offset2/u_ratio*adjustedThickness+u_translation+dist/u_ratio*adjustedThickness);gl_Position=projected_with_extrude;\n#ifdef GLOBE\nv_depth=gl_Position.z/gl_Position.w;\n#endif\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length((projected_with_extrude.xy-projected_no_extrude.xy)/projected_with_extrude.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nfloat u_patternscale_a_x=u_tileratio/dasharray_from.w/u_crossfade_from;float u_patternscale_a_y=-dasharray_from.z/2.0/u_lineatlas_height;float u_patternscale_b_x=u_tileratio/dasharray_to.w/u_crossfade_to;float u_patternscale_b_y=-dasharray_to.z/2.0/u_lineatlas_height;v_tex_a=vec2(a_linesofar*u_patternscale_a_x/floorwidth,normal.y*u_patternscale_a_y+(float(dasharray_from.y)+0.5)/u_lineatlas_height);v_tex_b=vec2(a_linesofar*u_patternscale_b_x/floorwidth,normal.y*u_patternscale_b_y+(float(dasharray_to.y)+0.5)/u_lineatlas_height);v_width2=vec2(outset,inset);}"),
 	layerOpacity: prepare("uniform sampler2D u_image;uniform float u_opacity;in vec2 v_pos;void main() {fragColor=texture(u_image,v_pos)*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(0.0);\n#endif\n}", "layout(location=0) in vec2 a_pos;out vec2 v_pos;void main() {gl_Position=vec4(a_pos.x*2.0-1.0,1.0-a_pos.y*2.0,0.0,1.0);v_pos.x=a_pos.x;v_pos.y=1.0-a_pos.y;}"),
 	raster: prepare("uniform float u_fade_t;uniform float u_opacity;uniform sampler2D u_image0;uniform sampler2D u_image1;in vec3 v_pos0;in vec3 v_pos1;uniform float u_brightness_low;uniform float u_brightness_high;uniform float u_saturation_factor;uniform float u_contrast_factor;uniform vec3 u_spin_weights;void main() {vec4 color0=texture(u_image0,v_pos0.xy/v_pos0.z);vec4 color1=texture(u_image1,v_pos1.xy/v_pos1.z);if (color0.a > 0.0) {color0.rgb=color0.rgb/color0.a;}if (color1.a > 0.0) {color1.rgb=color1.rgb/color1.a;}vec4 color=mix(color0,color1,u_fade_t);color.a*=u_opacity;vec3 rgb=color.rgb;rgb=vec3(dot(rgb,u_spin_weights.xyz),dot(rgb,u_spin_weights.zxy),dot(rgb,u_spin_weights.yzx));float average=(color.r+color.g+color.b)/3.0;rgb+=(average-rgb)*u_saturation_factor;rgb=(rgb-0.5)*u_contrast_factor+0.5;vec3 u_high_vec=vec3(u_brightness_low,u_brightness_low,u_brightness_low);vec3 u_low_vec=vec3(u_brightness_high,u_brightness_high,u_brightness_high);fragColor=vec4(mix(u_high_vec,u_low_vec,rgb)*color.a,color.a);\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "uniform vec2 u_tl_parent;uniform float u_scale_parent;uniform float u_buffer_scale;uniform vec3 u_image_warp;uniform vec4 u_coords_top;uniform vec4 u_coords_bottom;layout(location=0) in vec2 a_pos;out vec3 v_pos0;out vec3 v_pos1;void main() {vec2 fractionalPos=a_pos/8192.0;vec2 topLeft=u_coords_top.xy;vec2 topRight=u_coords_top.zw;vec2 bottomLeft=u_coords_bottom.xy;vec2 bottomRight=u_coords_bottom.zw;vec2 bilinearPos=mix(mix(topLeft,topRight,fractionalPos.x),mix(bottomLeft,bottomRight,fractionalPos.x),fractionalPos.y);float denominator=dot(u_image_warp.xy,fractionalPos)+1.0;vec2 acrossTop=topRight-topLeft+u_image_warp.x*topRight;vec2 downLeft=bottomLeft-topLeft+u_image_warp.y*bottomLeft;vec2 projectivePos=(acrossTop*fractionalPos.x+downLeft*fractionalPos.y+topLeft)/denominator;vec2 position=mix(projectivePos,bilinearPos,u_image_warp.z);gl_Position=projectTile(position,position);vec2 texturePos=((fractionalPos-0.5)/u_buffer_scale)+0.5;\n#ifdef GLOBE\nif (a_pos.y <-32767.5) {texturePos.y=0.0;}if (a_pos.y > 32766.5) {texturePos.y=1.0;}\n#endif\nfloat perspectiveRatio=mix(1.0/denominator,1.0,u_image_warp.z);v_pos0=vec3(texturePos*perspectiveRatio,perspectiveRatio);vec2 parentPos=(texturePos*u_scale_parent)+u_tl_parent;v_pos1=vec3(parentPos*perspectiveRatio,perspectiveRatio);}"),
-	symbolIcon: prepare("uniform sampler2D u_texture;in vec2 v_tex;flat in float v_total_opacity;void main() {fragColor=texture(u_texture,v_tex)*v_total_opacity;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "layout(location=0) in vec4 a_pos_offset;layout(location=1) in uvec4 a_data;layout(location=2) in vec4 a_pixeloffset;layout(location=3) in vec3 a_projected_pos;layout(location=4) in uint a_fade_opacity;layout(location=5) in float a_height_offset;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform highp float u_camera_to_center_distance;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform float u_fade_change;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform vec2 u_texsize;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform vec2 u_translation;uniform float u_pitched_scale;uniform bool u_is_offset;uniform bool u_height_anchor_ground;out vec2 v_tex;flat out float v_total_opacity;\n#pragma maplibre: define lowp float opacity\nvoid main() {\n#pragma maplibre: initialize lowp float opacity\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=vec2(a_data.xy);vec2 a_size=vec2(a_data.zw);float a_size_min=float(a_data.z >> 1u);vec2 a_pxoffset=a_pixeloffset.xy;vec2 a_minFontScale=a_pixeloffset.zw/256.0;float ele=a_height_offset+(u_height_anchor_ground ? get_elevation(a_pos) : 0.0);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);vec2 fade_opacity=unpack_opacity(a_fade_opacity);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float visibility=calculate_visibility(projectedPoint);v_total_opacity=opacity*max(0.0,min(visibility,fade_opacity[0]+fade_change));if (v_total_opacity < 0.1){gl_Position=vec4(-2.,-2.,-2.,1.);return;}highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);if (!u_is_offset) {size*=perspective_ratio;}float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;\n#ifdef GLOBE\nif(u_pitch_with_map) {float anchor_pos_tile_y=(u_coord_matrix*vec4(projected_pos.xy/projected_pos.w,z,1.0)).y;projectionScaling=mix(projectionScaling,1.0/circumferenceRatioAtTileY(anchor_pos_tile_y)*u_pitched_scale,u_projection_transition);}\n#endif\nvec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*max(a_minFontScale,fontScale)+a_pxoffset/16.0)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}gl_Position=finalPos;v_tex=a_tex/u_texsize;}"),
-	symbolSDF: prepare("#define SDF_PX 8.0\nuniform bool u_is_halo;uniform bool u_is_plain;uniform sampler2D u_texture;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;uniform bool u_is_text;in vec2 v_data0;in vec3 v_data1;\n#pragma maplibre: define highp vec4 fill_color\n#pragma maplibre: define highp vec4 halo_color\n#pragma maplibre: define lowp float halo_width\n#pragma maplibre: define lowp float halo_blur\nvoid main() {\n#pragma maplibre: initialize highp vec4 fill_color\n#pragma maplibre: initialize highp vec4 halo_color\n#pragma maplibre: initialize lowp float halo_width\n#pragma maplibre: initialize lowp float halo_blur\nfloat EDGE_GAMMA=0.105/u_device_pixel_ratio;vec2 tex=v_data0.xy;float gamma_scale=v_data1.x;float size=v_data1.y;float total_opacity=v_data1[2];float fontScale=u_is_text ? size/24.0 : size;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float inner_edge=(256.0-64.0)/256.0;lowp float dist=texture(u_texture,tex).a;lowp vec4 color_alpha_out_text,color_alpha_out_halo;if (u_is_plain){highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(inner_edge-gamma_scaled,inner_edge+gamma_scaled,dist);color_alpha_out_text=total_opacity*alpha*fill_color;}if (u_is_halo) {float gamma_halo=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);float inner_edge_halo=inner_edge+gamma_halo*gamma_scale;highp float gamma_scaled_halo=gamma_halo*gamma_scale;highp float alpha_halo=smoothstep(inner_edge_halo-gamma_scaled_halo,inner_edge_halo+gamma_scaled_halo,dist);highp float halo_edge=(6.0-halo_width/fontScale)/SDF_PX;alpha_halo= min(smoothstep(halo_edge-gamma_scaled_halo,halo_edge+gamma_scaled_halo,dist),1.0-alpha_halo);color_alpha_out_halo=total_opacity*alpha_halo*halo_color;}if (u_is_plain && u_is_halo) {fragColor=color_alpha_out_text+(1.-color_alpha_out_text.a)*color_alpha_out_halo;} else if (u_is_halo){fragColor=color_alpha_out_halo;} else {fragColor=color_alpha_out_text;}\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "layout(location=0) in vec4 a_pos_offset;layout(location=1) in uvec4 a_data;layout(location=2) in vec4 a_pixeloffset;layout(location=3) in vec3 a_projected_pos;layout(location=4) in uint a_fade_opacity;layout(location=5) in float a_height_offset;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;uniform vec2 u_translation;uniform float u_pitched_scale;uniform bool u_is_offset;uniform bool u_height_anchor_ground;out vec2 v_data0;out vec3 v_data1;\n#pragma maplibre: define highp vec4 fill_color\n#pragma maplibre: define highp vec4 halo_color\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define lowp float halo_width\n#pragma maplibre: define lowp float halo_blur\nvoid main() {\n#pragma maplibre: initialize highp vec4 fill_color\n#pragma maplibre: initialize highp vec4 halo_color\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize lowp float halo_width\n#pragma maplibre: initialize lowp float halo_blur\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=vec2(a_data.xy);vec2 a_size=vec2(a_data.zw);float a_size_min=float(a_data.z >> 1u);vec2 a_pxoffset=a_pixeloffset.xy/16.0;vec2 a_minFontScale=a_pixeloffset.zw/256.0;float ele=a_height_offset+(u_height_anchor_ground ? get_elevation(a_pos) : 0.0);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);vec2 fade_opacity=unpack_opacity(a_fade_opacity);float visibility=calculate_visibility(projectedPoint);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));float total_opacity=opacity*interpolated_fade_opacity;if (total_opacity < 0.1){gl_Position=vec4(-2.,-2.,-2.,1.);return;}highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);if (!u_is_offset) {size*=perspective_ratio;}float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;\n#ifdef GLOBE\nif(u_pitch_with_map) {float anchor_pos_tile_y=(u_coord_matrix*vec4(projected_pos.xy/projected_pos.w,z,1.0)).y;projectionScaling=mix(projectionScaling,1.0/circumferenceRatioAtTileY(anchor_pos_tile_y)*u_pitched_scale,u_projection_transition);}\n#endif\nvec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*max(a_minFontScale,fontScale)+a_pxoffset)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}float gamma_scale=finalPos.w;gl_Position=finalPos;v_data0=a_tex/u_texsize;v_data1=vec3(gamma_scale,size,total_opacity);}"),
-	symbolTextAndIcon: prepare("#define SDF_PX 8.0\n#define SDF 1.0\n#define ICON 0.0\nuniform bool u_is_halo;uniform bool u_is_text;uniform sampler2D u_texture;uniform sampler2D u_texture_icon;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;in vec4 v_data0;in vec3 v_data1;flat in float v_is_sdf;\n#pragma maplibre: define highp vec4 fill_color\n#pragma maplibre: define highp vec4 halo_color\n#pragma maplibre: define lowp float halo_width\n#pragma maplibre: define lowp float halo_blur\nvoid main() {\n#pragma maplibre: initialize highp vec4 fill_color\n#pragma maplibre: initialize highp vec4 halo_color\n#pragma maplibre: initialize lowp float halo_width\n#pragma maplibre: initialize lowp float halo_blur\nfloat total_opacity=v_data1[2];if (v_is_sdf==ICON) {vec2 tex_icon=v_data0.zw;fragColor=texture(u_texture_icon,tex_icon)*total_opacity;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\nreturn;}vec2 tex=v_data0.xy;float EDGE_GAMMA=0.105/u_device_pixel_ratio;float gamma_scale=v_data1.x;float size=v_data1.y;float fontScale=size/24.0;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float buff=(256.0-64.0)/256.0;lowp float dist=texture(u_texture,tex).a;lowp vec4 color_alpha_out,color_alpha_out_halo;if (u_is_text) {highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(buff-gamma_scaled,buff+gamma_scaled,dist);color_alpha_out=fill_color*(alpha*total_opacity);}if (u_is_halo) {highp float gamma_halo=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);lowp float buff_halo=(6.0-halo_width/fontScale)/SDF_PX;highp float gamma_scaled_halo=gamma_halo*gamma_scale;highp float alpha_halo=smoothstep(buff_halo-gamma_scaled_halo,buff_halo+gamma_scaled_halo,dist);color_alpha_out_halo=halo_color*(alpha_halo*total_opacity);}if (u_is_text && u_is_halo) {fragColor=color_alpha_out+(1.-color_alpha_out.a)*color_alpha_out_halo;} else if (u_is_halo) {fragColor=color_alpha_out_halo;} else {fragColor=color_alpha_out;}\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "layout(location=0) in vec4 a_pos_offset;layout(location=1) in uvec4 a_data;layout(location=2) in vec3 a_projected_pos;layout(location=3) in uint a_fade_opacity;layout(location=4) in float a_height_offset;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;uniform vec2 u_texsize_icon;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform vec2 u_translation;uniform float u_pitched_scale;uniform bool u_is_offset;uniform bool u_height_anchor_ground;out vec4 v_data0;out vec3 v_data1;flat out float v_is_sdf;\n#pragma maplibre: define highp vec4 fill_color\n#pragma maplibre: define highp vec4 halo_color\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define lowp float halo_width\n#pragma maplibre: define lowp float halo_blur\nvoid main() {\n#pragma maplibre: initialize highp vec4 fill_color\n#pragma maplibre: initialize highp vec4 halo_color\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize lowp float halo_width\n#pragma maplibre: initialize lowp float halo_blur\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=vec2(a_data.xy);vec2 a_size=vec2(a_data.zw);float a_size_min=float(a_data.z >> 1u);float is_sdf=float(a_data.z & 1u);float ele=a_height_offset+(u_height_anchor_ground ? get_elevation(a_pos) : 0.0);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);vec2 fade_opacity=unpack_opacity(a_fade_opacity);float visibility=calculate_visibility(projectedPoint);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));float total_opacity=opacity*interpolated_fade_opacity;if (total_opacity < 0.1){gl_Position=vec4(-2.,-2.,-2.,1.);return;}highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);if (!u_is_offset) {size*=perspective_ratio;}float fontScale=size/24.0;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;\n#ifdef GLOBE\nif(u_pitch_with_map && !u_is_along_line) {float anchor_pos_tile_y=(u_coord_matrix*vec4(projected_pos.xy/projected_pos.w,z,1.0)).y;projectionScaling=mix(projectionScaling,1.0/circumferenceRatioAtTileY(anchor_pos_tile_y)*u_pitched_scale,u_projection_transition);}\n#endif\nvec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*fontScale)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}float gamma_scale=finalPos.w;gl_Position=finalPos;v_data0.xy=a_tex/u_texsize;v_data0.zw=a_tex/u_texsize_icon;v_data1=vec3(gamma_scale,size,total_opacity);v_is_sdf=is_sdf;}"),
+	symbolIcon: prepare("uniform sampler2D u_texture;in vec2 v_tex;flat in float v_total_opacity;void main() {fragColor=texture(u_texture,v_tex)*v_total_opacity;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "layout(location=0) in vec4 a_pos_offset;layout(location=1) in uvec4 a_data;layout(location=2) in vec4 a_pixeloffset;layout(location=3) in vec3 a_projected_pos;layout(location=4) in uint a_fade_opacity;layout(location=5) in float a_height_offset;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform bool u_rotate_symbol;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform vec2 u_texsize;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform vec2 u_translation;uniform float u_pitched_scale;uniform bool u_is_offset;uniform bool u_height_anchor_ground;out vec2 v_tex;flat out float v_total_opacity;\n#pragma maplibre: define lowp float opacity\nvoid main() {\n#pragma maplibre: initialize lowp float opacity\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=vec2(a_data.xy);vec2 a_size=vec2(a_data.zw);float a_size_min=float(a_data.z >> 1u);vec2 a_pxoffset=a_pixeloffset.xy;vec2 a_minFontScale=a_pixeloffset.zw/256.0;float ele=a_height_offset+(u_height_anchor_ground ? get_elevation(a_pos) : 0.0);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);vec2 fade_opacity=unpack_opacity(a_fade_opacity);float fade_change=fade_opacity[1] > 0.5 ? u_symbol_fade_change :-u_symbol_fade_change;float visibility=calculate_visibility(projectedPoint);v_total_opacity=opacity*max(0.0,min(visibility,fade_opacity[0]+fade_change));if (v_total_opacity < 0.1){gl_Position=vec4(-2.,-2.,-2.,1.);return;}highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);if (!u_is_offset) {size*=perspective_ratio;}float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;\n#ifdef GLOBE\nif(u_pitch_with_map) {float anchor_pos_tile_y=(u_coord_matrix*vec4(projected_pos.xy/projected_pos.w,z,1.0)).y;projectionScaling=mix(projectionScaling,1.0/circumferenceRatioAtTileY(anchor_pos_tile_y)*u_pitched_scale,u_projection_transition);}\n#endif\nvec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*max(a_minFontScale,fontScale)+a_pxoffset/16.0)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}gl_Position=finalPos;v_tex=a_tex/u_texsize;}"),
+	symbolSDF: prepare("#define SDF_PX 8.0\nuniform bool u_is_halo;uniform bool u_is_plain;uniform sampler2D u_texture;uniform highp float u_gamma_scale;uniform bool u_is_text;in vec2 v_data0;in vec3 v_data1;\n#pragma maplibre: define highp vec4 fill_color\n#pragma maplibre: define highp vec4 halo_color\n#pragma maplibre: define lowp float halo_width\n#pragma maplibre: define lowp float halo_blur\nvoid main() {\n#pragma maplibre: initialize highp vec4 fill_color\n#pragma maplibre: initialize highp vec4 halo_color\n#pragma maplibre: initialize lowp float halo_width\n#pragma maplibre: initialize lowp float halo_blur\nfloat EDGE_GAMMA=0.105/u_device_pixel_ratio;vec2 tex=v_data0.xy;float gamma_scale=v_data1.x;float size=v_data1.y;float total_opacity=v_data1[2];float fontScale=u_is_text ? size/24.0 : size;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float inner_edge=(256.0-64.0)/256.0;lowp float dist=texture(u_texture,tex).a;lowp vec4 color_alpha_out_text,color_alpha_out_halo;if (u_is_plain){highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(inner_edge-gamma_scaled,inner_edge+gamma_scaled,dist);color_alpha_out_text=total_opacity*alpha*fill_color;}if (u_is_halo) {float gamma_halo=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);float inner_edge_halo=inner_edge+gamma_halo*gamma_scale;highp float gamma_scaled_halo=gamma_halo*gamma_scale;highp float alpha_halo=smoothstep(inner_edge_halo-gamma_scaled_halo,inner_edge_halo+gamma_scaled_halo,dist);highp float halo_edge=(6.0-halo_width/fontScale)/SDF_PX;alpha_halo= min(smoothstep(halo_edge-gamma_scaled_halo,halo_edge+gamma_scaled_halo,dist),1.0-alpha_halo);color_alpha_out_halo=total_opacity*alpha_halo*halo_color;}if (u_is_plain && u_is_halo) {fragColor=color_alpha_out_text+(1.-color_alpha_out_text.a)*color_alpha_out_halo;} else if (u_is_halo){fragColor=color_alpha_out_halo;} else {fragColor=color_alpha_out_text;}\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "layout(location=0) in vec4 a_pos_offset;layout(location=1) in uvec4 a_data;layout(location=2) in vec4 a_pixeloffset;layout(location=3) in vec3 a_projected_pos;layout(location=4) in uint a_fade_opacity;layout(location=5) in float a_height_offset;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform bool u_rotate_symbol;uniform vec2 u_texsize;uniform vec2 u_translation;uniform float u_pitched_scale;uniform bool u_is_offset;uniform bool u_height_anchor_ground;out vec2 v_data0;out vec3 v_data1;\n#pragma maplibre: define highp vec4 fill_color\n#pragma maplibre: define highp vec4 halo_color\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define lowp float halo_width\n#pragma maplibre: define lowp float halo_blur\nvoid main() {\n#pragma maplibre: initialize highp vec4 fill_color\n#pragma maplibre: initialize highp vec4 halo_color\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize lowp float halo_width\n#pragma maplibre: initialize lowp float halo_blur\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=vec2(a_data.xy);vec2 a_size=vec2(a_data.zw);float a_size_min=float(a_data.z >> 1u);vec2 a_pxoffset=a_pixeloffset.xy/16.0;vec2 a_minFontScale=a_pixeloffset.zw/256.0;float ele=a_height_offset+(u_height_anchor_ground ? get_elevation(a_pos) : 0.0);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);vec2 fade_opacity=unpack_opacity(a_fade_opacity);float visibility=calculate_visibility(projectedPoint);float fade_change=fade_opacity[1] > 0.5 ? u_symbol_fade_change :-u_symbol_fade_change;float interpolated_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));float total_opacity=opacity*interpolated_fade_opacity;if (total_opacity < 0.1){gl_Position=vec4(-2.,-2.,-2.,1.);return;}highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);if (!u_is_offset) {size*=perspective_ratio;}float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;\n#ifdef GLOBE\nif(u_pitch_with_map) {float anchor_pos_tile_y=(u_coord_matrix*vec4(projected_pos.xy/projected_pos.w,z,1.0)).y;projectionScaling=mix(projectionScaling,1.0/circumferenceRatioAtTileY(anchor_pos_tile_y)*u_pitched_scale,u_projection_transition);}\n#endif\nvec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*max(a_minFontScale,fontScale)+a_pxoffset)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}float gamma_scale=finalPos.w;gl_Position=finalPos;v_data0=a_tex/u_texsize;v_data1=vec3(gamma_scale,size,total_opacity);}"),
+	symbolTextAndIcon: prepare("#define SDF_PX 8.0\n#define SDF 1.0\n#define ICON 0.0\nuniform bool u_is_halo;uniform bool u_is_text;uniform sampler2D u_texture;uniform sampler2D u_texture_icon;uniform highp float u_gamma_scale;in vec4 v_data0;in vec3 v_data1;flat in float v_is_sdf;\n#pragma maplibre: define highp vec4 fill_color\n#pragma maplibre: define highp vec4 halo_color\n#pragma maplibre: define lowp float halo_width\n#pragma maplibre: define lowp float halo_blur\nvoid main() {\n#pragma maplibre: initialize highp vec4 fill_color\n#pragma maplibre: initialize highp vec4 halo_color\n#pragma maplibre: initialize lowp float halo_width\n#pragma maplibre: initialize lowp float halo_blur\nfloat total_opacity=v_data1[2];if (v_is_sdf==ICON) {vec2 tex_icon=v_data0.zw;fragColor=texture(u_texture_icon,tex_icon)*total_opacity;\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\nreturn;}vec2 tex=v_data0.xy;float EDGE_GAMMA=0.105/u_device_pixel_ratio;float gamma_scale=v_data1.x;float size=v_data1.y;float fontScale=size/24.0;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float buff=(256.0-64.0)/256.0;lowp float dist=texture(u_texture,tex).a;lowp vec4 color_alpha_out,color_alpha_out_halo;if (u_is_text) {highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(buff-gamma_scaled,buff+gamma_scaled,dist);color_alpha_out=fill_color*(alpha*total_opacity);}if (u_is_halo) {highp float gamma_halo=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);lowp float buff_halo=(6.0-halo_width/fontScale)/SDF_PX;highp float gamma_scaled_halo=gamma_halo*gamma_scale;highp float alpha_halo=smoothstep(buff_halo-gamma_scaled_halo,buff_halo+gamma_scaled_halo,dist);color_alpha_out_halo=halo_color*(alpha_halo*total_opacity);}if (u_is_text && u_is_halo) {fragColor=color_alpha_out+(1.-color_alpha_out.a)*color_alpha_out_halo;} else if (u_is_halo) {fragColor=color_alpha_out_halo;} else {fragColor=color_alpha_out;}\n#ifdef OVERDRAW_INSPECTOR\nfragColor=vec4(1.0);\n#endif\n}", "layout(location=0) in vec4 a_pos_offset;layout(location=1) in uvec4 a_data;layout(location=2) in vec3 a_projected_pos;layout(location=3) in uint a_fade_opacity;layout(location=4) in float a_height_offset;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform bool u_rotate_symbol;uniform vec2 u_texsize;uniform vec2 u_texsize_icon;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform vec2 u_translation;uniform float u_pitched_scale;uniform bool u_is_offset;uniform bool u_height_anchor_ground;out vec4 v_data0;out vec3 v_data1;flat out float v_is_sdf;\n#pragma maplibre: define highp vec4 fill_color\n#pragma maplibre: define highp vec4 halo_color\n#pragma maplibre: define lowp float opacity\n#pragma maplibre: define lowp float halo_width\n#pragma maplibre: define lowp float halo_blur\nvoid main() {\n#pragma maplibre: initialize highp vec4 fill_color\n#pragma maplibre: initialize highp vec4 halo_color\n#pragma maplibre: initialize lowp float opacity\n#pragma maplibre: initialize lowp float halo_width\n#pragma maplibre: initialize lowp float halo_blur\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=vec2(a_data.xy);vec2 a_size=vec2(a_data.zw);float a_size_min=float(a_data.z >> 1u);float is_sdf=float(a_data.z & 1u);float ele=a_height_offset+(u_height_anchor_ground ? get_elevation(a_pos) : 0.0);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);vec2 fade_opacity=unpack_opacity(a_fade_opacity);float visibility=calculate_visibility(projectedPoint);float fade_change=fade_opacity[1] > 0.5 ? u_symbol_fade_change :-u_symbol_fade_change;float interpolated_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));float total_opacity=opacity*interpolated_fade_opacity;if (total_opacity < 0.1){gl_Position=vec4(-2.,-2.,-2.,1.);return;}highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);if (!u_is_offset) {size*=perspective_ratio;}float fontScale=size/24.0;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;\n#ifdef GLOBE\nif(u_pitch_with_map && !u_is_along_line) {float anchor_pos_tile_y=(u_coord_matrix*vec4(projected_pos.xy/projected_pos.w,z,1.0)).y;projectionScaling=mix(projectionScaling,1.0/circumferenceRatioAtTileY(anchor_pos_tile_y)*u_pitched_scale,u_projection_transition);}\n#endif\nvec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*fontScale)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}float gamma_scale=finalPos.w;gl_Position=finalPos;v_data0.xy=a_tex/u_texsize;v_data0.zw=a_tex/u_texsize_icon;v_data1=vec3(gamma_scale,size,total_opacity);v_is_sdf=is_sdf;}"),
 	terrain: prepare("uniform sampler2D u_texture;uniform vec4 u_fog_color;uniform vec4 u_horizon_color;uniform float u_fog_ground_blend;uniform float u_fog_ground_blend_opacity;uniform float u_horizon_fog_blend;uniform bool u_is_globe_mode;in vec2 v_texture_pos;in float v_fog_depth;const float gamma=2.2;vec4 gammaToLinear(vec4 color) {return pow(color,vec4(gamma));}vec4 linearToGamma(vec4 color) {return pow(color,vec4(1.0/gamma));}void main() {vec4 surface_color=texture(u_texture,vec2(v_texture_pos.x,1.0-v_texture_pos.y));if (!u_is_globe_mode && u_fog_ground_blend_opacity > 0.0 && v_fog_depth > u_fog_ground_blend) {vec4 surface_color_linear=gammaToLinear(surface_color);float blend_color=smoothstep(0.0,1.0,max((v_fog_depth-u_horizon_fog_blend)/(1.0-u_horizon_fog_blend),0.0));vec4 fog_horizon_color_linear=mix(gammaToLinear(u_fog_color),gammaToLinear(u_horizon_color),blend_color);float factor_fog=max(v_fog_depth-u_fog_ground_blend,0.0)/(1.0-u_fog_ground_blend);fragColor=linearToGamma(mix(surface_color_linear,fog_horizon_color_linear,pow(factor_fog,2.0)*u_fog_ground_blend_opacity));} else {fragColor=surface_color;}}", "layout(location=0) in vec3 a_pos3d;uniform mat4 u_fog_matrix;uniform float u_ele_delta;out vec2 v_texture_pos;out float v_fog_depth;void main() {float ele=get_elevation(a_pos3d.xy);float ele_delta=a_pos3d.z==1.0 ? u_ele_delta : 0.0;v_texture_pos=a_pos3d.xy/8192.0;gl_Position=projectTileFor3D(a_pos3d.xy,ele-ele_delta);vec4 pos=u_fog_matrix*vec4(a_pos3d.xy,ele,1.0);v_fog_depth=pos.z/pos.w*0.5+0.5;}"),
 	terrainDepth: prepare("in float v_depth;const highp vec4 bitSh=vec4(256.*256.*256.,256.*256.,256.,1.);const highp vec4 bitMsk=vec4(0.,vec3(1./256.0));highp vec4 pack(highp float value) {highp vec4 comp=fract(value*bitSh);comp-=comp.xxyz*bitMsk;return comp;}void main() {fragColor=pack(v_depth);}", "layout(location=0) in vec3 a_pos3d;uniform float u_ele_delta;out float v_depth;void main() {float ele=get_elevation(a_pos3d.xy);float ele_delta=a_pos3d.z==1.0 ? u_ele_delta : 0.0;gl_Position=projectTileFor3D(a_pos3d.xy,ele-ele_delta);v_depth=gl_Position.z/gl_Position.w;}"),
 	atmosphere: prepare("#ifdef GL_ES\nprecision highp float;\n#endif\nin vec3 view_direction;uniform vec3 u_sun_pos;uniform vec3 u_globe_position;uniform float u_globe_radius;uniform float u_atmosphere_blend;/**Shader use from https:*Made some change to adapt to MapLibre Globe geometry*/const float PI=3.141592653589793;const int iSteps=5;const int jSteps=3;/*radius of the planet*/const float EARTH_RADIUS=6371e3;/*radius of the atmosphere*/const float ATMOS_RADIUS=6471e3;vec2 rsi(vec3 r0,vec3 rd,float sr) {float a=dot(rd,rd);float b=2.0*dot(rd,r0);float c=dot(r0,r0)-(sr*sr);float d=(b*b)-4.0*a*c;if (d < 0.0) return vec2(1e5,-1e5);return vec2((-b-sqrt(d))/(2.0*a),(-b+sqrt(d))/(2.0*a));}vec4 atmosphere(vec3 r,vec3 r0,vec3 pSun,float iSun,float rPlanet,float rAtmos,vec3 kRlh,float kMie,float shRlh,float shMie,float g) {pSun=normalize(pSun);r=normalize(r);vec2 p=rsi(r0,r,rAtmos);if (p.x > p.y) {return vec4(0.0,0.0,0.0,1.0);}if (p.x < 0.0) {p.x=0.0;}vec3 pos=r0+r*p.x;vec2 p2=rsi(r0,r,rPlanet);if (p2.x <=p2.y && p2.x > 0.0) {p.y=min(p.y,p2.x);}float iStepSize=(p.y-p.x)/float(iSteps);float iTime=p.x+iStepSize*0.5;vec3 totalRlh=vec3(0,0,0);vec3 totalMie=vec3(0,0,0);float iOdRlh=0.0;float iOdMie=0.0;float mu=dot(r,pSun);float mumu=mu*mu;float gg=g*g;float pRlh=3.0/(16.0*PI)*(1.0+mumu);float pMie=3.0/(8.0*PI)*((1.0-gg)*(mumu+1.0))/(pow(1.0+gg-2.0*mu*g,1.5)*(2.0+gg));for (int i=0; i < iSteps; i++) {vec3 iPos=r0+r*iTime;float iHeight=length(iPos)-rPlanet;float odStepRlh=exp(-iHeight/shRlh)*iStepSize;float odStepMie=exp(-iHeight/shMie)*iStepSize;iOdRlh+=odStepRlh;iOdMie+=odStepMie;float jStepSize=rsi(iPos,pSun,rAtmos).y/float(jSteps);float jTime=jStepSize*0.5;float jOdRlh=0.0;float jOdMie=0.0;for (int j=0; j < jSteps; j++) {vec3 jPos=iPos+pSun*jTime;float jHeight=length(jPos)-rPlanet;jOdRlh+=exp(-jHeight/shRlh)*jStepSize;jOdMie+=exp(-jHeight/shMie)*jStepSize;jTime+=jStepSize;}vec3 attn=exp(-(kMie*(iOdMie+jOdMie)+kRlh*(iOdRlh+jOdRlh)));totalRlh+=odStepRlh*attn;totalMie+=odStepMie*attn;iTime+=iStepSize;}float opacity=exp(-(length(kRlh)*length(totalRlh)+kMie*length(totalMie)));vec3 color=iSun*(pRlh*kRlh*totalRlh+pMie*kMie*totalMie);return vec4(color,opacity);}void main() {vec3 scale_camera_pos=-u_globe_position*EARTH_RADIUS/u_globe_radius;vec4 color=atmosphere(normalize(view_direction),scale_camera_pos,u_sun_pos,22.0,EARTH_RADIUS,ATMOS_RADIUS,vec3(5.5e-6,13.0e-6,22.4e-6),21e-6,8e3,1.2e3,0.758\n);color.rgb=1.0-exp(-1.0*color.rgb);color=pow(color,vec4(1.0/2.2));fragColor=vec4(color.rgb,1.0-color.a)*u_atmosphere_blend;}", "layout(location=0) in vec2 a_pos;uniform mat4 u_inv_proj_matrix;out vec3 view_direction;void main() {view_direction=(u_inv_proj_matrix*vec4(a_pos,0.0,1.0)).xyz;gl_Position=vec4(a_pos,0.0,1.0);}"),
-	sky: prepare("uniform vec4 u_sky_color;uniform vec4 u_horizon_color;uniform vec2 u_horizon;uniform vec2 u_horizon_normal;uniform float u_sky_horizon_blend;uniform float u_sky_blend;void main() {float x=gl_FragCoord.x;float y=gl_FragCoord.y;float blend=(y-u_horizon.y)*u_horizon_normal.y+(x-u_horizon.x)*u_horizon_normal.x;if (blend > 0.0) {if (blend < u_sky_horizon_blend) {fragColor=mix(u_sky_color,u_horizon_color,pow(1.0-blend/u_sky_horizon_blend,2.0));} else {fragColor=u_sky_color;}}fragColor=mix(fragColor,vec4(vec3(0.0),0.0),u_sky_blend);}", "layout(location=0) in vec2 a_pos;void main() {gl_Position=vec4(a_pos,1.0,1.0);}")
+	sky: prepare("uniform vec4 u_sky_color;uniform vec4 u_horizon_color;uniform vec2 u_horizon;uniform vec2 u_horizon_normal;uniform float u_sky_horizon_blend;uniform float u_sky_blend;uniform vec3 u_globe_position;uniform float u_globe_radius;in vec3 v_view_direction;void main() {float x=gl_FragCoord.x;float y=gl_FragCoord.y;float blend=(y-u_horizon.y)*u_horizon_normal.y+(x-u_horizon.x)*u_horizon_normal.x;if (u_sky_blend > 0.0) {vec3 ray=normalize(v_view_direction);float globe_distance=length(u_globe_position);float angle_to_globe_center=acos(clamp(dot(ray,u_globe_position)/globe_distance,-1.0,1.0));float horizon_angle=asin(min(u_globe_radius/globe_distance,1.0));blend=mix(blend,(angle_to_globe_center-horizon_angle)*u_camera_to_center_distance*u_device_pixel_ratio,u_sky_blend);}if (blend > 0.0) {if (blend < u_sky_horizon_blend) {fragColor=mix(u_sky_color,u_horizon_color,pow(1.0-blend/u_sky_horizon_blend,2.0));} else {fragColor=u_sky_color;}}fragColor=mix(fragColor,vec4(vec3(0.0),0.0),u_sky_blend);}", "layout(location=0) in vec2 a_pos;uniform mat4 u_inv_proj_matrix;out vec3 v_view_direction;void main() {v_view_direction=(u_inv_proj_matrix*vec4(a_pos,0.0,1.0)).xyz;gl_Position=vec4(a_pos,1.0,1.0);}")
 };
 /** Expand #pragmas to #ifdefs, extract attributes and uniforms */
 function prepare(fragmentSource, vertexSource) {
@@ -9767,6 +10190,7 @@ var TransformHelper = class {
 			const halfFov = this.fovInRadians / 2;
 			this._cameraToCenterDistance = .5 / Math.tan(halfFov) * this._height;
 		}
+		this._pixelPerMeter = mercatorZfromAltitude(1, this.center.lat) * this.worldSize;
 		this._callbacks.calcMatrices();
 	}
 	calculateCenterFromCameraLngLatAlt(lnglat, alt, bearing, pitch) {
@@ -9836,15 +10260,9 @@ var TransformHelper = class {
 		};
 	}
 	getCameraPoint() {
-		const pitch = this.pitchInRadians;
-		const offset = Math.tan(pitch) * (this.cameraToCenterDistance || 1);
-		return this.centerPoint.add(new Point(offset * Math.sin(this.rollInRadians), offset * Math.cos(this.rollInRadians)));
-	}
-	getCameraAltitude() {
-		return Math.cos(this.pitchInRadians) * this._cameraToCenterDistance / this._pixelPerMeter + this.elevation;
-	}
-	getCameraLngLat() {
-		return cameraMercatorCoordinate(this).toLngLat();
+		const pitch = this.pitchInRadians;
+		const offset = Math.tan(pitch) * (this.cameraToCenterDistance || 1);
+		return this.centerPoint.add(new Point(offset * Math.sin(this.rollInRadians), offset * Math.cos(this.rollInRadians)));
 	}
 	getMercatorTileCoordinates(overscaledTileID) {
 		if (!overscaledTileID) return [
@@ -9863,63 +10281,6 @@ var TransformHelper = class {
 	}
 };
 //#endregion
-//#region src/util/primitives/aabb.ts
-var Aabb = class Aabb {
-	constructor(min_, max_) {
-		this.min = min_;
-		this.max = max_;
-		this.center = scale$2([], add([], this.min, this.max), .5);
-	}
-	quadrant(index) {
-		const split = [index % 2 === 0, index < 2];
-		const qMin = clone(this.min);
-		const qMax = clone(this.max);
-		for (let axis = 0; axis < split.length; axis++) {
-			qMin[axis] = split[axis] ? this.min[axis] : this.center[axis];
-			qMax[axis] = split[axis] ? this.center[axis] : this.max[axis];
-		}
-		qMax[2] = this.max[2];
-		return new Aabb(qMin, qMax);
-	}
-	distanceX(point) {
-		return Math.max(Math.min(this.max[0], point[0]), this.min[0]) - point[0];
-	}
-	distanceY(point) {
-		return Math.max(Math.min(this.max[1], point[1]), this.min[1]) - point[1];
-	}
-	/**
-	* Performs a frustum-aabb intersection test.
-	*/
-	intersectsFrustum(frustum) {
-		let fullyInside = true;
-		for (const plane of frustum.planes) {
-			const planeIntersection = this.intersectsPlane(plane);
-			if (planeIntersection === 0) return 0;
-			if (planeIntersection === 1) fullyInside = false;
-		}
-		if (fullyInside) return 2;
-		if (frustum.aabb.min[0] > this.max[0] || frustum.aabb.min[1] > this.max[1] || frustum.aabb.min[2] > this.max[2] || frustum.aabb.max[0] < this.min[0] || frustum.aabb.max[1] < this.min[1] || frustum.aabb.max[2] < this.min[2]) return 0;
-		return 1;
-	}
-	/**
-	* Performs a halfspace-aabb intersection test.
-	*/
-	intersectsPlane(plane) {
-		let distMin = plane[3];
-		let distMax = plane[3];
-		for (let i = 0; i < 3; i++) if (plane[i] > 0) {
-			distMin += plane[i] * this.min[i];
-			distMax += plane[i] * this.max[i];
-		} else {
-			distMax += plane[i] * this.min[i];
-			distMin += plane[i] * this.max[i];
-		}
-		if (distMin >= 0) return 2;
-		if (distMax < 0) return 0;
-		return 1;
-	}
-};
-//#endregion
 //#region src/geo/projection/mercator_covering_tiles_details_provider.ts
 var MercatorCoveringTilesDetailsProvider = class {
 	distanceToTile2d(pointX, pointY, _tileID, boundingVolume) {
@@ -9958,249 +10319,16 @@ var MercatorCoveringTilesDetailsProvider = class {
 			maxElevation
 		]);
 	}
-	allowVariableZoom(transform, options) {
-		const zfov = transform.fov * (Math.abs(Math.cos(transform.rollInRadians)) * transform.height + Math.abs(Math.sin(transform.rollInRadians)) * transform.width) / transform.height;
-		const maxConstantZoomPitch = clamp(78.5 - zfov / 2, 0, 60);
-		return !!options.terrain || transform.pitch > maxConstantZoomPitch;
-	}
-	allowWorldCopies() {
-		return true;
-	}
-	prepareNextFrame() {}
-};
-//#endregion
-//#region src/util/primitives/frustum.ts
-var Frustum = class Frustum {
-	constructor(points, planes, aabb) {
-		this.points = points;
-		this.planes = planes;
-		this.aabb = aabb;
-	}
-	static fromInvProjectionMatrix(invProj, worldSize = 1, zoom = 0, horizonPlane, flippedNearFar) {
-		const clipSpaceCorners = [
-			[
-				-1,
-				1,
-				-1,
-				1
-			],
-			[
-				1,
-				1,
-				-1,
-				1
-			],
-			[
-				1,
-				-1,
-				-1,
-				1
-			],
-			[
-				-1,
-				-1,
-				-1,
-				1
-			],
-			[
-				-1,
-				1,
-				1,
-				1
-			],
-			[
-				1,
-				1,
-				1,
-				1
-			],
-			[
-				1,
-				-1,
-				1,
-				1
-			],
-			[
-				-1,
-				-1,
-				1,
-				1
-			]
-		];
-		const frustumPlanePointIndices = flippedNearFar ? [
-			[
-				6,
-				5,
-				4
-			],
-			[
-				0,
-				1,
-				2
-			],
-			[
-				0,
-				3,
-				7
-			],
-			[
-				2,
-				1,
-				5
-			],
-			[
-				3,
-				2,
-				6
-			],
-			[
-				0,
-				4,
-				5
-			]
-		] : [
-			[
-				0,
-				1,
-				2
-			],
-			[
-				6,
-				5,
-				4
-			],
-			[
-				0,
-				3,
-				7
-			],
-			[
-				2,
-				1,
-				5
-			],
-			[
-				3,
-				2,
-				6
-			],
-			[
-				0,
-				4,
-				5
-			]
-		];
-		const scale = Math.pow(2, zoom);
-		const frustumCoords = clipSpaceCorners.map((v) => unprojectClipSpacePoint(v, invProj, worldSize, scale));
-		if (horizonPlane) adjustFarPlaneByHorizonPlane(frustumCoords, frustumPlanePointIndices[0], horizonPlane, flippedNearFar);
-		const frustumPlanes = frustumPlanePointIndices.map((p) => {
-			const a = sub([], frustumCoords[p[0]], frustumCoords[p[1]]);
-			const b = sub([], frustumCoords[p[2]], frustumCoords[p[1]]);
-			const n = normalize([], cross([], a, b));
-			const d = -dot(n, frustumCoords[p[1]]);
-			return n.concat(d);
-		});
-		const min = [
-			Number.POSITIVE_INFINITY,
-			Number.POSITIVE_INFINITY,
-			Number.POSITIVE_INFINITY
-		];
-		const max = [
-			Number.NEGATIVE_INFINITY,
-			Number.NEGATIVE_INFINITY,
-			Number.NEGATIVE_INFINITY
-		];
-		for (const p of frustumCoords) for (let i = 0; i < 3; i++) {
-			min[i] = Math.min(min[i], p[i]);
-			max[i] = Math.max(max[i], p[i]);
-		}
-		return new Frustum(frustumCoords, frustumPlanes, new Aabb(min, max));
-	}
-};
-function unprojectClipSpacePoint(point, invProj, worldSize, scale) {
-	const v = transformMat4([], point, invProj);
-	const s = 1 / v[3] / worldSize * scale;
-	return mul(v, v, [
-		s,
-		s,
-		1 / v[3],
-		s
-	]);
-}
-/**
-* Modifies points in the supplied `frustumCoords` array so that the frustum's far plane only lies as far as the horizon,
-* which improves frustum culling effectiveness.
-* @param frustumCoords - Points of the frustum.
-* @param nearPlanePointsIndices - Which indices in the `frustumCoords` form the near plane.
-* @param horizonPlane - The horizon plane.
-*/
-function adjustFarPlaneByHorizonPlane(frustumCoords, nearPlanePointsIndices, horizonPlane, flippedNearFar) {
-	const nearPlanePointsOffset = flippedNearFar ? 4 : 0;
-	const farPlanePointsOffset = flippedNearFar ? 0 : 4;
-	let maxDist = 0;
-	const cornerRayLengths = [];
-	const cornerRayNormalizedDirections = [];
-	for (let i = 0; i < 4; i++) {
-		const dir = sub([], frustumCoords[i + farPlanePointsOffset], frustumCoords[i + nearPlanePointsOffset]);
-		const len = length$1(dir);
-		scale$2(dir, dir, 1 / len);
-		cornerRayLengths.push(len);
-		cornerRayNormalizedDirections.push(dir);
-	}
-	for (let i = 0; i < 4; i++) {
-		const dist = rayPlaneIntersection(frustumCoords[i + nearPlanePointsOffset], cornerRayNormalizedDirections[i], horizonPlane);
-		if (dist !== null && dist >= 0) maxDist = Math.max(maxDist, dist);
-		else maxDist = Math.max(maxDist, cornerRayLengths[i]);
-	}
-	const nearPlaneNormalized = getNormalizedNearPlane(frustumCoords, nearPlanePointsIndices);
-	const idealFarPlaneDistanceFromNearPlane = getIdealNearFarPlaneDistance(horizonPlane, nearPlaneNormalized);
-	if (idealFarPlaneDistanceFromNearPlane !== null) {
-		const idealCornerRayLength = idealFarPlaneDistanceFromNearPlane / dot(cornerRayNormalizedDirections[0], nearPlaneNormalized);
-		maxDist = Math.min(maxDist, idealCornerRayLength);
+	allowVariableZoom(transform, options) {
+		const zfov = transform.fov * (Math.abs(Math.cos(transform.rollInRadians)) * transform.height + Math.abs(Math.sin(transform.rollInRadians)) * transform.width) / transform.height;
+		const maxConstantZoomPitch = clamp(78.5 - zfov / 2, 0, 60);
+		return !!options.terrain || transform.pitch > maxConstantZoomPitch;
 	}
-	for (let i = 0; i < 4; i++) {
-		const targetLength = Math.min(maxDist, cornerRayLengths[i]);
-		frustumCoords[i + farPlanePointsOffset] = [
-			frustumCoords[i + nearPlanePointsOffset][0] + cornerRayNormalizedDirections[i][0] * targetLength,
-			frustumCoords[i + nearPlanePointsOffset][1] + cornerRayNormalizedDirections[i][1] * targetLength,
-			frustumCoords[i + nearPlanePointsOffset][2] + cornerRayNormalizedDirections[i][2] * targetLength,
-			1
-		];
+	allowWorldCopies() {
+		return true;
 	}
-}
-/**
-* Returns the near plane equation with unit length direction.
-* @param frustumCoords - Points of the frustum.
-* @param nearPlanePointsIndices - Which indices in the `frustumCoords` form the near plane.
-*/
-function getNormalizedNearPlane(frustumCoords, nearPlanePointsIndices) {
-	const nearPlaneA = sub([], frustumCoords[nearPlanePointsIndices[0]], frustumCoords[nearPlanePointsIndices[1]]);
-	const nearPlaneB = sub([], frustumCoords[nearPlanePointsIndices[2]], frustumCoords[nearPlanePointsIndices[1]]);
-	const nearPlaneNormalized = [
-		0,
-		0,
-		0,
-		0
-	];
-	normalize(nearPlaneNormalized, cross([], nearPlaneA, nearPlaneB));
-	nearPlaneNormalized[3] = -dot(nearPlaneNormalized, frustumCoords[nearPlanePointsIndices[0]]);
-	return nearPlaneNormalized;
-}
-/**
-* Returns the ideal distance between the frustum's near and far plane so that the far plane only lies as far as the horizon.
-*/
-function getIdealNearFarPlaneDistance(horizonPlane, nearPlaneNormalized) {
-	const horizonPlaneLen = len(horizonPlane);
-	const normalizedHorizonPlane = scale$3([], horizonPlane, 1 / horizonPlaneLen);
-	const projectedViewDirection = sub([], nearPlaneNormalized, scale$2([], normalizedHorizonPlane, dot(nearPlaneNormalized, normalizedHorizonPlane)));
-	const projectedViewLength = len(projectedViewDirection);
-	if (projectedViewLength > 0) {
-		const horizonCircleRadius = Math.sqrt(1 - normalizedHorizonPlane[3] * normalizedHorizonPlane[3]);
-		const horizonCircleCenter = scale$2([], normalizedHorizonPlane, -normalizedHorizonPlane[3]);
-		const pointFurthestOnHorizonCircle = add([], horizonCircleCenter, scale$2([], projectedViewDirection, horizonCircleRadius / projectedViewLength));
-		return pointPlaneSignedDistance(nearPlaneNormalized, pointFurthestOnHorizonCircle);
-	} else return null;
-}
+	prepareNextFrame() {}
+};
 //#endregion
 //#region src/data/pos3d_attributes.ts
 const pos3dAttributes = createLayout([{
@@ -11437,6 +11565,27 @@ var MercatorTransform = class MercatorTransform {
 	calculateCenterFromCameraLngLatAlt(lnglat, alt, bearing, pitch) {
 		return this._helper.calculateCenterFromCameraLngLatAlt(lnglat, alt, bearing, pitch);
 	}
+	calculateCameraOptionsFromTo(from, altitudeFrom, to, altitudeTo) {
+		const fromMercator = MercatorCoordinate.fromLngLat(from, altitudeFrom);
+		const toMercator = MercatorCoordinate.fromLngLat(to, altitudeTo);
+		const dx = toMercator.x - fromMercator.x;
+		const dy = toMercator.y - fromMercator.y;
+		const dz = toMercator.z - fromMercator.z;
+		const distance3D = Math.hypot(dx, dy, dz);
+		if (distance3D === 0) throw new Error("Can't calculate camera options with same From and To");
+		const groundDistance = Math.hypot(dx, dy);
+		const zoom = scaleZoom(this.cameraToCenterDistance / distance3D / this.tileSize);
+		const bearing = radiansToDegrees(Math.atan2(dx, -dy));
+		let pitch = radiansToDegrees(Math.acos(groundDistance / distance3D));
+		pitch = dz < 0 ? 90 - pitch : 90 + pitch;
+		return {
+			center: toMercator.toLngLat(),
+			elevation: altitudeTo,
+			zoom,
+			pitch,
+			bearing
+		};
+	}
 	_calculateNearFarZIfNeeded(cameraToSeaLevelDistance, limitedPitchRadians, offset) {
 		if (!this._helper.autoCalculateNearFarZ) return;
 		const minElevation = Math.min(this.elevation, this.minElevationForCurrentTile, this.getCameraAltitude() - 100);
@@ -11459,7 +11608,6 @@ var MercatorTransform = class MercatorTransform {
 		const offset = this.centerOffset;
 		const point = projectToWorldCoordinates(this.worldSize, this.center);
 		const x = point.x, y = point.y;
-		this._helper._pixelPerMeter = mercatorZfromAltitude(1, this.center.lat) * this.worldSize;
 		const limitedPitchRadians = degreesToRadians(Math.min(this.pitch, maxMercatorHorizonAngle));
 		const cameraToSeaLevelDistance = Math.max(this._helper.cameraToCenterDistance / 2, this._helper.cameraToCenterDistance + this._helper._elevation * this._helper._pixelPerMeter / Math.cos(limitedPitchRadians));
 		this._calculateNearFarZIfNeeded(cameraToSeaLevelDistance, limitedPitchRadians, offset);
@@ -11585,7 +11733,7 @@ var MercatorTransform = class MercatorTransform {
 		return this._helper.getCameraPoint();
 	}
 	getCameraAltitude() {
-		return this._helper.getCameraAltitude();
+		return Math.cos(this.pitchInRadians) * this.cameraToCenterDistance / this.pixelsPerMeter + this.elevation;
 	}
 	getCameraLngLat() {
 		const pixelPerMeter = mercatorZfromAltitude(1, this.center.lat) * this.worldSize;
@@ -12107,6 +12255,23 @@ function getGlobeRadiusPixels(worldSize, latitudeDegrees) {
 	return worldSize / (2 * Math.PI) / Math.cos(latitudeDegrees * Math.PI / 180);
 }
 /**
+* Returns the globe center in view space, in pixels: the camera is at the origin and looks down the negative Z axis.
+*/
+function getGlobeCenterInViewSpace(transform) {
+	const position = transformMat4(createVec4f64(), [
+		0,
+		0,
+		0,
+		1
+	], transform.modelViewProjectionMatrix);
+	transformMat4(position, position, transform.inverseProjectionMatrix);
+	return [
+		position[0] / position[3],
+		position[1] / position[3],
+		position[2] / position[3]
+	];
+}
+/**
 * Given a 3D point on the surface of a unit sphere, returns its angular coordinates in degrees.
 * The input vector must be normalized.
 */
@@ -12160,7 +12325,7 @@ const PAN_MAX_ANGLE = Math.PI * .98;
 */
 function panSurfaceLocation(tr, point) {
 	const origin = tr.cameraPosition;
-	const distance = length$1(origin);
+	const distance = length(origin);
 	if (distance <= 1) return tr.screenPointToLocation(point);
 	const u = createVec3f64();
 	normalize(u, origin);
@@ -12168,7 +12333,7 @@ function panSurfaceLocation(tr, point) {
 	const c = -dot(direction, u);
 	const lateral = createVec3f64();
 	scaleAndAdd(lateral, direction, u, c);
-	const s = length$1(lateral);
+	const s = length(lateral);
 	if (s < 1e-9) return tr.screenPointToLocation(point);
 	const angle = Math.atan2(s, c);
 	const handoverAngle = Math.asin(1 / distance) * .9;
@@ -12180,9 +12345,9 @@ function panSurfaceLocation(tr, point) {
 	const excess = angle - handoverAngle;
 	const target = targetAtHandover + room * (slopeAtHandover * excess) / (room + slopeAtHandover * excess);
 	const e = createVec3f64();
-	scale$2(e, lateral, 1 / s);
+	scale$1(e, lateral, 1 / s);
 	const surface = createVec3f64();
-	scale$2(surface, u, Math.cos(clamp(target, 0, PAN_MAX_ANGLE)));
+	scale$1(surface, u, Math.cos(clamp(target, 0, PAN_MAX_ANGLE)));
 	scaleAndAdd(surface, surface, e, Math.sin(clamp(target, 0, PAN_MAX_ANGLE)));
 	normalize(surface, surface);
 	return sphereSurfacePointToCoordinates(surface);
@@ -12377,7 +12542,7 @@ function raySphereIntersection(origin, direction, radius = 1) {
 	const radiusSquared = radius * radius;
 	const inner = createVec3f64();
 	const scaledDir = createVec3f64();
-	scale$2(scaledDir, direction, originDotDirection);
+	scale$1(scaledDir, direction, originDotDirection);
 	sub(inner, origin, scaledDir);
 	const discriminant = radiusSquared - dot(inner, inner);
 	if (discriminant < 0) return null;
@@ -12537,9 +12702,9 @@ var ConvexVolume = class ConvexVolume {
 		const points = [];
 		for (let i = 0; i < 8; i++) {
 			const p = [...center];
-			add(p, p, scale$2([], axisX, (i >> 0 & 1) === 1 ? 1 : -1));
-			add(p, p, scale$2([], axisY, (i >> 1 & 1) === 1 ? 1 : -1));
-			add(p, p, scale$2([], axisZ, (i >> 2 & 1) === 1 ? 1 : -1));
+			add(p, p, scale$1([], axisX, (i >> 0 & 1) === 1 ? 1 : -1));
+			add(p, p, scale$1([], axisY, (i >> 1 & 1) === 1 ? 1 : -1));
+			add(p, p, scale$1([], axisZ, (i >> 2 & 1) === 1 ? 1 : -1));
 			points.push(p);
 		}
 		return new ConvexVolume(points, [
@@ -12685,6 +12850,11 @@ var GlobeCoveringTilesDetailsProvider = class {
 	getTileBoundingVolume(tileID, wrap, elevation, options) {
 		return this._boundingVolumeCache.getTileBoundingVolume(tileID, wrap, elevation, options);
 	}
+	/**
+	* Computes the bounding volume of a tile for culling. The volume reaches up to `elevation`,
+	* which carries the content elevation allowance (e.g. elevated symbols); terrain elevations
+	* widen the volume but never shrink that allowance.
+	*/
 	_computeTileBoundingVolume(tileID, wrap, elevation, options) {
 		let minElevation = Math.min(0, elevation);
 		let maxElevation = Math.max(0, elevation);
@@ -12692,7 +12862,7 @@ var GlobeCoveringTilesDetailsProvider = class {
 			const overscaledTileID = new OverscaledTileID(tileID.z, wrap, tileID.z, tileID.x, tileID.y);
 			const minMax = options.terrain.getMinMaxElevation(overscaledTileID);
 			minElevation = minMax.minElevation ?? minElevation;
-			maxElevation = minMax.maxElevation ?? maxElevation;
+			maxElevation = Math.max(minMax.maxElevation ?? maxElevation, maxElevation);
 		}
 		minElevation /= earthRadius;
 		maxElevation /= earthRadius;
@@ -12724,8 +12894,8 @@ var GlobeCoveringTilesDetailsProvider = class {
 				projectTileCoordinatesToSphere(0, EXTENT, tileID.x, tileID.y, tileID.z)
 			];
 			const extremesPoints = [];
-			for (const c of corners) extremesPoints.push(scale$2([], c, maxElevation));
-			if (maxElevation !== minElevation) for (const c of corners) extremesPoints.push(scale$2([], c, minElevation));
+			for (const c of corners) extremesPoints.push(scale$1([], c, maxElevation));
+			if (maxElevation !== minElevation) for (const c of corners) extremesPoints.push(scale$1([], c, minElevation));
 			if (tileID.y === 0) extremesPoints.push([
 				0,
 				1,
@@ -12763,9 +12933,9 @@ var GlobeCoveringTilesDetailsProvider = class {
 			normalize(axisEast, axisEast);
 			const axisWest = cross([], corners[0], corners[3]);
 			normalize(axisWest, axisWest);
-			extremesPoints.push(scale$2([], center, maxElevation));
-			if (tileID.y >= (1 << tileID.z) / 2) extremesPoints.push(scale$2([], projectTileCoordinatesToSphere(EXTENT / 2, 0, tileID.x, tileID.y, tileID.z), maxElevation));
-			if (tileID.y < (1 << tileID.z) / 2) extremesPoints.push(scale$2([], projectTileCoordinatesToSphere(EXTENT / 2, EXTENT, tileID.x, tileID.y, tileID.z), maxElevation));
+			extremesPoints.push(scale$1([], center, maxElevation));
+			if (tileID.y >= (1 << tileID.z) / 2) extremesPoints.push(scale$1([], projectTileCoordinatesToSphere(EXTENT / 2, 0, tileID.x, tileID.y, tileID.z), maxElevation));
+			if (tileID.y < (1 << tileID.z) / 2) extremesPoints.push(scale$1([], projectTileCoordinatesToSphere(EXTENT / 2, EXTENT, tileID.x, tileID.y, tileID.z), maxElevation));
 			const upDownMinMax = findAxisMinMax(center, extremesPoints);
 			const northSouthMinMax = findAxisMinMax(north, extremesPoints);
 			const planeUp = [
@@ -12829,6 +12999,10 @@ const GLOBE_SAMPLES = 256;
 const GLOBE_BISECT_EPSILON_T = 1e-12;
 /** Latitudes outside the mercator range project past the world edge; the globe mesh still covers them. */
 const MAX_MERCATOR_Y = 1 - 1e-9;
+/** Two points on the unit globe closer than this, a micrometre, are the same point. */
+const SAME_POINT_DISTANCE = 1e-12;
+/** A camera whose horizontal offset is this small relative to its distance is straight above the center. */
+const STRAIGHT_ABOVE_RATIO = 1e-9;
 var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 	get pixelsToClipSpaceMatrix() {
 		return this._helper.pixelsToClipSpaceMatrix;
@@ -13115,8 +13289,8 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 			0,
 			0
 		], this.center.lng * Math.PI / 180);
-		const scale = 1 / length$1(planeVector);
-		scale$2(planeVector, planeVector, scale);
+		const scale = 1 / length(planeVector);
+		scale$1(planeVector, planeVector, scale);
 		return [...planeVector, -tangentPlaneDistanceToC * scale];
 	}
 	isLocationOccluded(location) {
@@ -13172,21 +13346,43 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 		const canonical = unwrappedTileID.canonical;
 		const spherePos = projectTileCoordinatesToSphere(x, y, canonical.x, canonical.y, canonical.z);
 		const vectorMultiplier = 1 + (elevation ?? 0) / earthRadius;
+		const elevatedX = spherePos[0] * vectorMultiplier;
+		const elevatedY = spherePos[1] * vectorMultiplier;
+		const elevatedZ = spherePos[2] * vectorMultiplier;
 		const pos = [
-			spherePos[0] * vectorMultiplier,
-			spherePos[1] * vectorMultiplier,
-			spherePos[2] * vectorMultiplier,
+			elevatedX,
+			elevatedY,
+			elevatedZ,
 			1
 		];
 		transformMat4(pos, pos, this._globeViewProjMatrixF64);
-		const plane = this._cachedClippingPlane;
-		const isOccluded = plane[0] * spherePos[0] + plane[1] * spherePos[1] + plane[2] * spherePos[2] + plane[3] < 0;
+		let isOccluded;
+		if (vectorMultiplier <= 1) {
+			const plane = this._cachedClippingPlane;
+			isOccluded = plane[0] * spherePos[0] + plane[1] * spherePos[1] + plane[2] * spherePos[2] + plane[3] < 0;
+		} else isOccluded = this._isLineOfSightBlocked(elevatedX, elevatedY, elevatedZ);
 		return {
 			point: new Point(pos[0] / pos[3], pos[1] / pos[3]),
 			signedDistanceFromCamera: pos[3],
 			isOccluded
 		};
 	}
+	/**
+	* True when the segment from the camera to the given point, both in unit-globe coordinates, passes through the planet.
+	*/
+	_isLineOfSightBlocked(x, y, z) {
+		const cam = this._cameraPosition;
+		const dx = x - cam[0];
+		const dy = y - cam[1];
+		const dz = z - cam[2];
+		const lengthSq = dx * dx + dy * dy + dz * dz;
+		if (lengthSq === 0) return false;
+		const t = clamp(-(cam[0] * dx + cam[1] * dy + cam[2] * dz) / lengthSq, 0, 1);
+		const cx = cam[0] + t * dx;
+		const cy = cam[1] + t * dy;
+		const cz = cam[2] + t * dz;
+		return cx * cx + cy * cy + cz * cz < 1;
+	}
 	_calcMatrices() {
 		if (!this._helper._width || !this._helper._height) return;
 		const globeRadiusPixels = getGlobeRadiusPixels(this.worldSize, this.center.lat);
@@ -13279,16 +13475,22 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 	getCameraPoint() {
 		return this._helper.getCameraPoint();
 	}
+	/**
+	* The altitude of the rendered camera above sea level. The sphere keeps the center point at sea level whatever its
+	* elevation (`_calcMatrices` does not apply it), so unlike on mercator the center elevation does not lift the camera.
+	* {@link calculateCameraOptionsFromTo} is the inverse.
+	*/
 	getCameraAltitude() {
-		return this._helper.getCameraAltitude();
+		return (length(this._cameraPosition) - 1) * earthRadius;
 	}
 	getCameraLngLat() {
-		return this._helper.getCameraLngLat();
+		const surface = createVec3f64();
+		normalize(surface, this._cameraPosition);
+		return sphereSurfacePointToCoordinates(surface);
 	}
 	lngLatToCameraDepth(lngLat, elevation) {
-		if (!this._globeViewProjMatrixF64) return 1;
 		const vec = angularCoordinatesToSurfaceVector(lngLat);
-		scale$2(vec, vec, 1 + elevation / earthRadius);
+		scale$1(vec, vec, 1 + elevation / earthRadius);
 		const result = createVec4f64();
 		transformMat4(result, [
 			vec[0],
@@ -13354,6 +13556,34 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 		return this._helper.calculateCenterFromCameraLngLatAlt(lngLat, alt, bearing, pitch);
 	}
 	/**
+	* Inverts the camera placement of `_calcMatrices` in unit-globe coordinates: the camera sits at radius
+	* `1 + altitudeFrom / earthRadius` and looks at the center on the sea-level sphere, the target altitude only becoming
+	* the center elevation (the inverse of {@link getCameraAltitude}). Pitch and bearing are read in the center's local
+	* frame, +z up, +y north, +x east. A camera straight above the center keeps the transform's bearing.
+	*/
+	calculateCameraOptionsFromTo(from, altitudeFrom, to, altitudeTo) {
+		const center = LngLat.convert(to);
+		const camera = angularCoordinatesToSurfaceVector(LngLat.convert(from));
+		scale$1(camera, camera, 1 + altitudeFrom / earthRadius);
+		const target = angularCoordinatesToSurfaceVector(center);
+		const targetAtAltitude = scale$1(createVec3f64(), target, 1 + altitudeTo / earthRadius);
+		const toCamera = subtract(createVec3f64(), camera, target);
+		const distance$1 = length(toCamera);
+		if (distance$1 < SAME_POINT_DISTANCE || distance(camera, targetAtAltitude) < SAME_POINT_DISTANCE) throw new Error("Can't calculate camera options with same From and To");
+		const zero = createVec3f64();
+		rotateY(toCamera, toCamera, zero, -degreesToRadians(center.lng));
+		rotateX$1(toCamera, toCamera, zero, degreesToRadians(center.lat));
+		const pitch = radiansToDegrees(Math.acos(clamp(toCamera[2] / distance$1, -1, 1)));
+		const bearing = Math.hypot(toCamera[0], toCamera[1]) < distance$1 * STRAIGHT_ABOVE_RATIO ? this.bearing : radiansToDegrees(Math.atan2(-toCamera[0], -toCamera[1]));
+		return {
+			center,
+			elevation: altitudeTo,
+			zoom: scaleZoom(this.cameraToCenterDistance / distance$1 / getGlobeRadiusPixels(this.tileSize, center.lat)),
+			pitch,
+			bearing
+		};
+	}
+	/**
 	* Note: automatically adjusts zoom to keep planet size consistent
 	* (same size before and after a {@link setLocationAtPoint} call).
 	*/
@@ -13414,7 +13644,7 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 		const pos = angularCoordinatesToSurfaceVector(lnglat);
 		if (terrain) {
 			const elevation = terrain.getElevationForLngLatZoom(lnglat, this._helper._tileZoom);
-			scale$2(pos, pos, 1 + elevation / earthRadius);
+			scale$1(pos, pos, 1 + elevation / earthRadius);
 		}
 		return this._projectSurfacePointToScreen(pos);
 	}
@@ -13586,9 +13816,9 @@ var VerticalPerspectiveTransform = class VerticalPerspectiveTransform {
 function globeSampleAt(ray, t) {
 	const position = createVec3f64();
 	scaleAndAdd(position, ray.origin, ray.direction, t);
-	const radius = length$1(position);
+	const radius = length(position);
 	const surface = createVec3f64();
-	scale$2(surface, position, 1 / radius);
+	scale$1(surface, position, 1 / radius);
 	const lngLat = sphereSurfacePointToCoordinates(surface);
 	const projected = MercatorCoordinate.fromLngLat(lngLat);
 	const mercator = new MercatorCoordinate(projected.x, clamp(projected.y, 0, MAX_MERCATOR_Y));
@@ -13925,11 +14155,13 @@ var GlobeTransform = class GlobeTransform {
 	getCameraPoint() {
 		return this._helper.getCameraPoint();
 	}
+	/** The camera of the child that renders the current frame. */
 	getCameraAltitude() {
-		return this._helper.getCameraAltitude();
+		return this.currentTransform.getCameraAltitude();
 	}
+	/** See {@link getCameraAltitude}. */
 	getCameraLngLat() {
-		return this._helper.getCameraLngLat();
+		return this.currentTransform.getCameraLngLat();
 	}
 	lngLatToCameraDepth(lngLat, elevation) {
 		return this.currentTransform.lngLatToCameraDepth(lngLat, elevation);
@@ -13944,6 +14176,10 @@ var GlobeTransform = class GlobeTransform {
 	calculateCenterFromCameraLngLatAlt(lngLat, alt, bearing, pitch) {
 		return this._helper.calculateCenterFromCameraLngLatAlt(lngLat, alt, bearing, pitch);
 	}
+	/** See {@link getCameraAltitude}. */
+	calculateCameraOptionsFromTo(from, altitudeFrom, to, altitudeTo) {
+		return this.currentTransform.calculateCameraOptionsFromTo(from, altitudeFrom, to, altitudeTo);
+	}
 	/**
 	* Note: automatically adjusts zoom to keep planet size consistent
 	* (same size before and after a {@link setLocationAtPoint} call).
@@ -14069,7 +14305,7 @@ var VerticalPerspectiveCameraHelper = class VerticalPerspectiveCameraHelper {
 			rayDirection[1] * distanceToClosestPoint,
 			rayDirection[2] * distanceToClosestPoint
 		]);
-		const rayDistanceFromGlobeCenter = length$1(closestPoint);
+		const rayDistanceFromGlobeCenter = length(closestPoint);
 		const distanceFromSurface = rayDistanceFromGlobeCenter - 1;
 		const distanceFactor = Math.exp(-Math.max(distanceFromSurface - RAY_SURFACE_DISTANCE_FOR_SLOWING_START, 0) * SLOWING_MULTIPLIER);
 		const interpolationFactorHorizon = remapSaturate(rayDistanceFromGlobeCenter, INTERPOLATE_TO_HEURISTIC_START_HORIZON, INTERPOLATE_TO_HEURISTIC_END_HORIZON, 0, 1);
@@ -15026,13 +15262,13 @@ var Style = class extends Evented {
 			return;
 		}
 		if (id === before) return;
-		const index = this._order.indexOf(id);
-		this._order.splice(index, 1);
-		const newIndex = before ? this._order.indexOf(before) : this._order.length;
-		if (before && newIndex === -1) {
+		if (before && !this._order.includes(before)) {
 			this.fire(new ErrorEvent(/* @__PURE__ */ new Error(`Cannot move layer "${id}" before non-existing layer "${before}".`)));
 			return;
 		}
+		const index = this._order.indexOf(id);
+		this._order.splice(index, 1);
+		const newIndex = before ? this._order.indexOf(before) : this._order.length;
 		this._order.splice(newIndex, 0, id);
 		this._layerOrderChanged = true;
 	}
@@ -15059,6 +15295,7 @@ var Style = class extends Evented {
 		if (this._serializedLayers) delete this._serializedLayers[id];
 		delete this._updatedLayers[id];
 		delete this._updatedPaintProps[id];
+		if (layer.type === "symbol" && layer.source) this.tileManagers[layer.source]?.resetMaxContentElevation();
 		if (layer.onRemove) layer.onRemove(this.map);
 	}
 	/**
@@ -15774,11 +16011,7 @@ var VertexArrayObject = class {
 //#region src/webgl/program/terrain_program.ts
 const terrainPreludeUniforms = (context, locations) => ({
 	"u_depth": new Uniform1i(context, locations.u_depth),
-	"u_terrain": new Uniform1i(context, locations.u_terrain),
-	"u_terrain_dim": new Uniform1f(context, locations.u_terrain_dim),
-	"u_terrain_matrix": new UniformMatrix4f(context, locations.u_terrain_matrix),
-	"u_terrain_unpack": new Uniform4f(context, locations.u_terrain_unpack),
-	"u_terrain_exaggeration": new Uniform1f(context, locations.u_terrain_exaggeration)
+	"u_terrain": new Uniform1i(context, locations.u_terrain)
 });
 const terrainUniforms = (context, locations) => ({
 	"u_texture": new Uniform1i(context, locations.u_texture),
@@ -15805,26 +16038,173 @@ const terrainUniformValues = (eleDelta, fogMatrix, sky, pitch, isGlobeMode) => (
 });
 const terrainDepthUniformValues = (eleDelta) => ({ "u_ele_delta": eleDelta });
 //#endregion
-//#region src/webgl/program/projection_program.ts
-const projectionUniforms = (context, locations) => ({
-	"u_projection_matrix": new UniformMatrix4f(context, locations.u_projection_matrix),
-	"u_projection_tile_mercator_coords": new Uniform4f(context, locations.u_projection_tile_mercator_coords),
-	"u_projection_clipping_plane": new Uniform4f(context, locations.u_projection_clipping_plane),
-	"u_projection_transition": new Uniform1f(context, locations.u_projection_transition),
-	"u_projection_fallback_matrix": new UniformMatrix4f(context, locations.u_projection_fallback_matrix),
-	"u_projection_clip_antimeridian": new Uniform1i(context, locations.u_projection_clip_antimeridian)
-});
+//#region src/webgl/uniform_buffer.ts
+const UBO_BINDINGS = {
+	ProjectionUBO: 0,
+	TerrainUBO: 1,
+	FrameUBO: 2
+};
+function applyUBOBindings(gl, program) {
+	for (const [name, binding] of Object.entries(UBO_BINDINGS)) {
+		const index = gl.getUniformBlockIndex(program, name);
+		if (index !== gl.INVALID_INDEX) gl.uniformBlockBinding(program, index, binding);
+	}
+}
+const STD140_SIZE_AND_ALIGNMENT_WORDS = {
+	float: [1, 1],
+	int: [1, 1],
+	vec2: [2, 2],
+	vec4: [4, 4],
+	mat4: [16, 4]
+};
+function std140Layout(members) {
+	const offsets = {};
+	let words = 0;
+	for (const { name, type } of members) {
+		const [size, alignment] = STD140_SIZE_AND_ALIGNMENT_WORDS[type];
+		words = Math.ceil(words / alignment) * alignment;
+		offsets[name] = words;
+		words += size;
+	}
+	return {
+		offsets,
+		contentWords: words,
+		sizeWords: Math.ceil(words / 4) * 4
+	};
+}
 /**
-* Converts a {@link ProjectionData} object into the values expected by the projection prelude's uniforms.
+* @internal
+* The buffer behind one std140 uniform block, bound to a fixed binding point. Callers write members into
+* `pending` at the layout's offsets and call `upload`, which skips the GPU write when nothing changed.
 */
-const projectionUniformValues = (projectionData) => ({
-	"u_projection_matrix": projectionData.mainMatrix,
-	"u_projection_tile_mercator_coords": projectionData.tileMercatorCoords,
-	"u_projection_clipping_plane": projectionData.clippingPlane,
-	"u_projection_transition": projectionData.projectionTransition,
-	"u_projection_fallback_matrix": projectionData.fallbackMatrix,
-	"u_projection_clip_antimeridian": projectionData.clipAntimeridian ? 1 : 0
-});
+var UniformBuffer = class {
+	constructor(context, binding, layout) {
+		this.context = context;
+		this.binding = binding;
+		this.contentWords = layout.contentWords;
+		const gl = context.gl;
+		this.buffer = gl.createBuffer();
+		gl.bindBuffer(gl.UNIFORM_BUFFER, this.buffer);
+		gl.bufferData(gl.UNIFORM_BUFFER, layout.sizeWords * 4, gl.DYNAMIC_DRAW);
+		gl.bindBufferBase(gl.UNIFORM_BUFFER, binding, this.buffer);
+		this.uploaded = new Float32Array(layout.sizeWords);
+		this.pending = new Float32Array(layout.sizeWords);
+		this.uploadedWords = new Uint32Array(this.uploaded.buffer);
+		this.pendingWords = new Uint32Array(this.pending.buffer);
+		this.hasData = false;
+		this.bindingDirty = false;
+	}
+	upload() {
+		const gl = this.context.gl;
+		let changed = !this.hasData;
+		if (!changed) {
+			const words = this.pendingWords;
+			const uploadedWords = this.uploadedWords;
+			for (let i = 0; i < this.contentWords; i++) if (words[i] !== uploadedWords[i]) {
+				changed = true;
+				break;
+			}
+		}
+		if (this.bindingDirty) {
+			gl.bindBufferBase(gl.UNIFORM_BUFFER, this.binding, this.buffer);
+			this.bindingDirty = false;
+		}
+		if (!changed) return;
+		gl.bindBuffer(gl.UNIFORM_BUFFER, this.buffer);
+		gl.bufferSubData(gl.UNIFORM_BUFFER, 0, this.pending);
+		this.uploaded.set(this.pending);
+		this.hasData = true;
+	}
+	destroy() {
+		const gl = this.context.gl;
+		if (this.buffer) {
+			gl.deleteBuffer(this.buffer);
+			delete this.buffer;
+		}
+	}
+};
+//#endregion
+//#region src/webgl/projection_uniform_buffer.ts
+const layout$2 = std140Layout([
+	{
+		name: "u_projection_matrix",
+		type: "mat4"
+	},
+	{
+		name: "u_projection_fallback_matrix",
+		type: "mat4"
+	},
+	{
+		name: "u_projection_tile_mercator_coords",
+		type: "vec4"
+	},
+	{
+		name: "u_projection_clipping_plane",
+		type: "vec4"
+	},
+	{
+		name: "u_projection_transition",
+		type: "float"
+	},
+	{
+		name: "u_projection_clip_antimeridian",
+		type: "int"
+	}
+]);
+const offsets$2 = layout$2.offsets;
+/**
+* @internal
+* The buffer behind the `ProjectionUBO` block in the shader preludes, written by `Program.draw` before each draw.
+*/
+function createProjectionUniformBuffer(context) {
+	return new UniformBuffer(context, UBO_BINDINGS.ProjectionUBO, layout$2);
+}
+function updateProjectionUniformBuffer(buffer, projectionData) {
+	const f32 = buffer.pending;
+	f32.set(projectionData.mainMatrix, offsets$2.u_projection_matrix);
+	f32.set(projectionData.fallbackMatrix, offsets$2.u_projection_fallback_matrix);
+	f32.set(projectionData.tileMercatorCoords, offsets$2.u_projection_tile_mercator_coords);
+	f32.set(projectionData.clippingPlane, offsets$2.u_projection_clipping_plane);
+	f32[offsets$2.u_projection_transition] = projectionData.projectionTransition;
+	buffer.pendingWords[offsets$2.u_projection_clip_antimeridian] = projectionData.clipAntimeridian ? 1 : 0;
+	buffer.upload();
+}
+//#endregion
+//#region src/webgl/terrain_uniform_buffer.ts
+const layout$1 = std140Layout([
+	{
+		name: "u_terrain_matrix",
+		type: "mat4"
+	},
+	{
+		name: "u_terrain_unpack",
+		type: "vec4"
+	},
+	{
+		name: "u_terrain_dim",
+		type: "float"
+	},
+	{
+		name: "u_terrain_exaggeration",
+		type: "float"
+	}
+]);
+const offsets$1 = layout$1.offsets;
+/**
+* @internal
+* The buffer behind the `TerrainUBO` block in the vertex prelude, written by `Program.draw` for every draw with terrain.
+*/
+function createTerrainUniformBuffer(context) {
+	return new UniformBuffer(context, UBO_BINDINGS.TerrainUBO, layout$1);
+}
+function updateTerrainUniformBuffer(buffer, terrain) {
+	const f32 = buffer.pending;
+	f32.set(terrain.u_terrain_matrix, offsets$1.u_terrain_matrix);
+	f32.set(terrain.u_terrain_unpack, offsets$1.u_terrain_unpack);
+	f32[offsets$1.u_terrain_dim] = terrain.u_terrain_dim;
+	f32[offsets$1.u_terrain_exaggeration] = terrain.u_terrain_exaggeration;
+	buffer.upload();
+}
 //#endregion
 //#region src/webgl/program.ts
 function getTokenizedAttributesAndUniforms(array) {
@@ -15867,10 +16247,9 @@ var Program = class {
 		const dynamicAttrInfo = configuration ? configuration.getBinderAttributes() : [];
 		const allAttrInfo = staticAttrInfo.concat(dynamicAttrInfo);
 		const preludeUniformsInfo = shaders.prelude.staticUniforms ? getTokenizedAttributesAndUniforms(shaders.prelude.staticUniforms) : [];
-		const projectionPreludeUniformsInfo = projectionPrelude.staticUniforms ? getTokenizedAttributesAndUniforms(projectionPrelude.staticUniforms) : [];
 		const staticUniformsInfo = source.staticUniforms ? getTokenizedAttributesAndUniforms(source.staticUniforms) : [];
 		const dynamicUniformsInfo = configuration ? configuration.getBinderUniforms() : [];
-		const uniformList = preludeUniformsInfo.concat(projectionPreludeUniformsInfo).concat(staticUniformsInfo).concat(dynamicUniformsInfo);
+		const uniformList = preludeUniformsInfo.concat(staticUniformsInfo).concat(dynamicUniformsInfo);
 		const allUniformsInfo = [];
 		for (const uniform of uniformList) if (!allUniformsInfo.includes(uniform)) allUniformsInfo.push(uniform);
 		const defines = configuration ? configuration.defines() : [];
@@ -15888,7 +16267,6 @@ var Program = class {
 		}
 		gl.shaderSource(fragmentShader, fragmentSource);
 		gl.compileShader(fragmentShader);
-		if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) throw new Error(`Could not compile fragment shader: ${gl.getShaderInfoLog(fragmentShader)}`);
 		gl.attachShader(this.program, fragmentShader);
 		const vertexShader = gl.createShader(gl.VERTEX_SHADER);
 		if (gl.isContextLost()) {
@@ -15897,13 +16275,21 @@ var Program = class {
 		}
 		gl.shaderSource(vertexShader, vertexSource);
 		gl.compileShader(vertexShader);
-		if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) throw new Error(`Could not compile vertex shader: ${gl.getShaderInfoLog(vertexShader)}`);
 		gl.attachShader(this.program, vertexShader);
 		this.attributes = {};
 		const uniformLocations = {};
 		this.numAttributes = allAttrInfo.length;
 		gl.linkProgram(this.program);
-		if (!gl.getProgramParameter(this.program, gl.LINK_STATUS)) throw new Error(`Program failed to link: ${gl.getProgramInfoLog(this.program)}`);
+		if (!gl.getProgramParameter(this.program, gl.LINK_STATUS)) {
+			if (gl.isContextLost()) {
+				this.failedToCreate = true;
+				return;
+			}
+			if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) throw new Error(`Could not compile fragment shader: ${gl.getShaderInfoLog(fragmentShader)}`);
+			if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) throw new Error(`Could not compile vertex shader: ${gl.getShaderInfoLog(vertexShader)}`);
+			throw new Error(`Program failed to link: ${gl.getProgramInfoLog(this.program)}`);
+		}
+		applyUBOBindings(gl, this.program);
 		const integerAttributeNames = getIntegerAttributeNames(gl, this.program);
 		for (const name of allAttrInfo) {
 			if (!name) continue;
@@ -15921,7 +16307,6 @@ var Program = class {
 		}
 		this.fixedUniforms = fixedUniforms(context, uniformLocations);
 		this.terrainUniforms = terrainPreludeUniforms(context, uniformLocations);
-		this.projectionUniforms = projectionUniforms(context, uniformLocations);
 		this.binderUniforms = configuration ? configuration.getUniforms(context, uniformLocations) : [];
 	}
 	draw(context, drawMode, depthMode, stencilMode, colorMode, cullFaceMode, uniformValues, terrain, projectionData, layerID, layoutVertexBuffer, indexBuffer, segments, currentProperties, zoom, configuration, dynamicLayoutBuffer, dynamicLayoutBuffer2, dynamicLayoutBuffer3) {
@@ -15938,11 +16323,9 @@ var Program = class {
 			context.activeTexture.set(gl.TEXTURE3);
 			gl.bindTexture(gl.TEXTURE_2D, terrain.texture);
 			for (const name in this.terrainUniforms) this.terrainUniforms[name].set(terrain[name]);
+			updateTerrainUniformBuffer(context.terrainUniformBuffer, terrain);
 		}
-		if (projectionData) {
-			const values = projectionUniformValues(projectionData);
-			for (const name in this.projectionUniforms) this.projectionUniforms[name].set(values[name]);
-		}
+		if (projectionData) updateProjectionUniformBuffer(context.projectionUniformBuffer, projectionData);
 		if (uniformValues) for (const name in this.fixedUniforms) this.fixedUniforms[name].set(uniformValues[name]);
 		if (configuration) configuration.setUniforms(context, this.binderUniforms, currentProperties, { zoom });
 		let primitiveSize = 0;
@@ -16071,37 +16454,33 @@ const fillPatternUniforms = (context, locations) => ({
 	"u_pixel_coord_lower": new Uniform2f(context, locations.u_pixel_coord_lower),
 	"u_scale": new Uniform3f(context, locations.u_scale),
 	"u_fade": new Uniform1f(context, locations.u_fade),
+	"u_sdf_pattern": new Uniform1i(context, locations.u_sdf_pattern),
 	"u_fill_translate": new Uniform2f(context, locations.u_fill_translate)
 });
-const fillOutlineUniforms = (context, locations) => ({
-	"u_world": new Uniform2f(context, locations.u_world),
-	"u_fill_translate": new Uniform2f(context, locations.u_fill_translate)
-});
+const fillOutlineUniforms = (context, locations) => ({ "u_fill_translate": new Uniform2f(context, locations.u_fill_translate) });
 const fillOutlinePatternUniforms = (context, locations) => ({
-	"u_world": new Uniform2f(context, locations.u_world),
 	"u_image": new Uniform1i(context, locations.u_image),
 	"u_texsize": new Uniform2f(context, locations.u_texsize),
 	"u_pixel_coord_upper": new Uniform2f(context, locations.u_pixel_coord_upper),
 	"u_pixel_coord_lower": new Uniform2f(context, locations.u_pixel_coord_lower),
 	"u_scale": new Uniform3f(context, locations.u_scale),
 	"u_fade": new Uniform1f(context, locations.u_fade),
+	"u_sdf_pattern": new Uniform1i(context, locations.u_sdf_pattern),
 	"u_fill_translate": new Uniform2f(context, locations.u_fill_translate)
 });
-const fillPatternUniformValues = (painter, crossfade, tile, translate) => extend(patternUniformValues(crossfade, painter, tile), { "u_fill_translate": translate });
-const fillUniformValues = (translate) => ({ "u_fill_translate": translate });
-const fillOutlineUniformValues = (drawingBufferSize, translate) => ({
-	"u_world": drawingBufferSize,
-	"u_fill_translate": translate
+const fillPatternUniformValues = (painter, crossfade, tile, translate, isSdfPattern) => extend(patternUniformValues(crossfade, painter, tile), {
+	"u_fill_translate": translate,
+	"u_sdf_pattern": isSdfPattern ? 1 : 0
 });
-const fillOutlinePatternUniformValues = (painter, crossfade, tile, drawingBufferSize, translate) => extend(fillPatternUniformValues(painter, crossfade, tile, translate), { "u_world": drawingBufferSize });
+const fillUniformValues = (translate) => ({ "u_fill_translate": translate });
+const fillOutlineUniformValues = (translate) => ({ "u_fill_translate": translate });
+const fillOutlinePatternUniformValues = (painter, crossfade, tile, translate, isSdfPattern) => fillPatternUniformValues(painter, crossfade, tile, translate, isSdfPattern);
 //#endregion
 //#region src/webgl/program/circle_program.ts
 const circleUniforms = (context, locations) => ({
-	"u_camera_to_center_distance": new Uniform1f(context, locations.u_camera_to_center_distance),
 	"u_scale_with_map": new Uniform1i(context, locations.u_scale_with_map),
 	"u_pitch_with_map": new Uniform1i(context, locations.u_pitch_with_map),
 	"u_extrude_scale": new Uniform2f(context, locations.u_extrude_scale),
-	"u_device_pixel_ratio": new Uniform1f(context, locations.u_device_pixel_ratio),
 	"u_globe_extrude_scale": new Uniform1f(context, locations.u_globe_extrude_scale),
 	"u_translate": new Uniform2f(context, locations.u_translate)
 });
@@ -16119,26 +16498,14 @@ const circleUniformValues = (painter, tile, layer, translate, radiusCorrectionFa
 		extrudeScale = transform.pixelsToGLUnits;
 	}
 	return {
-		"u_camera_to_center_distance": transform.cameraToCenterDistance,
 		"u_scale_with_map": +(layer.paint.get("circle-pitch-scale") === "map"),
 		"u_pitch_with_map": +pitchWithMap,
-		"u_device_pixel_ratio": painter.pixelRatio,
 		"u_extrude_scale": extrudeScale,
 		"u_globe_extrude_scale": globeExtrudeScale,
 		"u_translate": translate
 	};
 };
 //#endregion
-//#region src/webgl/program/collision_program.ts
-const collisionUniforms = (context, locations) => ({ "u_pixel_extrude_scale": new Uniform2f(context, locations.u_pixel_extrude_scale) });
-const collisionCircleUniforms = (context, locations) => ({ "u_viewport_size": new Uniform2f(context, locations.u_viewport_size) });
-const collisionUniformValues = (transform) => {
-	return { "u_pixel_extrude_scale": [1 / transform.width, 1 / transform.height] };
-};
-const collisionCircleUniformValues = (transform) => {
-	return { "u_viewport_size": [transform.width, transform.height] };
-};
-//#endregion
 //#region src/webgl/program/debug_program.ts
 const debugUniforms = (context, locations) => ({
 	"u_color": new UniformColor(context, locations.u_color),
@@ -16159,7 +16526,6 @@ const heatmapUniforms = (context, locations) => ({
 });
 const heatmapTextureUniforms = (context, locations) => ({
 	"u_matrix": new UniformMatrix4f(context, locations.u_matrix),
-	"u_world": new Uniform2f(context, locations.u_world),
 	"u_image": new Uniform1i(context, locations.u_image),
 	"u_color_ramp": new Uniform1i(context, locations.u_color_ramp),
 	"u_opacity": new Uniform1f(context, locations.u_opacity)
@@ -16175,10 +16541,8 @@ const heatmapUniformValues = (tile, zoom, intensity, radiusCorrectionFactor) =>
 const heatmapTextureUniformValues = (painter, layer, textureUnit, colorRampUnit) => {
 	const matrix = create$1();
 	ortho(matrix, 0, painter.width, painter.height, 0, 0, 1);
-	const gl = painter.context.gl;
 	return {
 		"u_matrix": matrix,
-		"u_world": [gl.drawingBufferWidth, gl.drawingBufferHeight],
 		"u_image": textureUnit,
 		"u_color_ramp": colorRampUnit,
 		"u_opacity": layer.paint.get("heatmap-opacity")
@@ -16284,15 +16648,11 @@ const colorReliefUniformValues = (layer, dem, colorRampSize = 0) => {
 //#region src/webgl/program/line_program.ts
 const lineUniforms = (context, locations) => ({
 	"u_translation": new Uniform2f(context, locations.u_translation),
-	"u_ratio": new Uniform1f(context, locations.u_ratio),
-	"u_device_pixel_ratio": new Uniform1f(context, locations.u_device_pixel_ratio),
-	"u_units_to_pixels": new Uniform2f(context, locations.u_units_to_pixels)
+	"u_ratio": new Uniform1f(context, locations.u_ratio)
 });
 const lineGradientUniforms = (context, locations) => ({
 	"u_translation": new Uniform2f(context, locations.u_translation),
 	"u_ratio": new Uniform1f(context, locations.u_ratio),
-	"u_device_pixel_ratio": new Uniform1f(context, locations.u_device_pixel_ratio),
-	"u_units_to_pixels": new Uniform2f(context, locations.u_units_to_pixels),
 	"u_image": new Uniform1i(context, locations.u_image),
 	"u_image_height": new Uniform1f(context, locations.u_image_height)
 });
@@ -16300,17 +16660,13 @@ const linePatternUniforms = (context, locations) => ({
 	"u_translation": new Uniform2f(context, locations.u_translation),
 	"u_texsize": new Uniform2f(context, locations.u_texsize),
 	"u_ratio": new Uniform1f(context, locations.u_ratio),
-	"u_device_pixel_ratio": new Uniform1f(context, locations.u_device_pixel_ratio),
 	"u_image": new Uniform1i(context, locations.u_image),
-	"u_units_to_pixels": new Uniform2f(context, locations.u_units_to_pixels),
 	"u_scale": new Uniform3f(context, locations.u_scale),
 	"u_fade": new Uniform1f(context, locations.u_fade)
 });
 const lineSDFUniforms = (context, locations) => ({
 	"u_translation": new Uniform2f(context, locations.u_translation),
 	"u_ratio": new Uniform1f(context, locations.u_ratio),
-	"u_device_pixel_ratio": new Uniform1f(context, locations.u_device_pixel_ratio),
-	"u_units_to_pixels": new Uniform2f(context, locations.u_units_to_pixels),
 	"u_image": new Uniform1i(context, locations.u_image),
 	"u_mix": new Uniform1f(context, locations.u_mix),
 	"u_tileratio": new Uniform1f(context, locations.u_tileratio),
@@ -16322,8 +16678,6 @@ const lineSDFUniforms = (context, locations) => ({
 const lineGradientSDFUniforms = (context, locations) => ({
 	"u_translation": new Uniform2f(context, locations.u_translation),
 	"u_ratio": new Uniform1f(context, locations.u_ratio),
-	"u_device_pixel_ratio": new Uniform1f(context, locations.u_device_pixel_ratio),
-	"u_units_to_pixels": new Uniform2f(context, locations.u_units_to_pixels),
 	"u_image": new Uniform1i(context, locations.u_image),
 	"u_image_height": new Uniform1f(context, locations.u_image_height),
 	"u_tileratio": new Uniform1f(context, locations.u_tileratio),
@@ -16338,9 +16692,7 @@ const lineUniformValues = (painter, tile, layer, ratioScale) => {
 	const transform = painter.transform;
 	return {
 		"u_translation": calculateTranslation(painter, tile, layer),
-		"u_ratio": ratioScale / pixelsToTileUnits(tile, 1, transform.zoom),
-		"u_device_pixel_ratio": painter.pixelRatio,
-		"u_units_to_pixels": [1 / transform.pixelsToGLUnits[0], 1 / transform.pixelsToGLUnits[1]]
+		"u_ratio": ratioScale / pixelsToTileUnits(tile, 1, transform.zoom)
 	};
 };
 const lineGradientUniformValues = (painter, tile, layer, ratioScale, imageHeight) => {
@@ -16356,15 +16708,13 @@ const linePatternUniformValues = (painter, tile, layer, ratioScale, crossfade) =
 		"u_translation": calculateTranslation(painter, tile, layer),
 		"u_texsize": tile.imageAtlasTexture.size,
 		"u_ratio": ratioScale / pixelsToTileUnits(tile, 1, transform.zoom),
-		"u_device_pixel_ratio": painter.pixelRatio,
 		"u_image": 0,
 		"u_scale": [
 			tileZoomRatio,
 			crossfade.fromScale,
 			crossfade.toScale
 		],
-		"u_fade": crossfade.t,
-		"u_units_to_pixels": [1 / transform.pixelsToGLUnits[0], 1 / transform.pixelsToGLUnits[1]]
+		"u_fade": crossfade.t
 	};
 };
 const lineSDFUniformValues = (painter, tile, layer, ratioScale, crossfade) => {
@@ -16418,11 +16768,7 @@ const symbolIconUniforms = (context, locations) => ({
 	"u_is_size_feature_constant": new Uniform1i(context, locations.u_is_size_feature_constant),
 	"u_size_t": new Uniform1f(context, locations.u_size_t),
 	"u_size": new Uniform1f(context, locations.u_size),
-	"u_camera_to_center_distance": new Uniform1f(context, locations.u_camera_to_center_distance),
-	"u_pitch": new Uniform1f(context, locations.u_pitch),
 	"u_rotate_symbol": new Uniform1i(context, locations.u_rotate_symbol),
-	"u_aspect_ratio": new Uniform1f(context, locations.u_aspect_ratio),
-	"u_fade_change": new Uniform1f(context, locations.u_fade_change),
 	"u_label_plane_matrix": new UniformMatrix4f(context, locations.u_label_plane_matrix),
 	"u_coord_matrix": new UniformMatrix4f(context, locations.u_coord_matrix),
 	"u_is_text": new Uniform1i(context, locations.u_is_text),
@@ -16441,11 +16787,7 @@ const symbolSDFUniforms = (context, locations) => ({
 	"u_is_size_feature_constant": new Uniform1i(context, locations.u_is_size_feature_constant),
 	"u_size_t": new Uniform1f(context, locations.u_size_t),
 	"u_size": new Uniform1f(context, locations.u_size),
-	"u_camera_to_center_distance": new Uniform1f(context, locations.u_camera_to_center_distance),
-	"u_pitch": new Uniform1f(context, locations.u_pitch),
 	"u_rotate_symbol": new Uniform1i(context, locations.u_rotate_symbol),
-	"u_aspect_ratio": new Uniform1f(context, locations.u_aspect_ratio),
-	"u_fade_change": new Uniform1f(context, locations.u_fade_change),
 	"u_label_plane_matrix": new UniformMatrix4f(context, locations.u_label_plane_matrix),
 	"u_coord_matrix": new UniformMatrix4f(context, locations.u_coord_matrix),
 	"u_is_text": new Uniform1i(context, locations.u_is_text),
@@ -16455,7 +16797,6 @@ const symbolSDFUniforms = (context, locations) => ({
 	"u_texsize": new Uniform2f(context, locations.u_texsize),
 	"u_texture": new Uniform1i(context, locations.u_texture),
 	"u_gamma_scale": new Uniform1f(context, locations.u_gamma_scale),
-	"u_device_pixel_ratio": new Uniform1f(context, locations.u_device_pixel_ratio),
 	"u_is_halo": new Uniform1i(context, locations.u_is_halo),
 	"u_is_plain": new Uniform1i(context, locations.u_is_plain),
 	"u_translation": new Uniform2f(context, locations.u_translation),
@@ -16468,11 +16809,7 @@ const symbolTextAndIconUniforms = (context, locations) => ({
 	"u_is_size_feature_constant": new Uniform1i(context, locations.u_is_size_feature_constant),
 	"u_size_t": new Uniform1f(context, locations.u_size_t),
 	"u_size": new Uniform1f(context, locations.u_size),
-	"u_camera_to_center_distance": new Uniform1f(context, locations.u_camera_to_center_distance),
-	"u_pitch": new Uniform1f(context, locations.u_pitch),
 	"u_rotate_symbol": new Uniform1i(context, locations.u_rotate_symbol),
-	"u_aspect_ratio": new Uniform1f(context, locations.u_aspect_ratio),
-	"u_fade_change": new Uniform1f(context, locations.u_fade_change),
 	"u_label_plane_matrix": new UniformMatrix4f(context, locations.u_label_plane_matrix),
 	"u_coord_matrix": new UniformMatrix4f(context, locations.u_coord_matrix),
 	"u_is_text": new Uniform1i(context, locations.u_is_text),
@@ -16484,7 +16821,6 @@ const symbolTextAndIconUniforms = (context, locations) => ({
 	"u_texture": new Uniform1i(context, locations.u_texture),
 	"u_texture_icon": new Uniform1i(context, locations.u_texture_icon),
 	"u_gamma_scale": new Uniform1f(context, locations.u_gamma_scale),
-	"u_device_pixel_ratio": new Uniform1f(context, locations.u_device_pixel_ratio),
 	"u_is_halo": new Uniform1i(context, locations.u_is_halo),
 	"u_translation": new Uniform2f(context, locations.u_translation),
 	"u_pitched_scale": new Uniform1f(context, locations.u_pitched_scale),
@@ -16492,17 +16828,12 @@ const symbolTextAndIconUniforms = (context, locations) => ({
 	"u_height_anchor_ground": new Uniform1i(context, locations.u_height_anchor_ground)
 });
 const symbolIconUniformValues = (functionType, size, rotateInShader, pitchWithMap, isAlongLine, isVariableAnchor, painter, labelPlaneMatrix, glCoordMatrix, translation, isText, texSize, pitchedScale, isOffset, heightAnchorGround) => {
-	const transform = painter.transform;
 	return {
 		"u_is_size_zoom_constant": +(functionType === "constant" || functionType === "source"),
 		"u_is_size_feature_constant": +(functionType === "constant" || functionType === "camera"),
 		"u_size_t": size ? size.uSizeT : 0,
 		"u_size": size ? size.uSize : 0,
-		"u_camera_to_center_distance": transform.cameraToCenterDistance,
-		"u_pitch": transform.pitch / 360 * 2 * Math.PI,
 		"u_rotate_symbol": +rotateInShader,
-		"u_aspect_ratio": transform.width / transform.height,
-		"u_fade_change": painter.options.fadeDuration ? painter.symbolFadeChange : 1,
 		"u_label_plane_matrix": labelPlaneMatrix,
 		"u_coord_matrix": glCoordMatrix,
 		"u_is_text": +isText,
@@ -16521,7 +16852,6 @@ const symbolSDFUniformValues = (functionType, size, rotateInShader, pitchWithMap
 	const transform = painter.transform;
 	return extend(symbolIconUniformValues(functionType, size, rotateInShader, pitchWithMap, isAlongLine, isVariableAnchor, painter, labelPlaneMatrix, glCoordMatrix, translation, isText, texSize, pitchedScale, isOffset, heightAnchorGround), {
 		"u_gamma_scale": pitchWithMap ? Math.cos(transform.pitch * Math.PI / 180) * transform.cameraToCenterDistance : 1,
-		"u_device_pixel_ratio": painter.pixelRatio,
 		"u_is_halo": isHalo ? 1 : 0,
 		"u_is_plain": 1
 	});
@@ -16584,7 +16914,10 @@ const skyUniforms = (context, locations) => ({
 	"u_horizon": new Uniform2f(context, locations.u_horizon),
 	"u_horizon_normal": new Uniform2f(context, locations.u_horizon_normal),
 	"u_sky_horizon_blend": new Uniform1f(context, locations.u_sky_horizon_blend),
-	"u_sky_blend": new Uniform1f(context, locations.u_sky_blend)
+	"u_sky_blend": new Uniform1f(context, locations.u_sky_blend),
+	"u_inv_proj_matrix": new UniformMatrix4f(context, locations.u_inv_proj_matrix),
+	"u_globe_position": new Uniform3f(context, locations.u_globe_position),
+	"u_globe_radius": new Uniform1f(context, locations.u_globe_radius)
 });
 const skyUniformValues = (sky, transform, pixelRatio) => {
 	const cosRoll = Math.cos(transform.rollInRadians);
@@ -16601,12 +16934,15 @@ const skyUniformValues = (sky, transform, pixelRatio) => {
 		"u_horizon": [(transform.width / 2 - mercatorHorizon * sinRoll) * pixelRatio, (transform.height / 2 + mercatorHorizon * cosRoll) * pixelRatio],
 		"u_horizon_normal": [-sinRoll, cosRoll],
 		"u_sky_horizon_blend": sky.properties.get("sky-horizon-blend") * transform.height / 2 * pixelRatio,
-		"u_sky_blend": skyBlend
+		"u_sky_blend": skyBlend,
+		"u_inv_proj_matrix": transform.inverseProjectionMatrix,
+		"u_globe_position": getGlobeCenterInViewSpace(transform),
+		"u_globe_radius": getGlobeRadiusPixels(transform.worldSize, transform.center.lat)
 	};
 };
 //#endregion
 //#region src/webgl/program/program_uniforms.ts
-const emptyUniforms = (_, __) => {};
+const emptyUniforms = (_, __) => ({});
 const programUniforms = {
 	fillExtrusion: fillExtrusionUniforms,
 	fillExtrusionPattern: fillExtrusionPatternUniforms,
@@ -16615,8 +16951,8 @@ const programUniforms = {
 	fillOutline: fillOutlineUniforms,
 	fillOutlinePattern: fillOutlinePatternUniforms,
 	circle: circleUniforms,
-	collisionBox: collisionUniforms,
-	collisionCircle: collisionCircleUniforms,
+	collisionBox: emptyUniforms,
+	collisionCircle: emptyUniforms,
 	debug: debugUniforms,
 	depth: emptyUniforms,
 	clippingMask: emptyUniforms,
@@ -17231,6 +17567,73 @@ var Framebuffer = class {
 	}
 };
 //#endregion
+//#region src/webgl/frame_uniform_buffer.ts
+const layout = std140Layout([
+	{
+		name: "u_units_to_pixels",
+		type: "vec2"
+	},
+	{
+		name: "u_world_size",
+		type: "vec2"
+	},
+	{
+		name: "u_camera_to_center_distance",
+		type: "float"
+	},
+	{
+		name: "u_symbol_fade_change",
+		type: "float"
+	},
+	{
+		name: "u_aspect_ratio",
+		type: "float"
+	},
+	{
+		name: "u_device_pixel_ratio",
+		type: "float"
+	},
+	{
+		name: "u_viewport_size",
+		type: "vec2"
+	},
+	{
+		name: "u_pixel_extrude_scale",
+		type: "vec2"
+	},
+	{
+		name: "u_pitch",
+		type: "float"
+	}
+]);
+const offsets = layout.offsets;
+/**
+* @internal
+* The buffer behind the `FrameUBO` block in the shader preludes, written once per frame by `Painter.render`.
+*/
+function createFrameUniformBuffer(context) {
+	return new UniformBuffer(context, UBO_BINDINGS.FrameUBO, layout);
+}
+function updateFrameUniformBuffer(buffer, painter) {
+	const f32 = buffer.pending;
+	const { transform } = painter;
+	const gl = painter.context.gl;
+	f32[offsets.u_units_to_pixels] = 1 / transform.pixelsToGLUnits[0];
+	f32[offsets.u_units_to_pixels + 1] = 1 / transform.pixelsToGLUnits[1];
+	f32[offsets.u_world_size] = gl.drawingBufferWidth;
+	f32[offsets.u_world_size + 1] = gl.drawingBufferHeight;
+	f32[offsets.u_camera_to_center_distance] = transform.cameraToCenterDistance;
+	f32[offsets.u_symbol_fade_change] = painter.options.fadeDuration ? painter.symbolFadeChange : 1;
+	f32[offsets.u_aspect_ratio] = transform.width / transform.height;
+	f32[offsets.u_device_pixel_ratio] = painter.pixelRatio;
+	f32[offsets.u_viewport_size] = transform.width;
+	f32[offsets.u_viewport_size + 1] = transform.height;
+	f32[offsets.u_pixel_extrude_scale] = 1 / transform.width;
+	f32[offsets.u_pixel_extrude_scale + 1] = 1 / transform.height;
+	f32[offsets.u_pitch] = transform.pitch / 360 * 2 * Math.PI;
+	buffer.upload();
+}
+//#endregion
 //#region src/webgl/color_mode.ts
 const ZERO = 0;
 const ONE = 1;
@@ -17306,6 +17709,9 @@ var Context = class {
 		this.maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);
 		gl.getExtension("EXT_color_buffer_half_float");
 		gl.getExtension("EXT_color_buffer_float");
+		this.projectionUniformBuffer = createProjectionUniformBuffer(this);
+		this.terrainUniformBuffer = createTerrainUniformBuffer(this);
+		this.frameUniformBuffer = createFrameUniformBuffer(this);
 	}
 	setDefault() {
 		this.unbindVAO();
@@ -17367,6 +17773,9 @@ var Context = class {
 		this.pixelStoreUnpack.dirty = true;
 		this.pixelStoreUnpackPremultiplyAlpha.dirty = true;
 		this.pixelStoreUnpackFlipY.dirty = true;
+		this.projectionUniformBuffer.bindingDirty = true;
+		this.terrainUniformBuffer.bindingDirty = true;
+		this.frameUniformBuffer.bindingDirty = true;
 	}
 	/**
 	* Reset some GL state to default values before handing users the raw context, as we do for
@@ -17554,7 +17963,7 @@ function drawCollisionDebug(painter, tileManager, layer, coords, isText) {
 			circleOffset = circleCount;
 		}
 		if (!buffers) continue;
-		program.draw(context, gl.LINES, DepthMode.disabled, StencilMode.disabled, painter.colorModeForRenderPass(), CullFaceMode.disabled, collisionUniformValues(painter.transform), painter.style.map.terrain?.getTerrainData(coord), transform.getProjectionData({
+		program.draw(context, gl.LINES, DepthMode.disabled, StencilMode.disabled, painter.colorModeForRenderPass(), CullFaceMode.disabled, null, painter.style.map.terrain?.getTerrainData(coord), transform.getProjectionData({
 			overscaledTileID: coord,
 			applyGlobeMatrix: true,
 			applyTerrainMatrix: true
@@ -17580,10 +17989,7 @@ function drawCollisionDebug(painter, tileManager, layer, coords, isText) {
 	if (!quadTriangles || quadTriangles.length < circleCount * 2) quadTriangles = createQuadTriangles(circleCount);
 	const indexBuffer = context.createIndexBuffer(quadTriangles, true);
 	const vertexBuffer = context.createVertexBuffer(vertexData, collisionCircleLayout.members, true);
-	for (const batch of tileBatches) {
-		const uniforms = collisionCircleUniformValues(painter.transform);
-		circleProgram.draw(context, gl.TRIANGLES, DepthMode.disabled, StencilMode.disabled, painter.colorModeForRenderPass(), CullFaceMode.disabled, uniforms, painter.style.map.terrain?.getTerrainData(batch.coord), null, layer.id, vertexBuffer, indexBuffer, SegmentVector.simpleSegment(0, batch.circleOffset * 2, batch.circleArray.length, batch.circleArray.length / 2), null, painter.transform.zoom, null, null, null);
-	}
+	for (const batch of tileBatches) circleProgram.draw(context, gl.TRIANGLES, DepthMode.disabled, StencilMode.disabled, painter.colorModeForRenderPass(), CullFaceMode.disabled, null, painter.style.map.terrain?.getTerrainData(batch.coord), null, layer.id, vertexBuffer, indexBuffer, SegmentVector.simpleSegment(0, batch.circleOffset * 2, batch.circleArray.length, batch.circleArray.length / 2), null, painter.transform.zoom, null, null, null);
 	vertexBuffer.destroy();
 	indexBuffer.destroy();
 }
@@ -17607,7 +18013,7 @@ function createQuadTriangles(quadCount) {
 //#region src/webgl/draw/draw_symbol.ts
 const identityMat4 = identity(/* @__PURE__ */ new Float32Array(16));
 function drawSymbols(painter, tileManager, layer, coords, variableOffsets, renderOptions) {
-	if (painter.renderPass !== "translucent") return;
+	if (renderOptions.currentPass !== "translucent") return;
 	const { isRenderingToTexture } = renderOptions;
 	const stencilMode = StencilMode.disabled;
 	const colorMode = painter.colorModeForRenderPass();
@@ -17863,7 +18269,7 @@ function drawSymbolElements(buffers, segments, layer, painter, program, depthMod
 //#endregion
 //#region src/webgl/draw/draw_circle.ts
 function drawCircles(painter, tileManager, layer, coords, renderOptions) {
-	if (painter.renderPass !== "translucent") return;
+	if (renderOptions.currentPass !== "translucent") return;
 	const { isRenderingToTexture } = renderOptions;
 	const opacity = layer.paint.get("circle-opacity");
 	const strokeWidth = layer.paint.get("circle-stroke-width");
@@ -17933,8 +18339,8 @@ function drawHeatmap(painter, tileManager, layer, tileIDs, renderOptions) {
 		for (const coord of tileIDs) {
 			const tile = tileManager.getTile(coord);
 			if (tileManager.hasRenderableParent(coord)) continue;
-			if (painter.renderPass === "offscreen") prepareHeatmapTerrain(painter, tile, layer, coord, isRenderingGlobe);
-			else if (painter.renderPass === "translucent") renderHeatmapTerrain(painter, layer, coord, isRenderingToTexture, isRenderingGlobe);
+			if (renderOptions.currentPass === "offscreen") prepareHeatmapTerrain(painter, tile, layer, coord, isRenderingGlobe);
+			else if (renderOptions.currentPass === "translucent") renderHeatmapTerrain(painter, layer, coord, isRenderingToTexture, isRenderingGlobe);
 		}
 		context.viewport.set([
 			0,
@@ -17942,8 +18348,8 @@ function drawHeatmap(painter, tileManager, layer, tileIDs, renderOptions) {
 			painter.width,
 			painter.height
 		]);
-	} else if (painter.renderPass === "offscreen") prepareHeatmapFlat(painter, tileManager, layer, tileIDs);
-	else if (painter.renderPass === "translucent") renderHeatmapFlat(painter, layer);
+	} else if (renderOptions.currentPass === "offscreen") prepareHeatmapFlat(painter, tileManager, layer, tileIDs);
+	else if (renderOptions.currentPass === "translucent") renderHeatmapFlat(painter, layer);
 }
 function prepareHeatmapFlat(painter, tileManager, layer, coords) {
 	const context = painter.context;
@@ -18209,7 +18615,7 @@ function bindGradientAndDashTextures(painter, tileManager, context, gl, layer, b
 	programConfiguration.updatePaintBuffers(crossfade);
 }
 function drawLine(painter, tileManager, layer, coords, renderOptions) {
-	if (painter.renderPass !== "translucent") return;
+	if (renderOptions.currentPass !== "translucent") return;
 	const opacity = layer.paint.get("line-opacity");
 	const width = layer.paint.get("line-width");
 	const layerOpacity = layer.paint.get("line-layer-opacity");
@@ -18328,7 +18734,7 @@ function drawFill(painter, tileManager, layer, coords, renderOptions) {
 	const layerOpacity = layer.paint.get("fill-layer-opacity");
 	if (opacity.constantOr(1) === 0 || layerOpacity === 0) return;
 	if (layerOpacity < 1) {
-		if (painter.renderPass !== "translucent") return;
+		if (renderOptions.currentPass !== "translucent") return;
 		const results = prepareDrawLayerOpacity(painter, layer, coords, !!painter.style.map.terrain);
 		drawFillAndOutline(painter, tileManager, layer, coords, renderOptions);
 		drawLayerOpacity(painter, layerOpacity, results, layer);
@@ -18336,17 +18742,17 @@ function drawFill(painter, tileManager, layer, coords, renderOptions) {
 	}
 	const pattern = layer.paint.get("fill-pattern");
 	const fillEligibleForOpaque = painter.opaquePassEnabledForLayer() && !pattern.constantOr(1) && color.constantOr(Color.transparent).a === 1 && opacity.constantOr(0) === 1;
-	if (fillEligibleForOpaque && painter.renderPass === "opaque") {
+	if (fillEligibleForOpaque && renderOptions.currentPass === "opaque") {
 		const { isRenderingToTexture } = renderOptions;
 		const colorMode = painter.colorModeForRenderPass();
 		drawFillTiles(painter, tileManager, layer, coords, painter.getDepthModeForSublayer(1, DepthMode.ReadWrite), colorMode, false, isRenderingToTexture);
 		return;
 	}
-	if (fillEligibleForOpaque && painter.renderPass === "translucent") {
+	if (fillEligibleForOpaque && renderOptions.currentPass === "translucent") {
 		drawOutline(painter, tileManager, layer, coords, renderOptions);
 		return;
 	}
-	if (painter.renderPass === "translucent") drawFillAndOutline(painter, tileManager, layer, coords, renderOptions);
+	if (renderOptions.currentPass === "translucent") drawFillAndOutline(painter, tileManager, layer, coords, renderOptions);
 }
 /**
 * Draw fill + outline in a single translucent pass with ReadOnly depth.
@@ -18388,6 +18794,7 @@ function drawFillTiles(painter, tileManager, layer, coords, depthMode, colorMode
 		if (image && !tile.patternsLoaded()) continue;
 		const bucket = tile.getBucket(layer);
 		if (!bucket) continue;
+		const isSdfPattern = bucket.sdfPatterns[layer.id] ?? false;
 		const programConfiguration = bucket.programConfigurations.get(layer.id);
 		const program = painter.useProgram(programName, programConfiguration);
 		const terrainData = painter.getTerrainDataForTile(coord, isRenderingToTexture);
@@ -18406,12 +18813,11 @@ function drawFillTiles(painter, tileManager, layer, coords, depthMode, colorMode
 		if (!isOutline) {
 			indexBuffer = bucket.indexBuffer;
 			segments = bucket.segments;
-			uniformValues = image ? fillPatternUniformValues(painter, crossfade, tile, translateForUniforms) : fillUniformValues(translateForUniforms);
+			uniformValues = image ? fillPatternUniformValues(painter, crossfade, tile, translateForUniforms, isSdfPattern) : fillUniformValues(translateForUniforms);
 		} else {
 			indexBuffer = bucket.indexBuffer2;
 			segments = bucket.segments2;
-			const drawingBufferSize = [gl.drawingBufferWidth, gl.drawingBufferHeight];
-			uniformValues = programName === "fillOutlinePattern" && image ? fillOutlinePatternUniformValues(painter, crossfade, tile, drawingBufferSize, translateForUniforms) : fillOutlineUniformValues(drawingBufferSize, translateForUniforms);
+			uniformValues = programName === "fillOutlinePattern" && image ? fillOutlinePatternUniformValues(painter, crossfade, tile, translateForUniforms, isSdfPattern) : fillOutlineUniformValues(translateForUniforms);
 		}
 		const stencil = painter.stencilModeForClipping(coord);
 		program.draw(painter.context, drawMode, depthMode, stencil, colorMode, CullFaceMode.backCCW, uniformValues, terrainData, projectionData, layer.id, bucket.layoutVertexBuffer, indexBuffer, segments, layer.paint, painter.transform.zoom, programConfiguration);
@@ -18423,8 +18829,8 @@ function drawFillExtrusion(painter, tileManager, layer, coords, renderOptions) {
 	const opacity = layer.paint.get("fill-extrusion-opacity");
 	if (opacity === 0) return;
 	const { isRenderingToTexture } = renderOptions;
-	if (painter.renderPass === "translucent") {
-		const depthMode = new DepthMode(painter.context.gl.LEQUAL, DepthMode.ReadWrite, painter.depthRangeFor3D);
+	if (renderOptions.currentPass === "translucent") {
+		const depthMode = new DepthMode(painter.context.gl.LEQUAL, DepthMode.ReadWrite, renderOptions.depthRangeFor3D);
 		if (opacity === 1 && !layer.paint.get("fill-extrusion-pattern").constantOr(1)) {
 			const colorMode = painter.colorModeForRenderPass();
 			drawExtrusionTiles(painter, tileManager, layer, coords, depthMode, StencilMode.disabled, colorMode, isRenderingToTexture);
@@ -18471,13 +18877,13 @@ function drawExtrusionTiles(painter, tileManager, layer, coords, depthMode, sten
 //#endregion
 //#region src/webgl/draw/draw_hillshade.ts
 function drawHillshade(painter, tileManager, layer, tileIDs, renderOptions) {
-	if (painter.renderPass !== "offscreen" && painter.renderPass !== "translucent") return;
+	if (renderOptions.currentPass !== "offscreen" && renderOptions.currentPass !== "translucent") return;
 	const { isRenderingToTexture } = renderOptions;
 	const context = painter.context;
 	const useSubdivision = painter.style.projection.useSubdivision;
 	const depthMode = painter.getDepthModeForSublayer(0, DepthMode.ReadOnly);
 	const colorMode = painter.colorModeForRenderPass();
-	if (painter.renderPass === "offscreen") {
+	if (renderOptions.currentPass === "offscreen") {
 		prepareHillshade(painter, tileManager, tileIDs, layer, depthMode, StencilMode.disabled, colorMode);
 		context.viewport.set([
 			0,
@@ -18485,7 +18891,7 @@ function drawHillshade(painter, tileManager, layer, tileIDs, renderOptions) {
 			painter.width,
 			painter.height
 		]);
-	} else if (painter.renderPass === "translucent") {
+	} else if (renderOptions.currentPass === "translucent") {
 		if (useSubdivision) {
 			const [stencilBorderless, stencilBorders, coords] = painter.stencilConfigForOverlapTwoPass(tileIDs);
 			renderHillshade(painter, tileManager, layer, coords, stencilBorderless, depthMode, colorMode, false, isRenderingToTexture);
@@ -18530,7 +18936,7 @@ function prepareHillshade(painter, tileManager, tileIDs, layer, depthMode, stenc
 		const dem = tile.dem;
 		if (!dem?.data) continue;
 		if (!tile.needsHillshadePrepare) continue;
-		const tileSize = dem.dim;
+		const hillshadeTextureSize = dem.dim + 2;
 		const textureStride = dem.stride;
 		const pixelData = dem.getPixels();
 		context.activeTexture.set(gl.TEXTURE1);
@@ -18548,20 +18954,20 @@ function prepareHillshade(painter, tileManager, tileIDs, layer, depthMode, stenc
 		let fbo = tile.fbo;
 		if (!fbo) {
 			const renderTexture = new Texture(context, {
-				width: tileSize,
-				height: tileSize,
+				width: hillshadeTextureSize,
+				height: hillshadeTextureSize,
 				data: null
 			}, gl.RGBA);
 			renderTexture.bind(textureFilter, gl.CLAMP_TO_EDGE);
-			fbo = tile.fbo = context.createFramebuffer(tileSize, tileSize, true, false);
+			fbo = tile.fbo = context.createFramebuffer(hillshadeTextureSize, hillshadeTextureSize, true, false);
 			fbo.colorAttachment.set(renderTexture.texture);
 		}
 		context.bindFramebuffer.set(fbo.framebuffer);
 		context.viewport.set([
 			0,
 			0,
-			tileSize,
-			tileSize
+			hillshadeTextureSize,
+			hillshadeTextureSize
 		]);
 		painter.useProgram("hillshadePrepare").draw(context, gl.TRIANGLES, depthMode, stencilMode, colorMode, CullFaceMode.disabled, hillshadeUniformPrepareValues(tile.tileID, dem), null, null, layer.id, painter.rasterBoundsBuffer, painter.quadTriangleIndexBuffer, painter.rasterBoundsSegments);
 		tile.needsHillshadePrepare = false;
@@ -18570,7 +18976,7 @@ function prepareHillshade(painter, tileManager, tileIDs, layer, depthMode, stenc
 //#endregion
 //#region src/webgl/draw/draw_color_relief.ts
 function drawColorRelief(painter, tileManager, layer, tileIDs, renderOptions) {
-	if (painter.renderPass !== "translucent") return;
+	if (renderOptions.currentPass !== "translucent") return;
 	if (!tileIDs.length) return;
 	const { isRenderingToTexture } = renderOptions;
 	const useSubdivision = painter.style.projection.useSubdivision;
@@ -18586,6 +18992,12 @@ function drawColorRelief(painter, tileManager, layer, tileIDs, renderOptions) {
 	}
 }
 let textureMaxSize = 0;
+/**
+* Draws the color-relief tiles of one pass.
+*
+* A loaded raster-DEM tile can carry no DEM at all (e.g. an empty 204 response);
+* such tiles are skipped before the first-tile setup reads from them.
+*/
 function renderColorRelief(painter, tileManager, layer, coords, stencilModes, depthMode, colorMode, useBorder, isRenderingToTexture) {
 	const projection = painter.style.projection;
 	const context = painter.context;
@@ -18599,6 +19011,7 @@ function renderColorRelief(painter, tileManager, layer, coords, stencilModes, de
 	for (const coord of coords) {
 		const tile = tileManager.getTile(coord);
 		const dem = tile.dem;
+		if (!dem?.data) continue;
 		if (firstTile) {
 			textureMaxSize ||= gl.getParameter(gl.MAX_TEXTURE_SIZE);
 			const maxLength = textureMaxSize;
@@ -18610,7 +19023,6 @@ function renderColorRelief(painter, tileManager, layer, coords, stencilModes, de
 			firstTile = false;
 			colorRampSize = elevationTexture.size[0];
 		}
-		if (!dem?.data) continue;
 		const textureStride = dem.stride;
 		context.activeTexture.set(gl.TEXTURE0);
 		if (!tile.demTexture || tile.needsColorReliefPrepare) {
@@ -18644,7 +19056,7 @@ const cornerCoords = [
 	new Point(0, EXTENT)
 ];
 function drawRaster(painter, tileManager, layer, tileIDs, renderOptions) {
-	if (painter.renderPass !== "translucent") return;
+	if (renderOptions.currentPass !== "translucent") return;
 	if (layer.paint.get("raster-opacity") === 0) return;
 	if (!tileIDs.length) return;
 	const { isRenderingToTexture } = renderOptions;
@@ -18785,7 +19197,7 @@ function drawBackground(painter, tileManager, layer, coords, renderOptions) {
 	const image = layer.paint.get("background-pattern");
 	if (painter.isPatternMissing(image)) return;
 	const pass = !image && color.a === 1 && opacity === 1 && painter.opaquePassEnabledForLayer() ? "opaque" : "translucent";
-	if (painter.renderPass !== pass) return;
+	if (renderOptions.currentPass !== pass) return;
 	const stencilMode = StencilMode.disabled;
 	const depthMode = painter.getDepthModeForSublayer(0, pass === "opaque" ? DepthMode.ReadWrite : DepthMode.ReadOnly);
 	const colorMode = painter.colorModeForRenderPass();
@@ -18942,7 +19354,7 @@ function drawCustom(painter, tileManager, layer, renderOptions) {
 		}
 	};
 	const renderingMode = implementation.renderingMode ? implementation.renderingMode : "2d";
-	if (painter.renderPass === "offscreen") {
+	if (renderOptions.currentPass === "offscreen") {
 		const prerender = implementation.prerender;
 		if (prerender) {
 			painter.setCustomLayerDefaults();
@@ -18951,7 +19363,7 @@ function drawCustom(painter, tileManager, layer, renderOptions) {
 			context.setDirty();
 			painter.setBaseState();
 		}
-	} else if (painter.renderPass === "translucent") {
+	} else if (renderOptions.currentPass === "translucent") {
 		painter.setCustomLayerDefaults();
 		context.setColorMode(painter.colorModeForRenderPass());
 		context.setStencilMode(StencilMode.disabled);
@@ -19028,7 +19440,7 @@ function drawTerrain(painter, terrain, tiles, renderOptions) {
 		const texture = painter.renderToTexture.getTexture(tile);
 		const terrainData = terrain.getTerrainData(tile.tileID);
 		context.activeTexture.set(gl.TEXTURE0);
-		gl.bindTexture(gl.TEXTURE_2D, texture.texture);
+		texture.bind(gl.LINEAR, gl.CLAMP_TO_EDGE, gl.LINEAR_MIPMAP_LINEAR);
 		const eleDelta = terrain.getSkirtLength(tr.zoom);
 		const fogMatrix = tr.calculateFogMatrix(tile.tileID.toUnwrapped());
 		const uniformValues = terrainUniformValues(eleDelta, fogMatrix, painter.style.sky, tr.pitch, isRenderingGlobe);
@@ -19096,25 +19508,8 @@ function drawAtmosphere(painter, sky, light) {
 	const atmosphereBlend = sky.properties.get("atmosphere-blend") * projectionData.projectionTransition;
 	if (atmosphereBlend === 0) return;
 	const globeRadius = getGlobeRadiusPixels(transform.worldSize, transform.center.lat);
-	const invProjMatrix = transform.inverseProjectionMatrix;
-	const vec = /* @__PURE__ */ new Float64Array(4);
-	vec[3] = 1;
-	transformMat4(vec, vec, transform.modelViewProjectionMatrix);
-	vec[0] /= vec[3];
-	vec[1] /= vec[3];
-	vec[2] /= vec[3];
-	vec[3] = 1;
-	transformMat4(vec, vec, invProjMatrix);
-	vec[0] /= vec[3];
-	vec[1] /= vec[3];
-	vec[2] /= vec[3];
-	vec[3] = 1;
-	const globePosition = [
-		vec[0],
-		vec[1],
-		vec[2]
-	];
-	const uniformValues = atmosphereUniformValues(sunPos, atmosphereBlend, globePosition, globeRadius, invProjMatrix);
+	const globePosition = getGlobeCenterInViewSpace(transform);
+	const uniformValues = atmosphereUniformValues(sunPos, atmosphereBlend, globePosition, globeRadius, transform.inverseProjectionMatrix);
 	const mesh = getMesh(context, sky);
 	program.draw(context, gl.TRIANGLES, depthMode, StencilMode.disabled, ColorMode.alphaBlended, CullFaceMode.disabled, uniformValues, null, null, "atmosphere", mesh.vertexBuffer, mesh.indexBuffer, mesh.segments);
 }
@@ -19139,6 +19534,22 @@ const webglDrawFunctions = {
 	terrainDepth: drawDepth
 };
 //#endregion
+//#region src/render/render_options.ts
+function createRenderOptions(transform, projection, terrain) {
+	const projectionTransition = projection?.transitionState ?? 0;
+	return {
+		currentPass: "offscreen",
+		currentLayer: 0,
+		opaquePassCutoff: Infinity,
+		depthRangeFor3D: [0, 1],
+		isRenderingToTexture: false,
+		transform,
+		terrain,
+		projectionTransition,
+		isRenderingGlobe: projectionTransition > 0
+	};
+}
+//#endregion
 //#region src/render/painter.ts
 /**
 * @internal
@@ -19408,38 +19819,36 @@ var Painter = class Painter {
 				true,
 				true
 			]);
-		} else if (this.renderPass === "opaque") return ColorMode.unblended;
+		} else if (this.renderOptions.currentPass === "opaque") return ColorMode.unblended;
 		else return ColorMode.alphaBlended;
 	}
 	getDepthModeForSublayer(n, mask, func) {
 		if (!this.opaquePassEnabledForLayer()) return DepthMode.disabled;
-		const depth = 1 - ((1 + this.currentLayer) * this.numSublayers + n) * this.depthEpsilon;
+		const depth = 1 - ((1 + this.renderOptions.currentLayer) * this.numSublayers + n) * this.depthEpsilon;
 		return new DepthMode(func || this.context.gl.LEQUAL, mask, [depth, depth]);
 	}
 	getDepthModeFor3D() {
-		return new DepthMode(this.context.gl.LEQUAL, DepthMode.ReadWrite, this.depthRangeFor3D);
+		return new DepthMode(this.context.gl.LEQUAL, DepthMode.ReadWrite, this.renderOptions.depthRangeFor3D);
 	}
 	opaquePassEnabledForLayer() {
-		return this.currentLayer < this.opaquePassCutoff;
+		return this.renderOptions.currentLayer < this.renderOptions.opaquePassCutoff;
 	}
 	render(style, options) {
 		this.style = style;
 		this.options = options;
+		const renderOptions = this.renderOptions = createRenderOptions(this.transform, style.projection, style.map.terrain ?? null);
 		this.lineAtlas = style.lineAtlas;
 		this.imageManager = style.imageManager;
 		this.patternAtlas = style.patternAtlas;
 		this.glyphManager = style.glyphManager;
 		this.symbolFadeChange = style.placement.symbolFadeChange(now());
+		updateFrameUniformBuffer(this.context.frameUniformBuffer, this);
 		this.imageManager.beginFrame();
 		const layerIds = this.style._order;
 		const tileManagers = this.style.tileManagers;
 		const coordsAscending = {};
 		const coordsDescending = {};
 		const coordsDescendingSymbol = {};
-		const renderOptions = {
-			isRenderingToTexture: false,
-			isRenderingGlobe: style.projection?.transitionState > 0
-		};
 		for (const id in tileManagers) {
 			const tileManager = tileManagers[id];
 			if (tileManager.used) tileManager.prepare(this.context);
@@ -19447,20 +19856,20 @@ var Painter = class Painter {
 			coordsDescending[id] = coordsAscending[id].slice().reverse();
 			coordsDescendingSymbol[id] = tileManager.getVisibleCoordinates(true).reverse();
 		}
-		this.opaquePassCutoff = Infinity;
+		renderOptions.opaquePassCutoff = Infinity;
 		for (let i = 0; i < layerIds.length; i++) {
 			const layerId = layerIds[i];
 			if (this.style._layers[layerId].is3D()) {
-				this.opaquePassCutoff = i;
+				renderOptions.opaquePassCutoff = i;
 				break;
 			}
 		}
 		this.maybeDrawDepth();
 		if (this.renderToTexture) {
 			this.renderToTexture.prepareForRender(this.style, this.transform.zoom);
-			this.opaquePassCutoff = 0;
+			renderOptions.opaquePassCutoff = 0;
 		}
-		this.renderPass = "offscreen";
+		renderOptions.currentPass = "offscreen";
 		for (const layerId of layerIds) {
 			const layer = this.style._layers[layerId];
 			if (!layer.hasOffscreenPass() || layer.isHidden(this.transform.zoom)) continue;
@@ -19482,21 +19891,21 @@ var Painter = class Painter {
 		this.clearStencil();
 		if (this.style.sky) this.drawFunctions.sky(this, this.style.sky);
 		this._showOverdrawInspector = options.showOverdrawInspector;
-		this.depthRangeFor3D = [0, 1 - (style._order.length + 2) * this.numSublayers * this.depthEpsilon];
+		renderOptions.depthRangeFor3D = [0, 1 - (style._order.length + 2) * this.numSublayers * this.depthEpsilon];
 		if (!this.renderToTexture) {
-			this.renderPass = "opaque";
-			for (this.currentLayer = layerIds.length - 1; this.currentLayer >= 0; this.currentLayer--) {
-				const layer = this.style._layers[layerIds[this.currentLayer]];
+			renderOptions.currentPass = "opaque";
+			for (renderOptions.currentLayer = layerIds.length - 1; renderOptions.currentLayer >= 0; renderOptions.currentLayer--) {
+				const layer = this.style._layers[layerIds[renderOptions.currentLayer]];
 				const tileManager = tileManagers[layer.source];
 				const coords = coordsAscending[layer.source];
 				this.renderTileClippingMasks(layer, coords, false);
 				this.renderLayer(this, tileManager, layer, coords, renderOptions);
 			}
 		}
-		this.renderPass = "translucent";
+		renderOptions.currentPass = "translucent";
 		let globeDepthRendered = false;
-		for (this.currentLayer = 0; this.currentLayer < layerIds.length; this.currentLayer++) {
-			const layer = this.style._layers[layerIds[this.currentLayer]];
+		for (renderOptions.currentLayer = 0; renderOptions.currentLayer < layerIds.length; renderOptions.currentLayer++) {
+			const layer = this.style._layers[layerIds[renderOptions.currentLayer]];
 			const tileManager = tileManagers[layer.source];
 			if (this.renderToTexture?.renderLayer(layer, renderOptions)) continue;
 			if (!this.opaquePassEnabledForLayer() && !globeDepthRendered) {
@@ -19566,9 +19975,16 @@ var Painter = class Painter {
 		const obj = this._rttObjectRecyclePool.pop();
 		if (obj) {
 			if (obj.size !== size) {
-				gl.bindTexture(gl.TEXTURE_2D, obj.texture.texture);
-				gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, size, size, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
-				obj.texture.size = [size, size];
+				obj.texture.update({
+					width: size,
+					height: size,
+					data: null
+				}, {
+					premultiply: false,
+					useMipmap: true
+				});
+				obj.texture.bind(gl.LINEAR, gl.CLAMP_TO_EDGE, gl.LINEAR_MIPMAP_LINEAR);
+				if (this.context.extTextureFilterAnisotropic) gl.texParameterf(gl.TEXTURE_2D, this.context.extTextureFilterAnisotropic.TEXTURE_MAX_ANISOTROPY_EXT, this.context.extTextureFilterAnisotropicMax);
 				obj.size = size;
 			}
 			return obj;
@@ -19577,8 +19993,11 @@ var Painter = class Painter {
 			width: size,
 			height: size,
 			data: null
-		}, gl.RGBA);
-		texture.bind(gl.LINEAR, gl.CLAMP_TO_EDGE);
+		}, gl.RGBA, {
+			premultiply: false,
+			useMipmap: true
+		});
+		texture.bind(gl.LINEAR, gl.CLAMP_TO_EDGE, gl.LINEAR_MIPMAP_LINEAR);
 		if (this.context.extTextureFilterAnisotropic) gl.texParameterf(gl.TEXTURE_2D, this.context.extTextureFilterAnisotropic.TEXTURE_MAX_ANISOTROPY_EXT, this.context.extTextureFilterAnisotropicMax);
 		return {
 			texture,
@@ -19706,6 +20125,9 @@ var Painter = class Painter {
 		if (this.tileExtentMesh) this.tileExtentMesh.vertexBuffer?.destroy();
 		if (this.tileExtentMesh) this.tileExtentMesh.indexBuffer?.destroy();
 		if (this.debugOverlayTexture) this.debugOverlayTexture.destroy();
+		this.context.projectionUniformBuffer.destroy();
+		this.context.terrainUniformBuffer.destroy();
+		this.context.frameUniformBuffer.destroy();
 		if (this.cache) {
 			for (const key in this.cache) {
 				const program = this.cache[key];
@@ -22628,27 +23050,6 @@ var Camera = class extends Evented {
 		if (rollChanged) this.fire(new MapMovementEvent("rollstart", eventData)).fire(new MapMovementEvent("roll", eventData)).fire(new MapMovementEvent("rollend", eventData));
 		return this.fire(new MapMovementEvent("moveend", eventData));
 	}
-	calculateCameraOptionsFromTo(from, altitudeFrom, to, altitudeTo = 0) {
-		const fromMercator = MercatorCoordinate.fromLngLat(from, altitudeFrom);
-		const toMercator = MercatorCoordinate.fromLngLat(to, altitudeTo);
-		const dx = toMercator.x - fromMercator.x;
-		const dy = toMercator.y - fromMercator.y;
-		const dz = toMercator.z - fromMercator.z;
-		const distance3D = Math.hypot(dx, dy, dz);
-		if (distance3D === 0) throw new Error("Can't calculate camera options with same From and To");
-		const groundDistance = Math.hypot(dx, dy);
-		const zoom = scaleZoom(this.transform.cameraToCenterDistance / distance3D / this.transform.tileSize);
-		const bearing = Math.atan2(dx, -dy) * 180 / Math.PI;
-		let pitch = Math.acos(groundDistance / distance3D) * 180 / Math.PI;
-		pitch = dz < 0 ? 90 - pitch : 90 + pitch;
-		return {
-			center: toMercator.toLngLat(),
-			elevation: altitudeTo,
-			zoom,
-			pitch,
-			bearing
-		};
-	}
 	calculateCameraOptionsFromCameraLngLatAltRotation(cameraLngLat, cameraAlt, bearing, pitch, roll) {
 		const centerInfo = this.transform.calculateCenterFromCameraLngLatAlt(cameraLngLat, cameraAlt, bearing, pitch);
 		return {
@@ -22776,7 +23177,7 @@ var Camera = class extends Evented {
 		const cameraAltitude = tr.getCameraAltitude();
 		const minAltitude = this.terrain ? this.terrain.getElevationForLngLatZoom(cameraLngLat, tr.zoom) : 0;
 		if (cameraAltitude < minAltitude) {
-			const newCamera = this.calculateCameraOptionsFromTo(cameraLngLat, minAltitude, tr.center, tr.elevation);
+			const newCamera = tr.calculateCameraOptionsFromTo(cameraLngLat, minAltitude, tr.center, tr.elevation);
 			return {
 				pitch: newCamera.pitch,
 				zoom: newCamera.zoom
@@ -23219,13 +23620,23 @@ var TaskQueue = class {
 		if (this._currentlyRunning) throw new Error("Attempting to run(), but is already running.");
 		const queue = this._currentlyRunning = this._queue;
 		this._queue = [];
+		let failed = false;
+		let firstError;
 		for (const task of queue) {
 			if (task.cancelled) continue;
-			task.callback(timeStamp);
+			try {
+				task.callback(timeStamp);
+			} catch (error) {
+				if (!failed) {
+					failed = true;
+					firstError = error;
+				}
+			}
 			if (this._cleared) break;
 		}
 		this._cleared = false;
 		this._currentlyRunning = false;
+		if (failed) throw firstError;
 	}
 	clear() {
 		if (this._currentlyRunning) this._cleared = true;
@@ -23233,6 +23644,35 @@ var TaskQueue = class {
 	}
 };
 //#endregion
+//#region src/webgl/rtt_fingerprint.ts
+/**
+* Immutable value describing the state a render-to-texture tile's textures
+* were rendered from: the source tiles drawn into them, the source data
+* revision, and the map zoom at render time (zoom-dependent style properties
+* are evaluated then).
+*
+* @internal
+*/
+var RTTFingerprint = class {
+	constructor(coords, revision, zoom) {
+		this._tileKeys = coords.map((c) => c.key).sort().join();
+		this._revision = revision;
+		this._zoom = zoom;
+	}
+	equals(other) {
+		return this.equalsIgnoringZoom(other) && this._zoom === other._zoom;
+	}
+	/**
+	* Returns whether the source tiles and revision match, without comparing zoom.
+	* Used to keep a texture on screen while the zoom is still changing and only
+	* re-render it once the zoom has settled.
+	*/
+	equalsIgnoringZoom(other) {
+		if (other === void 0) return false;
+		return this._tileKeys === other._tileKeys && this._revision === other._revision;
+	}
+};
+//#endregion
 //#region src/webgl/render_to_texture.ts
 /**
 * lookup table which layers should rendered to texture
@@ -23254,6 +23694,7 @@ const LAYERS_TO_TEXTURES = {
 */
 var RenderToTexture = class {
 	constructor(painter, terrain) {
+		this.needsFollowUpFrame = false;
 		this.painter = painter;
 		this.terrain = terrain;
 		this.rttSize = terrain.tileManager.tileSize * terrain.qualityFactor;
@@ -23262,6 +23703,8 @@ var RenderToTexture = class {
 		return tile.getRTT(this._stacks.length - 1).texture;
 	}
 	prepareForRender(style, zoom) {
+		const zoomChanged = zoom !== this._lastPrepareZoom;
+		this._lastPrepareZoom = zoom;
 		this._stacks = [];
 		this._prevType = null;
 		this._rttTiles = [];
@@ -23292,11 +23735,15 @@ var RenderToTexture = class {
 			this._rttFingerprints[sourceId] = {};
 			const fingerprints = this._rttFingerprints[sourceId];
 			const revision = tileManager.getState().revision;
-			for (const key in coordsAscending) fingerprints[key] = `${coordsAscending[key].map((c) => c.key).sort().join()}#${revision}`;
+			for (const key in coordsAscending) fingerprints[key] = new RTTFingerprint(coordsAscending[key], revision, zoom);
 		}
+		this.needsFollowUpFrame = false;
 		for (const tile of this._renderableTiles) for (const source in this._rttFingerprints) {
-			const fingerprint = this._rttFingerprints[source][tile.tileID.key];
-			if (fingerprint && fingerprint !== tile.rttFingerprint[source]) tile.releaseRTT(this.painter);
+			const frameFingerprint = this._rttFingerprints[source][tile.tileID.key];
+			const tileFingerprint = tile.rttFingerprint[source];
+			if (!frameFingerprint || frameFingerprint.equals(tileFingerprint)) continue;
+			if (zoomChanged && frameFingerprint.equalsIgnoringZoom(tileFingerprint)) this.needsFollowUpFrame = true;
+			else tile.releaseRTT(this.painter);
 		}
 	}
 	/**
@@ -23351,6 +23798,7 @@ var RenderToTexture = class {
 					painter.renderLayer(painter, painter.style.tileManagers[layer.source], layer, coords, options);
 					if (layer.source) tile.rttFingerprint[layer.source] = this._rttFingerprints[layer.source][tile.tileID.key];
 				}
+				obj.texture.generateMipmap();
 			}
 			drawTerrain(this.painter, this.terrain, this._rttTiles, options);
 			this._rttTiles = [];
@@ -23504,6 +23952,7 @@ var Map$1 = class extends Evented {
 		this._renderTaskQueue = new TaskQueue();
 		this._controls = [];
 		this._mapId = uniqueId();
+		this._styleUrl = null;
 		this._missingStyleImageResolver = null;
 		this._lostContextStyle = {
 			style: null,
@@ -24396,6 +24845,7 @@ var Map$1 = class extends Evented {
 	}
 	/**
 	* Given a camera 'from' position and a position to look at (`to`), calculates zoom and camera rotation and returns them as {@link CameraOptions}.
+	* Under `globe` and `vertical-perspective` the calculation follows the sphere while the map renders as a globe, keeping the point looked at on the sea-level sphere; `altitudeTo` only becomes the center elevation.
 	* @param from - The camera to look from
 	* @param altitudeFrom - The altitude of the camera to look from
 	* @param to - The center to look at
@@ -24415,7 +24865,7 @@ var Map$1 = class extends Evented {
 	*/
 	calculateCameraOptionsFromTo(from, altitudeFrom, to, altitudeTo) {
 		if (altitudeTo == null && this.terrain) altitudeTo = this.terrain.getElevationForLngLat(to, this._camera.transform);
-		return this._camera.calculateCameraOptionsFromTo(from, altitudeFrom, to, altitudeTo);
+		return this._camera.transform.calculateCameraOptionsFromTo(from, altitudeFrom, to, altitudeTo ?? 0);
 	}
 	/**
 	* Resizes the map according to the dimensions of its
@@ -24484,6 +24934,8 @@ var Map$1 = class extends Evented {
 	* @internal
 	* Return the map's pixel ratio eventually scaled down to respect maxCanvasSize.
 	* Internally you should use this and not getPixelRatio().
+	* Warns once when the ratio is scaled down. The message carries no sizes: this runs on every
+	* resize and `warnOnce` de-duplicates by message, so sizes would warn on every drag frame.
 	*/
 	_getClampedPixelRatio(width, height) {
 		const { 0: maxCanvasWidth, 1: maxCanvasHeight } = this._maxCanvasSize;
@@ -24492,7 +24944,9 @@ var Map$1 = class extends Evented {
 		const canvasHeight = height * pixelRatio;
 		const widthScaleFactor = canvasWidth > maxCanvasWidth ? maxCanvasWidth / canvasWidth : 1;
 		const heightScaleFactor = canvasHeight > maxCanvasHeight ? maxCanvasHeight / canvasHeight : 1;
-		return Math.min(widthScaleFactor, heightScaleFactor) * pixelRatio;
+		const scaleFactor = Math.min(widthScaleFactor, heightScaleFactor);
+		if (scaleFactor < 1) warnOnce("The canvas is larger than maxCanvasSize and is rendered at a lower pixel ratio to fit. Increase maxCanvasSize, within MAX_TEXTURE_SIZE, to render at full resolution.");
+		return scaleFactor * pixelRatio;
 	}
 	/**
 	* Returns the map's pixel ratio.
@@ -25164,6 +25618,7 @@ var Map$1 = class extends Evented {
 			localIdeographFontFamily: this._localIdeographFontFamily,
 			validate: this._validateStyle
 		}, options);
+		this._styleUrl = typeof style === "string" ? style : null;
 		if (options.diff !== false && options.localIdeographFontFamily === this._localIdeographFontFamily && this.style && style) {
 			this._diffStyle(style, options);
 			return this;
@@ -25272,6 +25727,19 @@ var Map$1 = class extends Evented {
 		if (this.style) return this.style.serialize();
 	}
 	/**
+	* Returns the URL the map's style was loaded from.
+	*
+	* @returns The URL given to {@link Map.setStyle} or the `style` map option, or `null` when the style was given as an object or the map has no style.
+	*
+	* @example
+	* ```ts
+	* const styleUrl = map.getStyleUrl();
+	* ```
+	*/
+	getStyleUrl() {
+		return this._styleUrl;
+	}
+	/**
 	* @internal
 	* Returns the map's style and cloned images to restore context.
 	* @returns An object containing the style and images.
@@ -25749,7 +26217,7 @@ var Map$1 = class extends Evented {
 	* domains must support [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS).
 	*
 	* @param url - The URL of the image file. Image file must be in png, webp, or jpg format.
-	* @returns a promise that is resolved when the image is loaded
+	* @returns a promise that is resolved when the image is loaded, or rejected when the response has no image data (for example an HTTP 204)
 	*
 	* @example
 	* Load an image from an external URL.
@@ -25761,7 +26229,9 @@ var Map$1 = class extends Evented {
 	* @see [Add an icon to the map](https://maplibre.org/maplibre-gl-js/docs/examples/add-an-icon-to-the-map/)
 	*/
 	async loadImage(url) {
-		return ImageRequest.getImage(await this._requestManager.transformRequest(url, "Image"), new AbortController());
+		const response = await ImageRequest.getImage(await this._requestManager.transformRequest(url, "Image"), new AbortController());
+		if (!response.data) throw new Error(`Could not load image ${url}: the response is empty`);
+		return response;
 	}
 	/**
 	* Returns an Array of strings containing the IDs of all images currently available in the map.
@@ -26606,7 +27076,7 @@ var Map$1 = class extends Evented {
 		}
 		if (this.style && (this.style.hasTransitions() || crossFading)) this._styleDirty = true;
 		if (this.style && !this._placementDirty) this.style._releaseSymbolFadeTiles();
-		const somethingDirty = this._sourcesDirty || this._styleDirty || this._placementDirty;
+		const somethingDirty = this._sourcesDirty || this._styleDirty || this._placementDirty || this.painter.renderToTexture?.needsFollowUpFrame;
 		if (somethingDirty || this._repaint) this.triggerRepaint();
 		else if (!this.isMoving() && this.loaded()) this.fire(new MapLibreEvent("idle"));
 		if (this._loaded && !this._fullyLoaded && !somethingDirty) this._fullyLoaded = true;
@@ -27093,6 +27563,87 @@ const ARROW_KEY_DELTAS = {
 };
 const KEYBOARD_DRAG_SMALL_STEP = 1;
 const KEYBOARD_DRAG_LARGE_STEP = 10;
+/** Fill color of the default marker when {@link MarkerOptions.color} is not given. */
+const DEFAULT_MARKER_COLOR = "#3FB1CE";
+/** Height in CSS pixels of the default marker SVG at scale 1. */
+const DEFAULT_MARKER_HEIGHT = 41;
+/** Width in CSS pixels of the default marker SVG at scale 1. */
+const DEFAULT_MARKER_WIDTH = 27;
+const SVG_NS = "http://www.w3.org/2000/svg";
+/** Creates an SVG element with the given attributes, set in the order given, and children. */
+function svgElement(tag, attributes, children = []) {
+	const element = DOM.createNS(SVG_NS, tag);
+	for (const name in attributes) element.setAttributeNS(null, name, attributes[name]);
+	for (const child of children) element.appendChild(child);
+	return element;
+}
+/** The default marker SVG at scale 1 in the default color, built on first use and cloned per marker. */
+let defaultMarkerTemplate;
+/**
+* Returns the shared default marker SVG, building it the first time it is asked for. Assembling
+* the pin takes about fifty DOM calls, so each default {@link Marker} deep-clones this template
+* and overrides only its size and its fill, see {@link defaultMarkerFillGroup}.
+*/
+function getDefaultMarkerTemplate() {
+	if (defaultMarkerTemplate) return defaultMarkerTemplate;
+	const shadow = svgElement("g", {
+		transform: "translate(3.0, 29.0)",
+		fill: "#000000"
+	}, [
+		["10.5", "5.25002273"],
+		["10.5", "5.25002273"],
+		["9.5", "4.77275007"],
+		["8.5", "4.29549936"],
+		["7.5", "3.81822308"],
+		["6.5", "3.34094679"],
+		["5.5", "2.86367051"],
+		["4.5", "2.38636864"]
+	].map(([rx, ry]) => svgElement("ellipse", {
+		opacity: "0.04",
+		cx: "10.5",
+		cy: "5.80029008",
+		rx,
+		ry
+	})));
+	const background = svgElement("g", { fill: DEFAULT_MARKER_COLOR }, [svgElement("path", { d: "M27,13.5 C27,19.074644 20.250001,27.000002 14.75,34.500002 C14.016665,35.500004 12.983335,35.500004 12.25,34.500002 C6.7499993,27.000002 0,19.222562 0,13.5 C0,6.0441559 6.0441559,0 13.5,0 C20.955844,0 27,6.0441559 27,13.5 Z" })]);
+	const border = svgElement("g", {
+		opacity: "0.25",
+		fill: "#000000"
+	}, [svgElement("path", { d: "M13.5,0 C6.0441559,0 0,6.0441559 0,13.5 C0,19.222562 6.7499993,27 12.25,34.5 C13,35.522727 14.016664,35.500004 14.75,34.5 C20.250001,27 27,19.074644 27,13.5 C27,6.0441559 20.955844,0 13.5,0 Z M13.5,1 C20.415404,1 26,6.584596 26,13.5 C26,15.898657 24.495584,19.181431 22.220703,22.738281 C19.945823,26.295132 16.705119,30.142167 13.943359,33.908203 C13.743445,34.180814 13.612715,34.322738 13.5,34.441406 C13.387285,34.322738 13.256555,34.180814 13.056641,33.908203 C10.284481,30.127985 7.4148684,26.314159 5.015625,22.773438 C2.6163816,19.232715 1,15.953538 1,13.5 C1,6.584596 6.584596,1 13.5,1 Z" })]);
+	const maki = svgElement("g", {
+		transform: "translate(6.0, 7.0)",
+		fill: "#FFFFFF"
+	});
+	const circles = svgElement("g", { transform: "translate(8.0, 8.0)" }, [svgElement("circle", {
+		fill: "#000000",
+		opacity: "0.25",
+		cx: "5.5",
+		cy: "5.5",
+		r: "5.4999962"
+	}), svgElement("circle", {
+		fill: "#FFFFFF",
+		cx: "5.5",
+		cy: "5.5",
+		r: "5.4999962"
+	})]);
+	defaultMarkerTemplate = svgElement("svg", {
+		display: "block",
+		height: `${DEFAULT_MARKER_HEIGHT}px`,
+		width: `${DEFAULT_MARKER_WIDTH}px`,
+		viewBox: `0 0 ${DEFAULT_MARKER_WIDTH} ${DEFAULT_MARKER_HEIGHT}`
+	}, [svgElement("g", { "fill-rule": "nonzero" }, [
+		shadow,
+		background,
+		border,
+		maki,
+		circles
+	])]);
+	return defaultMarkerTemplate;
+}
+/** The group of a default marker SVG that carries the pin's fill color: the second child of its single top-level group. */
+function defaultMarkerFillGroup(svg) {
+	return svg.firstElementChild.children[1];
+}
 /**
 * The event class for marker drag events (`dragstart`, `drag` and `dragend`).
 *
@@ -27255,7 +27806,7 @@ var Marker = class extends Evented {
 			}
 		};
 		this._anchor = options?.anchor || "center";
-		this._color = options?.color || "#3FB1CE";
+		this._color = options?.color || DEFAULT_MARKER_COLOR;
 		this._scale = options?.scale || 1;
 		this._draggable = options?.draggable || false;
 		this._clickTolerance = options?.clickTolerance || 0;
@@ -27272,102 +27823,10 @@ var Marker = class extends Evented {
 		if (!options?.element) {
 			this._defaultMarker = true;
 			this._element = DOM.create("div");
-			const svg = DOM.createNS("http://www.w3.org/2000/svg", "svg");
-			const defaultHeight = 41;
-			const defaultWidth = 27;
-			svg.setAttributeNS(null, "display", "block");
-			svg.setAttributeNS(null, "height", `${defaultHeight}px`);
-			svg.setAttributeNS(null, "width", `${defaultWidth}px`);
-			svg.setAttributeNS(null, "viewBox", `0 0 ${defaultWidth} ${defaultHeight}`);
-			const markerLarge = DOM.createNS("http://www.w3.org/2000/svg", "g");
-			markerLarge.setAttributeNS(null, "stroke", "none");
-			markerLarge.setAttributeNS(null, "stroke-width", "1");
-			markerLarge.setAttributeNS(null, "fill", "none");
-			markerLarge.setAttributeNS(null, "fill-rule", "evenodd");
-			const page1 = DOM.createNS("http://www.w3.org/2000/svg", "g");
-			page1.setAttributeNS(null, "fill-rule", "nonzero");
-			const shadow = DOM.createNS("http://www.w3.org/2000/svg", "g");
-			shadow.setAttributeNS(null, "transform", "translate(3.0, 29.0)");
-			shadow.setAttributeNS(null, "fill", "#000000");
-			for (const data of [
-				{
-					"rx": "10.5",
-					"ry": "5.25002273"
-				},
-				{
-					"rx": "10.5",
-					"ry": "5.25002273"
-				},
-				{
-					"rx": "9.5",
-					"ry": "4.77275007"
-				},
-				{
-					"rx": "8.5",
-					"ry": "4.29549936"
-				},
-				{
-					"rx": "7.5",
-					"ry": "3.81822308"
-				},
-				{
-					"rx": "6.5",
-					"ry": "3.34094679"
-				},
-				{
-					"rx": "5.5",
-					"ry": "2.86367051"
-				},
-				{
-					"rx": "4.5",
-					"ry": "2.38636864"
-				}
-			]) {
-				const ellipse = DOM.createNS("http://www.w3.org/2000/svg", "ellipse");
-				ellipse.setAttributeNS(null, "opacity", "0.04");
-				ellipse.setAttributeNS(null, "cx", "10.5");
-				ellipse.setAttributeNS(null, "cy", "5.80029008");
-				ellipse.setAttributeNS(null, "rx", data["rx"]);
-				ellipse.setAttributeNS(null, "ry", data["ry"]);
-				shadow.appendChild(ellipse);
-			}
-			const background = DOM.createNS("http://www.w3.org/2000/svg", "g");
-			background.setAttributeNS(null, "fill", this._color);
-			const bgPath = DOM.createNS("http://www.w3.org/2000/svg", "path");
-			bgPath.setAttributeNS(null, "d", "M27,13.5 C27,19.074644 20.250001,27.000002 14.75,34.500002 C14.016665,35.500004 12.983335,35.500004 12.25,34.500002 C6.7499993,27.000002 0,19.222562 0,13.5 C0,6.0441559 6.0441559,0 13.5,0 C20.955844,0 27,6.0441559 27,13.5 Z");
-			background.appendChild(bgPath);
-			const border = DOM.createNS("http://www.w3.org/2000/svg", "g");
-			border.setAttributeNS(null, "opacity", "0.25");
-			border.setAttributeNS(null, "fill", "#000000");
-			const borderPath = DOM.createNS("http://www.w3.org/2000/svg", "path");
-			borderPath.setAttributeNS(null, "d", "M13.5,0 C6.0441559,0 0,6.0441559 0,13.5 C0,19.222562 6.7499993,27 12.25,34.5 C13,35.522727 14.016664,35.500004 14.75,34.5 C20.250001,27 27,19.074644 27,13.5 C27,6.0441559 20.955844,0 13.5,0 Z M13.5,1 C20.415404,1 26,6.584596 26,13.5 C26,15.898657 24.495584,19.181431 22.220703,22.738281 C19.945823,26.295132 16.705119,30.142167 13.943359,33.908203 C13.743445,34.180814 13.612715,34.322738 13.5,34.441406 C13.387285,34.322738 13.256555,34.180814 13.056641,33.908203 C10.284481,30.127985 7.4148684,26.314159 5.015625,22.773438 C2.6163816,19.232715 1,15.953538 1,13.5 C1,6.584596 6.584596,1 13.5,1 Z");
-			border.appendChild(borderPath);
-			const maki = DOM.createNS("http://www.w3.org/2000/svg", "g");
-			maki.setAttributeNS(null, "transform", "translate(6.0, 7.0)");
-			maki.setAttributeNS(null, "fill", "#FFFFFF");
-			const circleContainer = DOM.createNS("http://www.w3.org/2000/svg", "g");
-			circleContainer.setAttributeNS(null, "transform", "translate(8.0, 8.0)");
-			const circle1 = DOM.createNS("http://www.w3.org/2000/svg", "circle");
-			circle1.setAttributeNS(null, "fill", "#000000");
-			circle1.setAttributeNS(null, "opacity", "0.25");
-			circle1.setAttributeNS(null, "cx", "5.5");
-			circle1.setAttributeNS(null, "cy", "5.5");
-			circle1.setAttributeNS(null, "r", "5.4999962");
-			const circle2 = DOM.createNS("http://www.w3.org/2000/svg", "circle");
-			circle2.setAttributeNS(null, "fill", "#FFFFFF");
-			circle2.setAttributeNS(null, "cx", "5.5");
-			circle2.setAttributeNS(null, "cy", "5.5");
-			circle2.setAttributeNS(null, "r", "5.4999962");
-			circleContainer.appendChild(circle1);
-			circleContainer.appendChild(circle2);
-			page1.appendChild(shadow);
-			page1.appendChild(background);
-			page1.appendChild(border);
-			page1.appendChild(maki);
-			page1.appendChild(circleContainer);
-			svg.appendChild(page1);
-			svg.setAttributeNS(null, "height", `${defaultHeight * this._scale}px`);
-			svg.setAttributeNS(null, "width", `${defaultWidth * this._scale}px`);
+			const svg = getDefaultMarkerTemplate().cloneNode(true);
+			svg.setAttributeNS(null, "height", `${DEFAULT_MARKER_HEIGHT * this._scale}px`);
+			svg.setAttributeNS(null, "width", `${DEFAULT_MARKER_WIDTH * this._scale}px`);
+			defaultMarkerFillGroup(svg).setAttributeNS(null, "fill", this._color);
 			this._element.appendChild(svg);
 			this._offset = Point.convert(options?.offset || [0, -14]);
 		} else {
@@ -27484,8 +27943,8 @@ var Marker = class extends Evented {
 	setLngLat(lnglat) {
 		this._lngLat = LngLat.convert(lnglat);
 		this._pos = null;
-		if (this._popup) this._popup.setLngLat(this._lngLat);
 		this._update();
+		if (this._popup) this._popup.setLngLat(this._lngLat);
 		return this;
 	}
 	/**