Expose maxOverscaleFactorForParentTiles for custom geometry source (#2429)

Co-authored-by: Patrick Leonard <[email protected]>

Author: evil159

CHANGELOG.md

@@ -4,7 +4,7 @@ Mapbox welcomes participation and contributions from everyone.
 
 ## main
 
-* Added support for the `maxOverscaleFactorForParentTiles` property in `CustomRasterSource`, allowing greater control over tile overscaling behavior when rendering custom raster tiles.
+* Add support for the `maxOverscaleFactorForParentTiles` property in `CustomRasterSource` and `CustomGeometrySource`, allowing greater control over tile overscaling behavior when rendering custom raster tiles.
 
 ## 11.10.0-beta.1 - 20 January, 2025
 

Examples.xcodeproj/project.pbxproj

@@ -0,0 +1,106 @@
+import SwiftUI
+import MapboxMaps
+
+struct CustomGeometrySourceExample: View {
+    @StateObject private var model = Model()
+
+    var body: some View {
+        MapReader { proxy in
+            Map {
+                if let options = model.options {
+                    CustomGeometrySource(id: .customGeometrySource, options: options)
+                    LineLayer(id: "grid_layer", source: .customGeometrySource)
+                        .lineColor(.red)
+                }
+            }
+            .ignoresSafeArea()
+            .overlay(alignment: .bottom) {
+                sliderPanel
+            }
+            .onAppear {
+                model.options = model.makeCustomGeometrySourceOptions(for: proxy.map!)
+            }
+            .onChange(of: model.gridSpacing) { _ in
+                try? proxy.map!.invalidateCustomGeometrySourceRegion(forSourceId: .customGeometrySource, bounds: .world)
+            }
+        }
+    }
+
+    @ViewBuilder
+    var sliderPanel: some View {
+        VStack {
+            Text("Grid Spacing: \(model.gridSpacing, specifier: "%.2f")")
+            Slider(value: $model.gridSpacing, in: 0.01...10) {
+                Text("Grid Spacing")
+            } minimumValueLabel: {
+                Image(systemName: "grid")
+                    .font(.system(size: 12))
+            } maximumValueLabel: {
+                Image(systemName: "grid")
+                    .font(.system(size: 24))
+            }
+        }
+        .padding(10)
+        .floating(RoundedRectangle(cornerRadius: 10))
+        .limitPaneWidth()
+    }
+}
+
+private extension String {
+    static let customGeometrySource = "custom-raster-source"
+}
+
+private class Model: ObservableObject {
+    @Published var gridSpacing: Double = 7
+    @Published var options: CustomGeometrySourceOptions?
+
+    func makeCustomGeometrySourceOptions(for mapboxMap: MapboxMap) -> CustomGeometrySourceOptions {
+        return CustomGeometrySourceOptions(
+           fetchTileFunction: { [weak self] tileId in
+               guard let self else { return }
+
+               let neighborTile = CanonicalTileID(z: tileId.z, x: tileId.x + 1, y: tileId.y + 1)
+               let bounds = CoordinateBounds(
+                   southwest: CLLocationCoordinate2D(latitude: neighborTile.latitude, longitude: tileId.longitude),
+                   northeast: CLLocationCoordinate2D(latitude: tileId.latitude, longitude: neighborTile.longitude)
+               )
+
+               let latFrom = ceil(bounds.northeast.latitude / gridSpacing) * gridSpacing
+               let latTo = floor(bounds.southwest.latitude / gridSpacing) * gridSpacing
+               let latLines = stride(from: latFrom, through: latTo, by: -gridSpacing).map { lat in
+                   LineString([
+                       CLLocationCoordinate2D(latitude: lat, longitude: bounds.southwest.longitude),
+                       CLLocationCoordinate2D(latitude: lat, longitude: bounds.northeast.longitude)
+                   ])
+               }
+
+               let lonFrom = floor(bounds.southwest.longitude / gridSpacing) * gridSpacing
+               let lonTo = ceil(bounds.northeast.longitude / gridSpacing) * gridSpacing
+               let lonLines = stride(from: lonFrom, through: lonTo, by: gridSpacing).map { lng in
+                   LineString([
+                       CLLocationCoordinate2D(latitude: bounds.southwest.latitude, longitude: lng),
+                       CLLocationCoordinate2D(latitude: bounds.northeast.latitude, longitude: lng)
+                   ])
+               }
+               try! mapboxMap.setCustomGeometrySourceTileData(
+                   forSourceId: .customGeometrySource,
+                   tileId: tileId,
+                   features: (latLines + lonLines).map(Feature.init)
+               )
+           },
+           cancelTileFunction: { _ in },
+           tileOptions: TileOptions()
+       )
+    }
+}
+
+extension CanonicalTileID {
+    var latitude: CLLocationDegrees {
+        let n = Double.pi - 2.0 * Double.pi * Double(y) / pow(2.0, Double(z))
+        return (180.0 / .pi) * atan(0.5 * (exp(n) - exp(-n)))
+    }
+
+    var longitude: CLLocationDegrees {
+        return Double(x) / pow(2.0, Double(z)) * 360.0 - 180.0
+    }
+}

Sources/Examples/SwiftUI Examples/CustomGeometrySourceExample.swift

@@ -54,6 +54,7 @@ struct SwiftUIRoot: View {
                     }
 #endif
                     ExampleLink("Precipitation", note: "Show show and rain", destination: PrecipitationExample())
+                    ExampleLink("Custom geometry", note: "Supply custom geometry to the map", destination: CustomGeometrySourceExample())
 
                 } header: { Text("Testing Examples") }
             }

Sources/Examples/SwiftUI Examples/SwiftUIRoot.swift

@@ -19,10 +19,15 @@ public struct CustomGeometrySource: Source {
     /// - Note: Current implementation does not take into account resources allocated by the visible tiles.
     public var tileCacheBudget: TileCacheBudgetSize?
 
-    public init(id: String, options: CustomGeometrySourceOptions) {
+    /// When a set of tiles for a current zoom level is being rendered and some of the ideal tiles that cover the screen are not yet loaded, parent tiles could be used instead. Note that this might introduce unwanted rendering side-effects, especially for raster tiles that are overscaled multiple times. This property sets the maximum limit for how much a parent tile can be overscaled.
+    @_documentation(visibility: public)
+    public var maxOverscaleFactorForParentTiles: UInt8?
+
+    public init(id: String, options: CustomGeometrySourceOptions, maxOverscaleFactorForParentTiles: UInt8? = nil) {
         self.type = .customGeometry
         self.id = id
         self.options = options
+        self.maxOverscaleFactorForParentTiles = maxOverscaleFactorForParentTiles
     }
 }
 
@@ -31,6 +36,7 @@ extension CustomGeometrySource {
         case id
         case type
         case tileCacheBudget = "tile-cache-budget"
+        case maxOverscaleFactorForParentTiles = "max-overscale-factor-for-parent-tiles"
     }
 
     /// Init from a decoder, note that the CustomGeometrySourceOptions are not decodable and need to be set separately
@@ -40,6 +46,7 @@ extension CustomGeometrySource {
         type = try container.decode(SourceType.self, forKey: .type)
         tileCacheBudget = try container.decodeIfPresent(TileCacheBudgetSize.self, forKey: .tileCacheBudget)
         options = nil
+        maxOverscaleFactorForParentTiles = try container.decodeIfPresent(UInt8.self, forKey: .maxOverscaleFactorForParentTiles)
     }
 
     /// Encode, note that options will not be included
@@ -58,6 +65,7 @@ extension CustomGeometrySource {
 
     private func encodeVolatile(to encoder: Encoder, into container: inout KeyedEncodingContainer<CodingKeys>) throws {
         try container.encodeIfPresent(tileCacheBudget, forKey: .tileCacheBudget)
+        try container.encodeIfPresent(maxOverscaleFactorForParentTiles, forKey: .maxOverscaleFactorForParentTiles)
     }
 
     private func encodeNonVolatile(to encoder: Encoder, into container: inout KeyedEncodingContainer<CodingKeys>) throws {

Sources/MapboxMaps/Style/CustomSources/CustomGeometrySource.swift

@@ -53,9 +53,18 @@ final class CustomSourcesIntegrationTests: MapViewIntegrationTestCase {
         successfullyRetrievedSourceExpectation.expectedFulfillmentCount = 1
 
         mapView.mapboxMap.styleURI = .standard
+        let maxOverscaleFactorForParentTiles = UInt8(83)
 
         didFinishLoadingStyle = { mapView in
-            var source = CustomGeometrySource(id: "test-source", options: CustomGeometrySourceOptions(fetchTileFunction: { _ in }, cancelTileFunction: { _ in }, tileOptions: TileOptions()))
+            var source = CustomGeometrySource(
+                id: "test-source",
+                options: CustomGeometrySourceOptions(
+                    fetchTileFunction: { _ in },
+                    cancelTileFunction: { _ in },
+                    tileOptions: TileOptions()
+                ),
+                maxOverscaleFactorForParentTiles: maxOverscaleFactorForParentTiles
+            )
             source.tileCacheBudget = .testSourceValue(.megabytes(7))
 
             // Add source
@@ -70,6 +79,7 @@ final class CustomSourcesIntegrationTests: MapViewIntegrationTestCase {
             do {
                 let retrievedSource = try mapView.mapboxMap.source(withId: "test-source", type: CustomGeometrySource.self)
                 XCTAssertEqual(retrievedSource.tileCacheBudget, .testSourceValue(.megabytes(7)))
+                XCTAssertEqual(retrievedSource.maxOverscaleFactorForParentTiles, maxOverscaleFactorForParentTiles)
 
                 successfullyRetrievedSourceExpectation.fulfill()
             } catch {

Tests/MapboxMapsTests/Style/CustomSourcesIntegrationTests.swift

@@ -2064,5 +2064,6 @@ Func StyleManager.removeSnow() is now with @_documentation
 Func StyleManager.setRain(_:) is now with @_documentation
 Func StyleManager.setSnow(_:) is now with @_documentation
 
-# Add maxOverscaleFactorForParentTiles to CustomRasterSource constructor
+# Add maxOverscaleFactorForParentTiles to CustomRasterSource and CustomGeometrySource constructors
 Constructor CustomRasterSource.init(id:options:) has been removed
+Constructor CustomGeometrySource.init(id:options:) has been removed