mapsglmaps/com.xweather.mapsgl.sources/EncodedGridVectorTileSource

EncodedGridVectorTileSource

class EncodedGridVectorTileSource(val id: String, encodedSource: XweatherEncodedTileSource, gridSpacing: Double, iconEncodedColorScale: ColorScaleOptions? = null, iconEncodedScalarMax: Double? = null, val timelineMeldInvalidatesMapboxTiles: Boolean = true, instancedQuadMonochromeWhite: Boolean = false) : VectorTileSource

Sidecar vector source for gridded/symbol layers backed by XweatherEncodedTileSource.

Mapbox requests geometry per tile via requestTile; features are placed on a global Web Mercator world-pixel grid (512×2^zoom) for even screen spacing. Wind uses G/B u/v (atan2(u,-v); sampleFieldsFromEncodedRgb). Maritime *_dir.fill (instancedQuadMonochromeWhite) uses blue-only scalar degrees like JS EXPRESSION_ANGLE (norm * 360 - 180, wrapped to 0–360°).

Constructors

constructor(id: String, encodedSource: XweatherEncodedTileSource, gridSpacing: Double, iconEncodedColorScale: ColorScaleOptions? = null, iconEncodedScalarMax: Double? = null, timelineMeldInvalidatesMapboxTiles: Boolean = true, instancedQuadMonochromeWhite: Boolean = false)

Types

Companion

object Companion

Properties

_shouldTriggerLoadCompleteEvent

var _shouldTriggerLoadCompleteEvent: Boolean

animTileList

val animTileList: MutableList<String>

authenticator

open var authenticator: XweatherAuthenticator?

bounds

var bounds: LatLonBounds?

consumers

val consumers: MutableList<DataSourceConsumer>

datasets

open var datasets: List<DatasetType>

dlCount

var dlCount: Int

eventDispatcher

open override val eventDispatcher: EventDispatcher

open override val id: String

The unique identifier for the data source.

isEncoded

open val isEncoded: Boolean

isLoading

var isLoading: Boolean

isReady

open override var isReady: Boolean

Indicates whether the data source is ready to be used by consuming layers, which may be false if data has not been loaded from a remote source yet or the data has not been fully prepared for rendering.

isReady

val TileSource<DataType>.isReady: Boolean

kind

open override val kind: DataSourceKind

type in MapsGL JS

maxZoom

var maxZoom: Float

maxZoom

val TileSource<DataType>.maxZoom: Float

metadata

lateinit var metadata: SourceMetadata<MetadataType>

metaDataNeeded

var metaDataNeeded: Int

metadataObserver

val metadataObserver: VariableObserver

metadataURL

var metadataURL: String?

minZoom

var minZoom: Float

minZoom

val TileSource<DataType>.minZoom: Float

needsMetadata

val TileSource<DataType>.needsMetadata: Boolean

tileCache

open override var tileCache: TileCache<DataType>

tileManager

open var tileManager: TileRequestManager<VectorData>

tiles

val TileSource<DataType>.tiles: TileCache<DataType>

tileSize

var tileSize: TileSize

tileSize

val TileSource<DataType>.tileSize: TileSize

tileURL

var tileURL: String?

timelineMeldInvalidatesMapboxTiles

val timelineMeldInvalidatesMapboxTiles: Boolean = true

Mapbox symbol overlays need timeline meld invalidation so custom-geometry tiles refetch blended icons. Instanced GL wind barbs meld on the GPU (com.xweather.mapsgl.anim.Timeline.dataMeld) and skip this work.

timeRange

open override var timeRange: ClosedRange<Date>?

type

val DataSource.type: DataSourceKind

validTime

var validTime: Date

validTimes

var validTimes: List<Date>?

Functions

abortTile

fun abortTile(x: Int, y: Int, z: Int)

addConsumer

open override fun addConsumer(consumer: DataSourceConsumer)

Adds a map layer as a consumer of the data source.

addToAnimationQueue

fun addToAnimationQueue(inputString: String)

adjustDateBySeconds

fun adjustDateBySeconds(dateString: String, offsetSeconds: Long): String?

Used by prepareTileRequest() to increment or decremnet the time and reformate it for sources with time offets

applyIconColorOptions

fun applyIconColorOptions(scale: ColorScaleOptions?, encodedScalarMax: Double?)

Rebuilds the CPU palette used for instanced wind barb/arrow RGB when SamplePaint.colorScale or SamplePaint.encodedScalarNormMax changes. Safe to call when reusing a cached gridVector sidecar source.

buildInstancedWindBufferDualPhase

suspend fun buildInstancedWindBufferDualPhase(coords: List<TileCoord>, mapZoom: Double, visibleGeoBounds: VisibleGeoBounds?, maxInstances: Int, viewportGridMarginWorldPx: Double = 0.0, viewportExtraEastFraction: Double = 0.0): Pair<FloatArray, Int>

Packed instanced wind barbs: endpoint phase A and B only (no Timeline.dataMeld in sampling). Matches encoded raster layers: the GPU applies dataMeld each frame so timeline crossfade stays smooth without rebuilding this buffer at playback frame rate.

contains

open fun contains(coord: TileCoord): Boolean

contains

fun <DataType : TileData> TileSource<DataType>.contains(coord: TileCoord): Boolean

fetchMetadata

open suspend override fun fetchMetadata(startDate: Date?, endDate: Date?): Result<Unit>

Returns the metadata for the source, which can be loaded from a remote source.

getMetadataURL

open override fun getMetadataURL(): URL?

getTileData

open override fun getTileData(coord: TileCoord): Any?

init

fun <DataType : TileData> TileSource<DataType>.init(id: String, authenticator: Authenticator<MediaSession.Token>?)

inspectorSampleMaritimeDirDeg

fun inspectorSampleMaritimeDirDeg(lon: Double, latDeg: Double, mapZoom: Double): Float?

Data inspector for maritime *_dir.fill: bilinear sample at lon/latDeg using the same placement zoom as buildInstancedWindBufferDualPhase (stablePlacementZoomInt\(mapZoom\)), then vector-blend phases like the GPU. Nearest-neighbor tile bytes in EncodedTileLayer do not match instanced sampling.

intervalToURLTime

fun intervalToURLTime(intervalTime: String): String

convert from \"2025-04-22T03:49:31Z\" to 20250422030000

invalidate

open override fun invalidate()

invalidateDynamicIconData

fun invalidateDynamicIconData()

Timeline-only invalidation: keep cached placement geometry, refresh only sampled icon properties.

makeTileURL

fun makeTileURL(coord: TileCoord, variables: Map<String, Any>?): URL

mergeFeaturesForTiles

suspend fun mergeFeaturesForTiles(coords: List<TileCoord>, mapZoom: Double, visibleGeoBounds: VisibleGeoBounds?): List<Pair<TileCoord, Feature>>

Same feature generation as the Mapbox sidecar path, merged for OpenGL instanced drawing (no Mapbox vector layer).

onLoadFailed

fun onLoadFailed()

onTileError

fun onTileError(tile: TileType, error: Error)

parseTile

suspend fun parseTile(tile: TileType, data: ByteArray, headers: <Error class: unknown class><Any, Any>?): Bitmap

publisher

inline fun <EventType : Event> EventSource.publisher(eventType: Class<EventType>): Flow<EventType>

removeConsumer

open override fun removeConsumer(layerId: String)

Removes a map layer as a consumer of the data source.

removeFromAnimationQueue

fun removeFromAnimationQueue(inputString: String)

requestTile

open suspend override fun requestTile(x: Int, y: Int, z: Int, mapZoomForDensity: Double?, visibleGeoBounds: VisibleGeoBounds?): VectorData?

requestTiles

open suspend override fun requestTiles(coord: TileCoord, options: TileRequestOptions, currentDate: String, fromAnimation: Boolean, intervals: List<String>?): Any

setBatchInvalidateFunction

fun setBatchInvalidateFunction(batchInvalidateFunction: (List<Triple<Int, Int, Int>>) -> Unit?)

setInvalidateFunction

fun setInvalidateFunction(invalidateFunction: (Int, Int, Int) -> Unit?)

shouldRequestTile

fun shouldRequestTile(tile: TileType, reload: Boolean): Boolean

shouldRequestTile

fun <DataType : TileData> TileSource<DataType>.shouldRequestTile(tile: TileType, reload: Boolean): Boolean

inline suspend fun <EventType : Event> EventSource.subscribe(eventType: Class<EventType>, crossinline handler: (EventType) -> Unit)

syncGridSpacingFromPaint

fun syncGridSpacingFromPaint(authoredSpacing: Double, displayDensity: Float)

JS GridPaint.spacing is in logical px; instanced gridded placement uses authored × density × 0.5 (same density convention as com.xweather.mapsgl.renderers.GridLayerRenderer icon sizing). Safe when reusing a cached sidecar: bumps spacing and invalidates placement caches when the effective value changes.

trigger

fun <EventType : Event> EventSource.trigger(event: EventType)