@scoova/mgl 1.0.0

package/src/render/draw_hillshade.ts

@@ -0,0 +1,119 @@
+import {Texture} from './texture';
+import {StencilMode} from '../gl/stencil_mode';
+import {DepthMode} from '../gl/depth_mode';
+import {CullFaceMode} from '../gl/cull_face_mode';
+import {ColorMode} from '../gl/color_mode';
+import {Tile} from '../source/tile';
+import {
+    hillshadeUniformValues,
+    hillshadeUniformPrepareValues
+} from './program/hillshade_program';
+
+import type {Painter} from './painter';
+import type {SourceCache} from '../source/source_cache';
+import type {HillshadeStyleLayer} from '../style/style_layer/hillshade_style_layer';
+import type {OverscaledTileID} from '../source/tile_id';
+
+export function drawHillshade(painter: Painter, sourceCache: SourceCache, layer: HillshadeStyleLayer, tileIDs: Array<OverscaledTileID>) {
+    if (painter.renderPass !== 'offscreen' && painter.renderPass !== 'translucent') return;
+
+    const context = painter.context;
+
+    const depthMode = painter.depthModeForSublayer(0, DepthMode.ReadOnly);
+    const colorMode = painter.colorModeForRenderPass();
+
+    const [stencilModes, coords] = painter.renderPass === 'translucent' ?
+        painter.stencilConfigForOverlap(tileIDs) : [{}, tileIDs];
+
+    for (const coord of coords) {
+        const tile = sourceCache.getTile(coord);
+        if (typeof tile.needsHillshadePrepare !== 'undefined' && tile.needsHillshadePrepare && painter.renderPass === 'offscreen') {
+            prepareHillshade(painter, tile, layer, depthMode, StencilMode.disabled, colorMode);
+        } else if (painter.renderPass === 'translucent') {
+            renderHillshade(painter, coord, tile, layer, depthMode, stencilModes[coord.overscaledZ], colorMode);
+        }
+    }
+
+    context.viewport.set([0, 0, painter.width, painter.height]);
+}
+
+function renderHillshade(
+    painter: Painter,
+    coord: OverscaledTileID,
+    tile: Tile,
+    layer: HillshadeStyleLayer,
+    depthMode: Readonly<DepthMode>,
+    stencilMode: Readonly<StencilMode>,
+    colorMode: Readonly<ColorMode>) {
+    const context = painter.context;
+    const gl = context.gl;
+    const fbo = tile.fbo;
+    if (!fbo) return;
+
+    const program = painter.useProgram('hillshade');
+    const terrainData = painter.style.map.terrain && painter.style.map.terrain.getTerrainData(coord);
+
+    context.activeTexture.set(gl.TEXTURE0);
+    gl.bindTexture(gl.TEXTURE_2D, fbo.colorAttachment.get());
+
+    const terrainCoord = terrainData ? coord : null;
+    program.draw(context, gl.TRIANGLES, depthMode, stencilMode, colorMode, CullFaceMode.disabled,
+        hillshadeUniformValues(painter, tile, layer, terrainCoord), terrainData, layer.id, painter.rasterBoundsBuffer,
+        painter.quadTriangleIndexBuffer, painter.rasterBoundsSegments);
+
+}
+
+// hillshade rendering is done in two steps. the prepare step first calculates the slope of the terrain in the x and y
+// directions for each pixel, and saves those values to a framebuffer texture in the r and g channels.
+function prepareHillshade(
+    painter: Painter,
+    tile: Tile,
+    layer: HillshadeStyleLayer,
+    depthMode: Readonly<DepthMode>,
+    stencilMode: Readonly<StencilMode>,
+    colorMode: Readonly<ColorMode>) {
+    const context = painter.context;
+    const gl = context.gl;
+    const dem = tile.dem;
+    if (dem && dem.data) {
+        const tileSize = dem.dim;
+        const textureStride = dem.stride;
+
+        const pixelData = dem.getPixels();
+        context.activeTexture.set(gl.TEXTURE1);
+
+        context.pixelStoreUnpackPremultiplyAlpha.set(false);
+        tile.demTexture = tile.demTexture || painter.getTileTexture(textureStride);
+        if (tile.demTexture) {
+            const demTexture = tile.demTexture;
+            demTexture.update(pixelData, {premultiply: false});
+            demTexture.bind(gl.NEAREST, gl.CLAMP_TO_EDGE);
+        } else {
+            tile.demTexture = new Texture(context, pixelData, gl.RGBA, {premultiply: false});
+            tile.demTexture.bind(gl.NEAREST, gl.CLAMP_TO_EDGE);
+        }
+
+        context.activeTexture.set(gl.TEXTURE0);
+
+        let fbo = tile.fbo;
+
+        if (!fbo) {
+            const renderTexture = new Texture(context, {width: tileSize, height: tileSize, data: null}, gl.RGBA);
+            renderTexture.bind(gl.LINEAR, gl.CLAMP_TO_EDGE);
+
+            fbo = tile.fbo = context.createFramebuffer(tileSize, tileSize, true, false);
+            fbo.colorAttachment.set(renderTexture.texture);
+        }
+
+        context.bindFramebuffer.set(fbo.framebuffer);
+        context.viewport.set([0, 0, tileSize, tileSize]);
+
+        painter.useProgram('hillshadePrepare').draw(context, gl.TRIANGLES,
+            depthMode, stencilMode, colorMode, CullFaceMode.disabled,
+            hillshadeUniformPrepareValues(tile.tileID, dem),
+            null, layer.id, painter.rasterBoundsBuffer,
+            painter.quadTriangleIndexBuffer, painter.rasterBoundsSegments);
+
+        tile.needsHillshadePrepare = false;
+    }
+}

package/src/render/draw_line.ts

@@ -0,0 +1,125 @@
+import {DepthMode} from '../gl/depth_mode';
+import {CullFaceMode} from '../gl/cull_face_mode';
+import {Texture} from './texture';
+import {
+    lineUniformValues,
+    linePatternUniformValues,
+    lineSDFUniformValues,
+    lineGradientUniformValues
+} from './program/line_program';
+
+import type {Painter} from './painter';
+import type {SourceCache} from '../source/source_cache';
+import type {LineStyleLayer} from '../style/style_layer/line_style_layer';
+import type {LineBucket} from '../data/bucket/line_bucket';
+import type {OverscaledTileID} from '../source/tile_id';
+import {clamp, nextPowerOfTwo} from '../util/util';
+import {renderColorRamp} from '../util/color_ramp';
+import {EXTENT} from '../data/extent';
+
+export function drawLine(painter: Painter, sourceCache: SourceCache, layer: LineStyleLayer, coords: Array<OverscaledTileID>) {
+    if (painter.renderPass !== 'translucent') return;
+
+    const opacity = layer.paint.get('line-opacity');
+    const width = layer.paint.get('line-width');
+    if (opacity.constantOr(1) === 0 || width.constantOr(1) === 0) return;
+
+    const depthMode = painter.depthModeForSublayer(0, DepthMode.ReadOnly);
+    const colorMode = painter.colorModeForRenderPass();
+
+    const dasharray = layer.paint.get('line-dasharray');
+    const patternProperty = layer.paint.get('line-pattern');
+    const image = patternProperty.constantOr(1 as any);
+
+    const gradient = layer.paint.get('line-gradient');
+    const crossfade = layer.getCrossfadeParameters();
+
+    const programId =
+        image ? 'linePattern' :
+            dasharray ? 'lineSDF' :
+                gradient ? 'lineGradient' : 'line';
+
+    const context = painter.context;
+    const gl = context.gl;
+
+    let firstTile = true;
+
+    for (const coord of coords) {
+        const tile = sourceCache.getTile(coord);
+
+        if (image && !tile.patternsLoaded()) continue;
+
+        const bucket: LineBucket = (tile.getBucket(layer) as any);
+        if (!bucket) continue;
+
+        const programConfiguration = bucket.programConfigurations.get(layer.id);
+        const prevProgram = painter.context.program.get();
+        const program = painter.useProgram(programId, programConfiguration);
+        const programChanged = firstTile || program.program !== prevProgram;
+        const terrainData = painter.style.map.terrain &&  painter.style.map.terrain.getTerrainData(coord);
+
+        const constantPattern = patternProperty.constantOr(null);
+        if (constantPattern && tile.imageAtlas) {
+            const atlas = tile.imageAtlas;
+            const posTo = atlas.patternPositions[constantPattern.to.toString()];
+            const posFrom = atlas.patternPositions[constantPattern.from.toString()];
+            if (posTo && posFrom) programConfiguration.setConstantPatternPositions(posTo, posFrom);
+        }
+
+        const terrainCoord = terrainData ? coord : null;
+        const uniformValues = image ? linePatternUniformValues(painter, tile, layer, crossfade, terrainCoord) :
+            dasharray ? lineSDFUniformValues(painter, tile, layer, dasharray, crossfade, terrainCoord) :
+                gradient ? lineGradientUniformValues(painter, tile, layer, bucket.lineClipsArray.length, terrainCoord) :
+                    lineUniformValues(painter, tile, layer, terrainCoord);
+
+        if (image) {
+            context.activeTexture.set(gl.TEXTURE0);
+            tile.imageAtlasTexture.bind(gl.LINEAR, gl.CLAMP_TO_EDGE);
+            programConfiguration.updatePaintBuffers(crossfade);
+        } else if (dasharray && (programChanged || painter.lineAtlas.dirty)) {
+            context.activeTexture.set(gl.TEXTURE0);
+            painter.lineAtlas.bind(context);
+        } else if (gradient) {
+            const layerGradient = bucket.gradients[layer.id];
+            let gradientTexture = layerGradient.texture;
+            if (layer.gradientVersion !== layerGradient.version) {
+                let textureResolution = 256;
+                if (layer.stepInterpolant) {
+                    const sourceMaxZoom = sourceCache.getSource().maxzoom;
+                    const potentialOverzoom = coord.canonical.z === sourceMaxZoom ?
+                        Math.ceil(1 << (painter.transform.maxZoom - coord.canonical.z)) : 1;
+                    const lineLength = bucket.maxLineLength / EXTENT;
+                    // Logical pixel tile size is 512px, and 1024px right before current zoom + 1
+                    const maxTilePixelSize = 1024;
+                    // Maximum possible texture coverage heuristic, bound by hardware max texture size
+                    const maxTextureCoverage = lineLength * maxTilePixelSize * potentialOverzoom;
+                    textureResolution = clamp(nextPowerOfTwo(maxTextureCoverage), 256, context.maxTextureSize);
+                }
+                layerGradient.gradient = renderColorRamp({
+                    expression: layer.gradientExpression(),
+                    evaluationKey: 'lineProgress',
+                    resolution: textureResolution,
+                    image: layerGradient.gradient || undefined,
+                    clips: bucket.lineClipsArray
+                });
+                if (layerGradient.texture) {
+                    layerGradient.texture.update(layerGradient.gradient);
+                } else {
+                    layerGradient.texture = new Texture(context, layerGradient.gradient, gl.RGBA);
+                }
+                layerGradient.version = layer.gradientVersion;
+                gradientTexture = layerGradient.texture;
+            }
+            context.activeTexture.set(gl.TEXTURE0);
+            gradientTexture.bind(layer.stepInterpolant ? gl.NEAREST : gl.LINEAR, gl.CLAMP_TO_EDGE);
+        }
+
+        program.draw(context, gl.TRIANGLES, depthMode,
+            painter.stencilModeForClipping(coord), colorMode, CullFaceMode.disabled, uniformValues, terrainData,
+            layer.id, bucket.layoutVertexBuffer, bucket.indexBuffer, bucket.segments,
+            layer.paint, painter.transform.zoom, programConfiguration, bucket.layoutVertexBuffer2);
+
+        firstTile = false;
+        // once refactored so that bound texture state is managed, we'll also be able to remove this firstTile/programChanged logic
+    }
+}

package/src/render/draw_raster.ts

@@ -0,0 +1,133 @@
+import {clamp} from '../util/util';
+
+import {ImageSource} from '../source/image_source';
+import {browser} from '../util/browser';
+import {StencilMode} from '../gl/stencil_mode';
+import {DepthMode} from '../gl/depth_mode';
+import {CullFaceMode} from '../gl/cull_face_mode';
+import {rasterUniformValues} from './program/raster_program';
+
+import type {Painter} from './painter';
+import type {SourceCache} from '../source/source_cache';
+import type {RasterStyleLayer} from '../style/style_layer/raster_style_layer';
+import type {OverscaledTileID} from '../source/tile_id';
+
+export function drawRaster(painter: Painter, sourceCache: SourceCache, layer: RasterStyleLayer, tileIDs: Array<OverscaledTileID>) {
+    if (painter.renderPass !== 'translucent') return;
+    if (layer.paint.get('raster-opacity') === 0) return;
+    if (!tileIDs.length) return;
+
+    const context = painter.context;
+    const gl = context.gl;
+    const source = sourceCache.getSource();
+    const program = painter.useProgram('raster');
+
+    const colorMode = painter.colorModeForRenderPass();
+
+    const [stencilModes, coords] = source instanceof ImageSource ? [{}, tileIDs] :
+        painter.stencilConfigForOverlap(tileIDs);
+
+    const minTileZ = coords[coords.length - 1].overscaledZ;
+
+    const align = !painter.options.moving;
+    for (const coord of coords) {
+        // Set the lower zoom level to sublayer 0, and higher zoom levels to higher sublayers
+        // Use gl.LESS to prevent double drawing in areas where tiles overlap.
+        const depthMode = painter.depthModeForSublayer(coord.overscaledZ - minTileZ,
+            layer.paint.get('raster-opacity') === 1 ? DepthMode.ReadWrite : DepthMode.ReadOnly, gl.LESS);
+
+        const tile = sourceCache.getTile(coord);
+
+        tile.registerFadeDuration(layer.paint.get('raster-fade-duration'));
+
+        const parentTile = sourceCache.findLoadedParent(coord, 0);
+        const siblingTile = sourceCache.findLoadedSibling(coord);
+        // Prefer parent tile if present
+        const fadeTileReference = parentTile || siblingTile || null;
+        const fade = getFadeValues(tile, fadeTileReference, sourceCache, layer, painter.transform, painter.style.map.terrain);
+
+        let parentScaleBy, parentTL;
+
+        const textureFilter = layer.paint.get('raster-resampling') === 'nearest' ?  gl.NEAREST : gl.LINEAR;
+
+        context.activeTexture.set(gl.TEXTURE0);
+        tile.texture.bind(textureFilter, gl.CLAMP_TO_EDGE, gl.LINEAR_MIPMAP_NEAREST);
+
+        context.activeTexture.set(gl.TEXTURE1);
+
+        if (parentTile) {
+            parentTile.texture.bind(textureFilter, gl.CLAMP_TO_EDGE, gl.LINEAR_MIPMAP_NEAREST);
+            parentScaleBy = Math.pow(2, parentTile.tileID.overscaledZ - tile.tileID.overscaledZ);
+            parentTL = [tile.tileID.canonical.x * parentScaleBy % 1, tile.tileID.canonical.y * parentScaleBy % 1];
+
+        } else {
+            tile.texture.bind(textureFilter, gl.CLAMP_TO_EDGE, gl.LINEAR_MIPMAP_NEAREST);
+        }
+
+        // Enable anisotropic filtering only when the pitch is greater than 20 degrees
+        // to preserve image sharpness on flat or slightly tilted maps.
+        if (tile.texture.useMipmap && context.extTextureFilterAnisotropic && painter.transform.pitch > 20) {
+            gl.texParameterf(gl.TEXTURE_2D, context.extTextureFilterAnisotropic.TEXTURE_MAX_ANISOTROPY_EXT,
+                context.extTextureFilterAnisotropicMax);
+        }
+
+        const terrainData = painter.style.map.terrain && painter.style.map.terrain.getTerrainData(coord);
+        const terrainCoord = terrainData ? coord : null;
+        const posMatrix = terrainCoord ? terrainCoord.posMatrix : painter.transform.calculatePosMatrix(coord.toUnwrapped(), align);
+        const uniformValues = rasterUniformValues(posMatrix, parentTL || [0, 0], parentScaleBy || 1, fade, layer);
+
+        if (source instanceof ImageSource) {
+            program.draw(context, gl.TRIANGLES, depthMode, StencilMode.disabled, colorMode, CullFaceMode.disabled,
+                uniformValues, terrainData, layer.id, source.boundsBuffer,
+                painter.quadTriangleIndexBuffer, source.boundsSegments);
+        } else {
+            program.draw(context, gl.TRIANGLES, depthMode, stencilModes[coord.overscaledZ], colorMode, CullFaceMode.disabled,
+                uniformValues, terrainData, layer.id, painter.rasterBoundsBuffer,
+                painter.quadTriangleIndexBuffer, painter.rasterBoundsSegments);
+        }
+    }
+}
+
+function getFadeValues(tile, parentTile, sourceCache, layer, transform, terrain) {
+    const fadeDuration = layer.paint.get('raster-fade-duration');
+
+    if (!terrain && fadeDuration > 0) {
+        const now = browser.now();
+        const sinceTile = (now - tile.timeAdded) / fadeDuration;
+        const sinceParent = parentTile ? (now - parentTile.timeAdded) / fadeDuration : -1;
+
+        const source = sourceCache.getSource();
+        const idealZ = transform.coveringZoomLevel({
+            tileSize: source.tileSize,
+            roundZoom: source.roundZoom
+        });
+
+        // if no parent or parent is older, fade in; if parent is younger, fade out
+        const fadeIn = !parentTile || Math.abs(parentTile.tileID.overscaledZ - idealZ) > Math.abs(tile.tileID.overscaledZ - idealZ);
+
+        const childOpacity = (fadeIn && tile.refreshedUponExpiration) ? 1 : clamp(fadeIn ? sinceTile : 1 - sinceParent, 0, 1);
+
+        // we don't crossfade tiles that were just refreshed upon expiring:
+        // once they're old enough to pass the crossfading threshold
+        // (fadeDuration), unset the `refreshedUponExpiration` flag so we don't
+        // incorrectly fail to crossfade them when zooming
+        if (tile.refreshedUponExpiration && sinceTile >= 1) tile.refreshedUponExpiration = false;
+
+        if (parentTile) {
+            return {
+                opacity: 1,
+                mix: 1 - childOpacity
+            };
+        } else {
+            return {
+                opacity: childOpacity,
+                mix: 0
+            };
+        }
+    } else {
+        return {
+            opacity: 1,
+            mix: 0
+        };
+    }
+}

package/src/render/draw_sky.ts

@@ -0,0 +1,44 @@
+import {StencilMode} from '../gl/stencil_mode';
+import {DepthMode} from '../gl/depth_mode';
+import {CullFaceMode} from '../gl/cull_face_mode';
+import {PosArray, TriangleIndexArray} from '../data/array_types.g';
+import posAttributes from '../data/pos_attributes';
+import {SegmentVector} from '../data/segment';
+import {skyUniformValues} from './program/sky_program';
+import {Sky} from '../style/sky';
+import {Mesh} from './mesh';
+import type {Painter} from './painter';
+
+export function drawSky(painter: Painter, sky: Sky) {
+    const context = painter.context;
+    const gl = context.gl;
+
+    const skyUniforms = skyUniformValues(sky, painter.style.map.transform, painter.pixelRatio);
+
+    const depthMode = new DepthMode(gl.LEQUAL, DepthMode.ReadWrite, [0, 1]);
+    const stencilMode = StencilMode.disabled;
+    const colorMode = painter.colorModeForRenderPass();
+    const program = painter.useProgram('sky');
+
+    if (!sky.mesh) {
+        const vertexArray = new PosArray();
+        vertexArray.emplaceBack(-1, -1);
+        vertexArray.emplaceBack(1, -1);
+        vertexArray.emplaceBack(1, 1);
+        vertexArray.emplaceBack(-1, 1);
+
+        const indexArray = new TriangleIndexArray();
+        indexArray.emplaceBack(0, 1, 2);
+        indexArray.emplaceBack(0, 2, 3);
+
+        sky.mesh = new Mesh(
+            context.createVertexBuffer(vertexArray, posAttributes.members),
+            context.createIndexBuffer(indexArray),
+            SegmentVector.simpleSegment(0, 0, vertexArray.length, indexArray.length)
+        );
+    }
+
+    program.draw(context, gl.TRIANGLES, depthMode, stencilMode, colorMode,
+        CullFaceMode.disabled, skyUniforms, undefined, 'sky', sky.mesh.vertexBuffer,
+        sky.mesh.indexBuffer, sky.mesh.segments);
+}

package/src/render/draw_symbol.test.ts

@@ -0,0 +1,223 @@
+import {mat4} from 'gl-matrix';
+import {OverscaledTileID} from '../source/tile_id';
+import {SymbolBucket} from '../data/bucket/symbol_bucket';
+import {SourceCache} from '../source/source_cache';
+import {Tile} from '../source/tile';
+import {SymbolStyleLayer} from '../style/style_layer/symbol_style_layer';
+import {Painter} from './painter';
+import {Program} from './program';
+import {drawSymbols} from './draw_symbol';
+import * as symbolProjection from '../symbol/projection';
+import type {ZoomHistory} from '../style/zoom_history';
+import type {Map} from '../ui/map';
+import {Transform} from '../geo/transform';
+import type {EvaluationParameters} from '../style/evaluation_parameters';
+import type {SymbolLayerSpecification} from '@maplibre/maplibre-gl-style-spec';
+import {Style} from '../style/style';
+
+jest.mock('./painter');
+jest.mock('./program');
+jest.mock('../source/source_cache');
+jest.mock('../source/tile');
+jest.mock('../data/bucket/symbol_bucket');
+jest.mock('../symbol/projection');
+
+describe('drawSymbol', () => {
+    test('should not do anything', () => {
+        const mockPainter = new Painter(null, null);
+        mockPainter.renderPass = 'opaque';
+
+        drawSymbols(mockPainter, null, null, null, null);
+
+        expect(mockPainter.colorModeForRenderPass).not.toHaveBeenCalled();
+    });
+
+    test('should call program.draw', () => {
+
+        const painterMock = new Painter(null, null);
+        painterMock.context = {
+            gl: {},
+            activeTexture: {
+                set: () => { }
+            }
+        } as any;
+        painterMock.renderPass = 'translucent';
+        painterMock.transform = {pitch: 0, labelPlaneMatrix: mat4.create()} as any as Transform;
+        painterMock.options = {} as any;
+        painterMock.style = {
+            map: {}
+        } as any as Style;
+
+        const layerSpec = {
+            id: 'mock-layer',
+            source: 'empty-source',
+            type: 'symbol',
+            layout: {},
+            paint: {
+                'text-opacity': 1
+            }
+        } as SymbolLayerSpecification;
+        const layer = new SymbolStyleLayer(layerSpec);
+        layer.recalculate({zoom: 0, zoomHistory: {} as ZoomHistory} as EvaluationParameters, []);
+
+        const tileId = new OverscaledTileID(1, 0, 1, 0, 0);
+        tileId.posMatrix = mat4.create();
+        const programMock = new Program(null, null, null, null, null, null);
+        (painterMock.useProgram as jest.Mock).mockReturnValue(programMock);
+        const bucketMock = new SymbolBucket(null);
+        bucketMock.icon = {
+            programConfigurations: {
+                get: () => { }
+            },
+            segments: {
+                get: () => [1]
+            },
+            hasVisibleVertices: true
+        } as any;
+        bucketMock.iconSizeData = {
+            kind: 'constant',
+            layoutSize: 1
+        };
+        const tile = new Tile(tileId, 256);
+        tile.tileID = tileId;
+        tile.imageAtlasTexture = {
+            bind: () => { }
+        } as any;
+        (tile.getBucket as jest.Mock).mockReturnValue(bucketMock);
+        const sourceCacheMock = new SourceCache(null, null, null);
+        (sourceCacheMock.getTile as jest.Mock).mockReturnValue(tile);
+        sourceCacheMock.map = {showCollisionBoxes: false} as any as Map;
+
+        drawSymbols(painterMock, sourceCacheMock, layer, [tileId], null);
+
+        expect(programMock.draw).toHaveBeenCalledTimes(1);
+    });
+
+    test('should call updateLineLabels with rotateToLine === false if text-rotation-alignment is viewport-glyph', () => {
+
+        const painterMock = new Painter(null, null);
+        painterMock.context = {
+            gl: {},
+            activeTexture: {
+                set: () => { }
+            }
+        } as any;
+        painterMock.renderPass = 'translucent';
+        painterMock.transform = {pitch: 0, labelPlaneMatrix: mat4.create()} as any as Transform;
+        painterMock.options = {} as any;
+
+        const layerSpec = {
+            id: 'mock-layer',
+            source: 'empty-source',
+            type: 'symbol',
+            layout: {
+                'text-rotation-alignment': 'viewport-glyph',
+                'text-field': 'ABC',
+                'symbol-placement': 'line',
+            },
+            paint: {
+                'text-opacity': 1
+            }
+        } as SymbolLayerSpecification;
+        const layer = new SymbolStyleLayer(layerSpec);
+        layer.recalculate({zoom: 0, zoomHistory: {} as ZoomHistory} as EvaluationParameters, []);
+
+        const tileId = new OverscaledTileID(1, 0, 1, 0, 0);
+        tileId.posMatrix = mat4.create();
+        const programMock = new Program(null, null, null, null, null, null);
+        (painterMock.useProgram as jest.Mock).mockReturnValue(programMock);
+        const bucketMock = new SymbolBucket(null);
+        bucketMock.icon = {
+            programConfigurations: {
+                get: () => { }
+            },
+            segments: {
+                get: () => [1]
+            },
+            hasVisibleVertices: true
+        } as any;
+        bucketMock.iconSizeData = {
+            kind: 'constant',
+            layoutSize: 1
+        };
+        const tile = new Tile(tileId, 256);
+        tile.tileID = tileId;
+        tile.imageAtlasTexture = {
+            bind: () => { }
+        } as any;
+        (tile.getBucket as jest.Mock).mockReturnValue(bucketMock);
+        const sourceCacheMock = new SourceCache(null, null, null);
+        (sourceCacheMock.getTile as jest.Mock).mockReturnValue(tile);
+        sourceCacheMock.map = {showCollisionBoxes: false} as any as Map;
+        painterMock.style = {
+            map: {}
+        } as any as Style;
+
+        const spy = jest.spyOn(symbolProjection, 'updateLineLabels');
+        drawSymbols(painterMock, sourceCacheMock, layer, [tileId], null);
+
+        expect(spy.mock.calls[0][8]).toBeFalsy(); // rotateToLine === false
+    });
+
+    test('transparent tile optimization should prevent program.draw from being called', () => {
+
+        const painterMock = new Painter(null, null);
+        painterMock.context = {
+            gl: {},
+            activeTexture: {
+                set: () => { }
+            }
+        } as any;
+        painterMock.renderPass = 'translucent';
+        painterMock.transform = {pitch: 0, labelPlaneMatrix: mat4.create()} as any as Transform;
+        painterMock.options = {} as any;
+        painterMock.style = {
+            map: {}
+        } as any as Style;
+
+        const layerSpec = {
+            id: 'mock-layer',
+            source: 'empty-source',
+            type: 'symbol',
+            layout: {},
+            paint: {
+                'text-opacity': 1
+            }
+        } as SymbolLayerSpecification;
+        const layer = new SymbolStyleLayer(layerSpec);
+        layer.recalculate({zoom: 0, zoomHistory: {} as ZoomHistory} as EvaluationParameters, []);
+
+        const tileId = new OverscaledTileID(1, 0, 1, 0, 0);
+        tileId.posMatrix = mat4.create();
+        const programMock = new Program(null, null, null, null, null, null);
+        (painterMock.useProgram as jest.Mock).mockReturnValue(programMock);
+        const bucketMock = new SymbolBucket(null);
+        bucketMock.icon = {
+            programConfigurations: {
+                get: () => { }
+            },
+            segments: {
+                get: () => [1]
+            },
+            hasVisibleVertices: false // nark this bucket as having no visible vertices
+        } as any;
+        bucketMock.iconSizeData = {
+            kind: 'constant',
+            layoutSize: 1
+        };
+        const tile = new Tile(tileId, 256);
+        tile.tileID = tileId;
+        tile.imageAtlasTexture = {
+            bind: () => { }
+        } as any;
+        (tile.getBucket as jest.Mock).mockReturnValue(bucketMock);
+        const sourceCacheMock = new SourceCache(null, null, null);
+        (sourceCacheMock.getTile as jest.Mock).mockReturnValue(tile);
+        sourceCacheMock.map = {showCollisionBoxes: false} as any as Map;
+
+        drawSymbols(painterMock, sourceCacheMock, layer, [tileId], null);
+
+        expect(programMock.draw).toHaveBeenCalledTimes(0);
+    });
+
+});