• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

visgl / deck.gl / 21241467751

22 Jan 2026 08:31AM UTC coverage: 91.105% (-0.01%) from 91.115%
21241467751

Pull #9955

github

web-flow
Merge 46c735350 into 83ac41278
Pull Request #9955: chore(mapbox): Remove internal deck mode from `MapboxLayer`

6862 of 7538 branches covered (91.03%)

Branch coverage included in aggregate %.

63 of 63 new or added lines in 4 files covered. (100.0%)

13 existing lines in 1 file now uncovered.

56814 of 62355 relevant lines covered (91.11%)

14388.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.0
/modules/mapbox/src/deck-utils.ts
1
// deck.gl
1✔
2
// SPDX-License-Identifier: MIT
1✔
3
// Copyright (c) vis.gl contributors
1✔
4

1✔
5
import {Deck, MapView, _GlobeView as GlobeView, _flatten as flatten} from '@deck.gl/core';
1✔
6
import type {Viewport, MapViewState, Layer} from '@deck.gl/core';
1✔
7
import type {Parameters} from '@luma.gl/core';
1✔
8
import type MapboxLayer from './mapbox-layer';
1✔
9
import type MapboxLayerGroup from './mapbox-layer-group';
1✔
10
import type {LayerOverlayProps, Map} from './types';
1✔
11

1✔
12
import {lngLatToWorld, unitsPerMeter} from '@math.gl/web-mercator';
1✔
13

1✔
14
const MAPBOX_VIEW_ID = 'mapbox';
1✔
15

1✔
16
type UserData = {
1✔
17
  currentViewport?: Viewport | null;
1✔
18
  mapboxLayers: Set<MapboxLayer<any>>;
1✔
19
  // mapboxVersion: {minor: number; major: number};
1✔
20
};
1✔
21

1✔
22
// Mercator constants
1✔
23
const TILE_SIZE = 512;
1✔
24
const DEGREES_TO_RADIANS = Math.PI / 180;
1✔
25

1✔
26
// Create an interleaved deck instance.
1✔
27
export function getDeckInstance({
1✔
28
  map,
14✔
29
  deck
14✔
30
}: {
14✔
31
  map: Map & {__deck?: Deck<any> | null};
14✔
32
  deck: Deck<any>;
14✔
33
}): Deck<any> {
14✔
34
  // Only create one deck instance per context
14✔
35
  if (map.__deck) {
14!
UNCOV
36
    return map.__deck;
×
UNCOV
37
  }
×
38

14✔
39
  // Only initialize certain props once per context
14✔
40
  const customRender = deck.props._customRender;
14✔
41
  const onLoad = deck.props.onLoad;
14✔
42

14✔
43
  const deckProps = {
14✔
44
    ...deck.props,
14✔
45
    _customRender: () => {
14✔
46
      map.triggerRepaint();
15✔
47
      // customRender may be subscribed by DeckGL React component to update child props
15✔
48
      // make sure it is still called
15✔
49
      // Hack - do not pass a redraw reason here to prevent the React component from clearing the context
15✔
50
      // Rerender will be triggered by MapboxLayer's render()
15✔
51
      customRender?.('');
15!
52
    }
15✔
53
  };
14✔
54
  deckProps.parameters = {...getDefaultParameters(map, true), ...deckProps.parameters};
14✔
55
  deckProps.views ||= getDefaultView(map);
14✔
56

14✔
57
  // deck is using the WebGLContext created by mapbox,
14✔
58
  // block deck from setting the canvas size, and use the map's viewState to drive deck.
14✔
59
  Object.assign(deckProps, {
14✔
60
    width: null,
14✔
61
    height: null,
14✔
62
    touchAction: 'unset',
14✔
63
    viewState: getViewState(map)
14✔
64
  });
14✔
65
  if (deck.isInitialized) {
14✔
66
    watchMapMove(deck, map);
2✔
67
  } else {
14✔
68
    deckProps.onLoad = () => {
12✔
69
      onLoad?.();
10✔
70
      watchMapMove(deck, map);
10✔
71
    };
10✔
72
  }
12✔
73

14✔
74
  deck.setProps(deckProps);
14✔
75

14✔
76
  (deck.userData as UserData).mapboxLayers = new Set();
14✔
77
  map.__deck = deck;
14✔
78
  map.on('render', () => {
14✔
79
    if (deck.isInitialized) afterRender(deck, map);
17✔
80
  });
14✔
81

14✔
82
  return deck;
14✔
83
}
14✔
84

1✔
85
function watchMapMove(deck: Deck, map: Map & {__deck?: Deck | null}) {
12✔
86
  const _handleMapMove = () => {
12✔
87
    if (deck.isInitialized) {
1!
88
      // call view state methods
×
UNCOV
89
      onMapMove(deck, map);
×
90
    } else {
1✔
91
      // deregister itself when deck is finalized
1✔
92
      map.off('move', _handleMapMove);
1✔
93
    }
1✔
94
  };
1✔
95
  map.on('move', _handleMapMove);
12✔
96
}
12✔
97

1✔
98
export function removeDeckInstance(map: Map & {__deck?: Deck | null}) {
1✔
99
  map.__deck?.finalize();
10✔
100
  map.__deck = null;
10✔
101
}
10✔
102

1✔
103
export function getDefaultParameters(map: Map, interleaved: boolean): Parameters {
1✔
104
  const result: Parameters = interleaved
32✔
105
    ? {
28✔
106
        depthWriteEnabled: true,
28✔
107
        depthCompare: 'less-equal',
28✔
108
        depthBias: 0,
28✔
109
        blend: true,
28✔
110
        blendColorSrcFactor: 'src-alpha',
28✔
111
        blendColorDstFactor: 'one-minus-src-alpha',
28✔
112
        blendAlphaSrcFactor: 'one',
28✔
113
        blendAlphaDstFactor: 'one-minus-src-alpha',
28✔
114
        blendColorOperation: 'add',
28✔
115
        blendAlphaOperation: 'add'
28✔
116
      }
28✔
117
    : {};
4✔
118
  if (getProjection(map) === 'globe') {
32✔
119
    result.cullMode = 'back';
2✔
120
  }
2✔
121
  return result;
32✔
122
}
32✔
123

1✔
124
export function addLayer(deck: Deck, layer: MapboxLayer<any>): void {
1✔
125
  (deck.userData as UserData).mapboxLayers.add(layer);
18✔
126
}
18✔
127

1✔
128
export function removeLayer(deck: Deck, layer: MapboxLayer<any>): void {
1✔
129
  (deck.userData as UserData).mapboxLayers.delete(layer);
12✔
130
}
12✔
131

1✔
132
export function drawLayer(
1✔
133
  deck: Deck,
11✔
134
  map: Map,
11✔
135
  layer: MapboxLayer<any>,
11✔
136
  renderParameters: any
11✔
137
): void {
11✔
138
  let {currentViewport} = deck.userData as UserData;
11✔
139
  let clearStack: boolean = false;
11✔
140
  if (!currentViewport) {
11✔
141
    // This is the first layer drawn in this render cycle.
10✔
142
    // Generate viewport from the current map state.
10✔
143
    currentViewport = getViewport(deck, map, renderParameters);
10✔
144
    (deck.userData as UserData).currentViewport = currentViewport;
10✔
145
    clearStack = true;
10✔
146
  }
10✔
147

11✔
148
  if (!deck.isInitialized) {
11✔
149
    return;
1✔
150
  }
1✔
151

10✔
152
  deck._drawLayers('mapbox-repaint', {
10✔
153
    viewports: [currentViewport],
10✔
154
    layerFilter: params =>
10✔
155
      (!deck.props.layerFilter || deck.props.layerFilter(params)) &&
13✔
156
      (layer.id === params.layer.id || params.layer.props.operation.includes('terrain')),
10✔
157
    clearStack,
10✔
158
    clearCanvas: false
10✔
159
  });
10✔
160
}
10✔
161

1✔
162
export function drawLayerGroup(
1✔
163
  deck: Deck,
3✔
164
  map: Map,
3✔
165
  group: MapboxLayerGroup,
3✔
166
  renderParameters: any
3✔
167
): void {
3✔
168
  let {currentViewport} = deck.userData as UserData;
3✔
169
  let clearStack: boolean = false;
3✔
170
  if (!currentViewport) {
3✔
171
    // This is the first layer drawn in this render cycle.
3✔
172
    // Generate viewport from the current map state.
3✔
173
    currentViewport = getViewport(deck, map, renderParameters);
3✔
174
    (deck.userData as UserData).currentViewport = currentViewport;
3✔
175
    clearStack = true;
3✔
176
  }
3✔
177

3✔
178
  if (!deck.isInitialized) {
3!
179
    return;
×
UNCOV
180
  }
×
181

3✔
182
  deck._drawLayers('mapbox-repaint', {
3✔
183
    viewports: [currentViewport],
3✔
184
    layerFilter: params => {
3✔
185
      if (deck.props.layerFilter && !deck.props.layerFilter(params)) {
4!
186
        return false;
×
UNCOV
187
      }
×
188

4✔
189
      const layer = params.layer as Layer<LayerOverlayProps>;
4✔
190
      if (layer.props.beforeId === group.beforeId && layer.props.slot === group.slot) {
4✔
191
        return true;
4✔
192
      }
4!
UNCOV
193
      return false;
×
194
    },
4✔
195
    clearStack,
3✔
196
    clearCanvas: false
3✔
197
  });
3✔
198
}
3✔
199

1✔
200
export function getProjection(map: Map): 'mercator' | 'globe' {
1✔
201
  const projection = map.getProjection?.();
65✔
202
  const type =
65✔
203
    // maplibre projection spec
65✔
204
    projection?.type ||
65!
205
    // mapbox projection spec
×
UNCOV
206
    projection?.name;
×
207
  if (type === 'globe') {
65✔
208
    return 'globe';
5✔
209
  }
5✔
210
  if (type && type !== 'mercator') {
65!
211
    throw new Error('Unsupported projection');
×
UNCOV
212
  }
✔
213
  return 'mercator';
60✔
214
}
60✔
215

1✔
216
export function getDefaultView(map: Map): GlobeView | MapView {
1✔
217
  if (getProjection(map) === 'globe') {
25✔
218
    return new GlobeView({id: MAPBOX_VIEW_ID});
2✔
219
  }
2✔
220
  return new MapView({id: MAPBOX_VIEW_ID});
23✔
221
}
23✔
222

1✔
223
export function getViewState(map: Map): MapViewState & {
1✔
224
  repeat: boolean;
35✔
225
  padding: {
35✔
226
    left: number;
35✔
227
    right: number;
35✔
228
    top: number;
35✔
229
    bottom: number;
35✔
230
  };
35✔
231
} {
35✔
232
  const {lng, lat} = map.getCenter();
35✔
233

35✔
234
  const viewState: MapViewState & {
35✔
235
    repeat: boolean;
35✔
236
    padding: {
35✔
237
      left: number;
35✔
238
      right: number;
35✔
239
      top: number;
35✔
240
      bottom: number;
35✔
241
    };
35✔
242
  } = {
35✔
243
    // Longitude returned by getCenter can be outside of [-180, 180] when zooming near the anti meridian
35✔
244
    // https://github.com/visgl/deck.gl/issues/6894
35✔
245
    longitude: ((lng + 540) % 360) - 180,
35✔
246
    latitude: lat,
35✔
247
    zoom: map.getZoom(),
35✔
248
    bearing: map.getBearing(),
35✔
249
    pitch: map.getPitch(),
35✔
250
    padding: map.getPadding(),
35✔
251
    repeat: map.getRenderWorldCopies()
35✔
252
  };
35✔
253

35✔
254
  if (map.getTerrain?.()) {
35!
255
    // When the base map has terrain, we need to target the camera at the terrain surface
×
256
    centerCameraOnTerrain(map, viewState);
×
UNCOV
257
  }
×
258

35✔
259
  return viewState;
35✔
260
}
35✔
261

1✔
262
function centerCameraOnTerrain(map: Map, viewState: MapViewState) {
×
263
  if (map.getFreeCameraOptions) {
×
264
    // mapbox-gl v2
×
265
    const {position} = map.getFreeCameraOptions();
×
266
    if (!position || position.z === undefined) {
×
267
      return;
×
268
    }
×
269

×
270
    // @ts-ignore transform is not typed
×
271
    const height = map.transform.height;
×
272
    const {longitude, latitude, pitch} = viewState;
×
273

×
274
    // Convert mapbox mercator coordinate to deck common space
×
275
    const cameraX = position.x * TILE_SIZE;
×
276
    const cameraY = (1 - position.y) * TILE_SIZE;
×
277
    const cameraZ = position.z * TILE_SIZE;
×
278

×
279
    // Mapbox manipulates zoom in terrain mode, see discussion here: https://github.com/mapbox/mapbox-gl-js/issues/12040
×
280
    const center = lngLatToWorld([longitude, latitude]);
×
281
    const dx = cameraX - center[0];
×
282
    const dy = cameraY - center[1];
×
283
    const cameraToCenterDistanceGround = Math.sqrt(dx * dx + dy * dy);
×
284

×
285
    const pitchRadians = pitch! * DEGREES_TO_RADIANS;
×
286
    const altitudePixels = 1.5 * height;
×
287
    const scale =
×
288
      pitchRadians < 0.001
×
289
        ? // Pitch angle too small to deduce the look at point, assume elevation is 0
×
290
          (altitudePixels * Math.cos(pitchRadians)) / cameraZ
×
291
        : (altitudePixels * Math.sin(pitchRadians)) / cameraToCenterDistanceGround;
×
292
    viewState.zoom = Math.log2(scale);
×
293

×
294
    const cameraZFromSurface = (altitudePixels * Math.cos(pitchRadians)) / scale;
×
295
    const surfaceElevation = cameraZ - cameraZFromSurface;
×
296
    viewState.position = [0, 0, surfaceElevation / unitsPerMeter(latitude)];
×
297
  }
×
298
  // @ts-ignore transform is not typed
×
299
  else if (typeof map.transform.elevation === 'number') {
×
300
    // maplibre-gl
×
301
    // @ts-ignore transform is not typed
×
302
    viewState.position = [0, 0, map.transform.elevation];
×
303
  }
×
UNCOV
304
}
×
305

1✔
306
// Since maplibre-gl@5
1✔
307
// https://github.com/maplibre/maplibre-gl-js/blob/main/src/style/style_layer/custom_style_layer.ts
1✔
308
type MaplibreRenderParameters = {
1✔
309
  farZ: number;
1✔
310
  nearZ: number;
1✔
311
  fov: number;
1✔
312
  modelViewProjectionMatrix: number[];
1✔
313
  projectionMatrix: number[];
1✔
314
};
1✔
315

1✔
316
function getViewport(deck: Deck, map: Map, renderParameters?: unknown): Viewport {
17✔
317
  const viewState = getViewState(map);
17✔
318
  const {views} = deck.props;
17✔
319
  const view =
17✔
320
    (views && flatten(views).find((v: {id: string}) => v.id === MAPBOX_VIEW_ID)) ||
17✔
321
    getDefaultView(map);
1✔
322

17✔
323
  if (renderParameters) {
17!
324
    // Called from MapboxLayer.render
×
325
    // Magic number, matches mapbox-gl@>=1.3.0's projection matrix
×
326
    view.props.nearZMultiplier = 0.2;
×
UNCOV
327
  }
×
328

17✔
329
  // Get the base map near/far plane
17✔
330
  // renderParameters is maplibre API but not mapbox
17✔
331
  // Transform is not an official API, properties could be undefined for older versions
17✔
332
  const nearZ = (renderParameters as MaplibreRenderParameters)?.nearZ ?? map.transform._nearZ;
17!
333
  const farZ = (renderParameters as MaplibreRenderParameters)?.farZ ?? map.transform._farZ;
17!
334
  if (Number.isFinite(nearZ)) {
17!
335
    viewState.nearZ = nearZ / map.transform.height;
×
336
    viewState.farZ = farZ / map.transform.height;
×
UNCOV
337
  }
×
338
  // Otherwise fallback to default calculation using nearZMultiplier/farZMultiplier
17✔
339

17✔
340
  return view.makeViewport({
17✔
341
    width: deck.width,
17✔
342
    height: deck.height,
17✔
343
    viewState
17✔
344
  }) as Viewport;
17✔
345
}
17✔
346

1✔
347
function afterRender(deck: Deck, map: Map): void {
16✔
348
  const {mapboxLayers} = deck.userData as UserData;
16✔
349

16✔
350
  // Draw non-Mapbox layers
16✔
351
  const mapboxLayerIds = Array.from(mapboxLayers, layer => layer.id);
16✔
352
  const deckLayers = flatten(deck.props.layers, Boolean) as Layer[];
16✔
353
  const hasNonMapboxLayers = deckLayers.some(layer => layer && !mapboxLayerIds.includes(layer.id));
16✔
354
  let viewports = deck.getViewports();
16✔
355
  const mapboxViewportIdx = viewports.findIndex(vp => vp.id === MAPBOX_VIEW_ID);
16✔
356
  const hasNonMapboxViews = viewports.length > 1 || mapboxViewportIdx < 0;
16✔
357

16✔
358
  if (hasNonMapboxLayers || hasNonMapboxViews) {
16✔
359
    if (mapboxViewportIdx >= 0) {
5✔
360
      viewports = viewports.slice();
4✔
361
      viewports[mapboxViewportIdx] = getViewport(deck, map);
4✔
362
    }
4✔
363

5✔
364
    deck._drawLayers('mapbox-repaint', {
5✔
365
      viewports,
5✔
366
      layerFilter: params =>
5✔
367
        (!deck.props.layerFilter || deck.props.layerFilter(params)) &&
9✔
368
        (params.viewport.id !== MAPBOX_VIEW_ID || !mapboxLayerIds.includes(params.layer.id)),
7✔
369
      clearCanvas: false
5✔
370
    });
5✔
371
  }
5✔
372

16✔
373
  // End of render cycle, clear generated viewport
16✔
374
  (deck.userData as UserData).currentViewport = null;
16✔
375
}
16✔
376

1✔
377
function onMapMove(deck: Deck, map: Map): void {
×
378
  deck.setProps({
×
379
    viewState: getViewState(map)
×
380
  });
×
381
  // Camera changed, will trigger a map repaint right after this
×
382
  // Clear any change flag triggered by setting viewState so that deck does not request
×
383
  // a second repaint
×
384
  deck.needsRedraw({clearRedrawFlags: true});
×
UNCOV
385
}
×
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc