mapbox-gl 1.13.2

package/src/render/program/background_program.js

@@ -0,0 +1,103 @@
+// @flow
+
+import {bgPatternUniformValues} from './pattern';
+import {
+    Uniform1i,
+    Uniform1f,
+    Uniform2f,
+    UniformColor,
+    UniformMatrix4f
+} from '../uniform_binding';
+import {extend} from '../../util/util';
+
+import type Painter from '../painter';
+import type {UniformValues, UniformLocations} from '../uniform_binding';
+import type Context from '../../gl/context';
+import type Color from '../../style-spec/util/color';
+import type {CrossFaded} from '../../style/properties';
+import type {CrossfadeParameters} from '../../style/evaluation_parameters';
+import type {OverscaledTileID} from '../../source/tile_id';
+import type ResolvedImage from '../../style-spec/expression/types/resolved_image';
+
+export type BackgroundUniformsType = {|
+    'u_matrix': UniformMatrix4f,
+    'u_opacity': Uniform1f,
+    'u_color': UniformColor
+|};
+
+export type BackgroundPatternUniformsType = {|
+    'u_matrix': UniformMatrix4f,
+    'u_opacity': Uniform1f,
+    // pattern uniforms:
+    'u_image': Uniform1i,
+    'u_pattern_tl_a': Uniform2f,
+    'u_pattern_br_a': Uniform2f,
+    'u_pattern_tl_b': Uniform2f,
+    'u_pattern_br_b': Uniform2f,
+    'u_texsize': Uniform2f,
+    'u_mix': Uniform1f,
+    'u_pattern_size_a': Uniform2f,
+    'u_pattern_size_b': Uniform2f,
+    'u_scale_a': Uniform1f,
+    'u_scale_b': Uniform1f,
+    'u_pixel_coord_upper': Uniform2f,
+    'u_pixel_coord_lower': Uniform2f,
+    'u_tile_units_to_pixels': Uniform1f
+|};
+
+const backgroundUniforms = (context: Context, locations: UniformLocations): BackgroundUniformsType => ({
+    'u_matrix': new UniformMatrix4f(context, locations.u_matrix),
+    'u_opacity': new Uniform1f(context, locations.u_opacity),
+    'u_color': new UniformColor(context, locations.u_color)
+});
+
+const backgroundPatternUniforms = (context: Context, locations: UniformLocations): BackgroundPatternUniformsType => ({
+    'u_matrix': new UniformMatrix4f(context, locations.u_matrix),
+    'u_opacity': new Uniform1f(context, locations.u_opacity),
+    'u_image': new Uniform1i(context, locations.u_image),
+    'u_pattern_tl_a': new Uniform2f(context, locations.u_pattern_tl_a),
+    'u_pattern_br_a': new Uniform2f(context, locations.u_pattern_br_a),
+    'u_pattern_tl_b': new Uniform2f(context, locations.u_pattern_tl_b),
+    'u_pattern_br_b': new Uniform2f(context, locations.u_pattern_br_b),
+    'u_texsize': new Uniform2f(context, locations.u_texsize),
+    'u_mix': new Uniform1f(context, locations.u_mix),
+    'u_pattern_size_a': new Uniform2f(context, locations.u_pattern_size_a),
+    'u_pattern_size_b': new Uniform2f(context, locations.u_pattern_size_b),
+    'u_scale_a': new Uniform1f(context, locations.u_scale_a),
+    'u_scale_b': new Uniform1f(context, locations.u_scale_b),
+    '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_tile_units_to_pixels': new Uniform1f(context, locations.u_tile_units_to_pixels)
+});
+
+const backgroundUniformValues = (
+    matrix: Float32Array,
+    opacity: number,
+    color: Color
+): UniformValues<BackgroundUniformsType> => ({
+    'u_matrix': matrix,
+    'u_opacity': opacity,
+    'u_color': color
+});
+
+const backgroundPatternUniformValues = (
+    matrix: Float32Array,
+    opacity: number,
+    painter: Painter,
+    image: CrossFaded<ResolvedImage>,
+    tile: {tileID: OverscaledTileID, tileSize: number},
+    crossfade: CrossfadeParameters
+): UniformValues<BackgroundPatternUniformsType> => extend(
+    bgPatternUniformValues(image, crossfade, painter, tile),
+    {
+        'u_matrix': matrix,
+        'u_opacity': opacity
+    }
+);
+
+export {
+    backgroundUniforms,
+    backgroundPatternUniforms,
+    backgroundUniformValues,
+    backgroundPatternUniformValues
+};

package/src/render/program/circle_program.js

@@ -0,0 +1,69 @@
+// @flow
+
+import {
+    Uniform1i,
+    Uniform1f,
+    Uniform2f,
+    UniformMatrix4f
+} from '../uniform_binding';
+import pixelsToTileUnits from '../../source/pixels_to_tile_units';
+
+import type Context from '../../gl/context';
+import type {UniformValues, UniformLocations} from '../uniform_binding';
+import type {OverscaledTileID} from '../../source/tile_id';
+import type Tile from '../../source/tile';
+import type CircleStyleLayer from '../../style/style_layer/circle_style_layer';
+import type Painter from '../painter';
+import browser from '../../util/browser';
+
+export type CircleUniformsType = {|
+    'u_camera_to_center_distance': Uniform1f,
+    'u_scale_with_map': Uniform1i,
+    'u_pitch_with_map': Uniform1i,
+    'u_extrude_scale': Uniform2f,
+    'u_device_pixel_ratio': Uniform1f,
+    'u_matrix': UniformMatrix4f
+|};
+
+const circleUniforms = (context: Context, locations: UniformLocations): CircleUniformsType => ({
+    '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_matrix': new UniformMatrix4f(context, locations.u_matrix)
+});
+
+const circleUniformValues = (
+    painter: Painter,
+    coord: OverscaledTileID,
+    tile: Tile,
+    layer: CircleStyleLayer
+): UniformValues<CircleUniformsType> => {
+    const transform = painter.transform;
+
+    let pitchWithMap: boolean, extrudeScale: [number, number];
+    if (layer.paint.get('circle-pitch-alignment') === 'map') {
+        const pixelRatio = pixelsToTileUnits(tile, 1, transform.zoom);
+        pitchWithMap = true;
+        extrudeScale = [pixelRatio, pixelRatio];
+    } else {
+        pitchWithMap = false;
+        extrudeScale = transform.pixelsToGLUnits;
+    }
+
+    return {
+        'u_camera_to_center_distance': transform.cameraToCenterDistance,
+        'u_scale_with_map': +(layer.paint.get('circle-pitch-scale') === 'map'),
+        'u_matrix': painter.translatePosMatrix(
+            coord.posMatrix,
+            tile,
+            layer.paint.get('circle-translate'),
+            layer.paint.get('circle-translate-anchor')),
+        'u_pitch_with_map': +(pitchWithMap),
+        'u_device_pixel_ratio': browser.devicePixelRatio,
+        'u_extrude_scale': extrudeScale
+    };
+};
+
+export {circleUniforms, circleUniformValues};

package/src/render/program/clipping_mask_program.js

@@ -0,0 +1,20 @@
+// @flow
+
+import {UniformMatrix4f} from '../uniform_binding';
+
+import type Context from '../../gl/context';
+import type {UniformValues, UniformLocations} from '../uniform_binding';
+
+export type ClippingMaskUniformsType = {|
+    'u_matrix': UniformMatrix4f
+|};
+
+const clippingMaskUniforms = (context: Context, locations: UniformLocations): ClippingMaskUniformsType => ({
+    'u_matrix': new UniformMatrix4f(context, locations.u_matrix)
+});
+
+const clippingMaskUniformValues = (matrix: Float32Array): UniformValues<ClippingMaskUniformsType> => ({
+    'u_matrix': matrix
+});
+
+export {clippingMaskUniforms, clippingMaskUniformValues};

package/src/render/program/collision_program.js

@@ -0,0 +1,76 @@
+// @flow
+
+import {
+    Uniform1f,
+    Uniform2f,
+    UniformMatrix4f
+} from '../uniform_binding';
+import pixelsToTileUnits from '../../source/pixels_to_tile_units';
+
+import type Context from '../../gl/context';
+import type {UniformValues, UniformLocations} from '../uniform_binding';
+import type Transform from '../../geo/transform';
+import type Tile from '../../source/tile';
+
+export type CollisionUniformsType = {|
+    'u_matrix': UniformMatrix4f,
+    'u_camera_to_center_distance': Uniform1f,
+    'u_pixels_to_tile_units': Uniform1f,
+    'u_extrude_scale': Uniform2f,
+    'u_overscale_factor': Uniform1f
+|};
+
+export type CollisionCircleUniformsType = {|
+    'u_matrix': UniformMatrix4f,
+    'u_inv_matrix': UniformMatrix4f,
+    'u_camera_to_center_distance': Uniform1f,
+    'u_viewport_size': Uniform2f
+|};
+
+const collisionUniforms = (context: Context, locations: UniformLocations): CollisionUniformsType => ({
+    'u_matrix': new UniformMatrix4f(context, locations.u_matrix),
+    'u_camera_to_center_distance': new Uniform1f(context, locations.u_camera_to_center_distance),
+    'u_pixels_to_tile_units': new Uniform1f(context, locations.u_pixels_to_tile_units),
+    'u_extrude_scale': new Uniform2f(context, locations.u_extrude_scale),
+    'u_overscale_factor': new Uniform1f(context, locations.u_overscale_factor)
+});
+
+const collisionCircleUniforms = (context: Context, locations: UniformLocations): CollisionCircleUniformsType => ({
+    'u_matrix': new UniformMatrix4f(context, locations.u_matrix),
+    'u_inv_matrix': new UniformMatrix4f(context, locations.u_inv_matrix),
+    'u_camera_to_center_distance': new Uniform1f(context, locations.u_camera_to_center_distance),
+    'u_viewport_size': new Uniform2f(context, locations.u_viewport_size)
+});
+
+const collisionUniformValues = (
+    matrix: Float32Array,
+    transform: Transform,
+    tile: Tile
+): UniformValues<CollisionUniformsType> => {
+    const pixelRatio = pixelsToTileUnits(tile, 1, transform.zoom);
+    const scale = Math.pow(2, transform.zoom - tile.tileID.overscaledZ);
+    const overscaleFactor = tile.tileID.overscaleFactor();
+    return {
+        'u_matrix': matrix,
+        'u_camera_to_center_distance': transform.cameraToCenterDistance,
+        'u_pixels_to_tile_units': pixelRatio,
+        'u_extrude_scale': [transform.pixelsToGLUnits[0] / (pixelRatio * scale),
+            transform.pixelsToGLUnits[1] / (pixelRatio * scale)],
+        'u_overscale_factor': overscaleFactor
+    };
+};
+
+const collisionCircleUniformValues = (
+    matrix: Float32Array,
+    invMatrix: Float32Array,
+    transform: Transform
+): UniformValues<CollisionCircleUniformsType> => {
+    return {
+        'u_matrix': matrix,
+        'u_inv_matrix': invMatrix,
+        'u_camera_to_center_distance': transform.cameraToCenterDistance,
+        'u_viewport_size': [transform.width, transform.height]
+    };
+};
+
+export {collisionUniforms, collisionUniformValues, collisionCircleUniforms, collisionCircleUniformValues};

package/src/render/program/debug_program.js

@@ -0,0 +1,35 @@
+// @flow
+
+import {
+    UniformColor,
+    UniformMatrix4f,
+    Uniform1i,
+    Uniform1f
+} from '../uniform_binding';
+
+import type Context from '../../gl/context';
+import type {UniformValues, UniformLocations} from '../uniform_binding';
+import type Color from '../../style-spec/util/color';
+
+export type DebugUniformsType = {|
+    'u_color': UniformColor,
+    'u_matrix': UniformMatrix4f,
+    'u_overlay': Uniform1i,
+    'u_overlay_scale': Uniform1f
+|};
+
+const debugUniforms = (context: Context, locations: UniformLocations): DebugUniformsType => ({
+    'u_color': new UniformColor(context, locations.u_color),
+    'u_matrix': new UniformMatrix4f(context, locations.u_matrix),
+    'u_overlay': new Uniform1i(context, locations.u_overlay),
+    'u_overlay_scale':  new Uniform1f(context, locations.u_overlay_scale),
+});
+
+const debugUniformValues = (matrix: Float32Array, color: Color, scaleRatio: number = 1): UniformValues<DebugUniformsType> => ({
+    'u_matrix': matrix,
+    'u_color': color,
+    'u_overlay': 0,
+    'u_overlay_scale': scaleRatio
+});
+
+export {debugUniforms, debugUniformValues};

package/src/render/program/fill_extrusion_program.js

@@ -0,0 +1,122 @@
+// @flow
+
+import {patternUniformValues} from './pattern';
+import {
+    Uniform1i,
+    Uniform1f,
+    Uniform2f,
+    Uniform3f,
+    UniformMatrix4f
+} from '../uniform_binding';
+
+import {mat3, vec3} from 'gl-matrix';
+import {extend} from '../../util/util';
+
+import type Context from '../../gl/context';
+import type Painter from '../painter';
+import type {OverscaledTileID} from '../../source/tile_id';
+import type {UniformValues, UniformLocations} from '../uniform_binding';
+import type {CrossfadeParameters} from '../../style/evaluation_parameters';
+import type Tile from '../../source/tile';
+
+export type FillExtrusionUniformsType = {|
+    'u_matrix': UniformMatrix4f,
+    'u_lightpos': Uniform3f,
+    'u_lightintensity': Uniform1f,
+    'u_lightcolor': Uniform3f,
+    'u_vertical_gradient': Uniform1f,
+    'u_opacity': Uniform1f
+|};
+
+export type FillExtrusionPatternUniformsType = {|
+    'u_matrix': UniformMatrix4f,
+    'u_lightpos': Uniform3f,
+    'u_lightintensity': Uniform1f,
+    'u_lightcolor': Uniform3f,
+    'u_height_factor': Uniform1f,
+    'u_vertical_gradient': Uniform1f,
+    // pattern uniforms:
+    'u_texsize': Uniform2f,
+    'u_image': Uniform1i,
+    'u_pixel_coord_upper': Uniform2f,
+    'u_pixel_coord_lower': Uniform2f,
+    'u_scale': Uniform3f,
+    'u_fade': Uniform1f,
+    'u_opacity': Uniform1f
+|};
+
+const fillExtrusionUniforms = (context: Context, locations: UniformLocations): FillExtrusionUniformsType => ({
+    'u_matrix': new UniformMatrix4f(context, locations.u_matrix),
+    'u_lightpos': new Uniform3f(context, locations.u_lightpos),
+    'u_lightintensity': new Uniform1f(context, locations.u_lightintensity),
+    'u_lightcolor': new Uniform3f(context, locations.u_lightcolor),
+    'u_vertical_gradient': new Uniform1f(context, locations.u_vertical_gradient),
+    'u_opacity': new Uniform1f(context, locations.u_opacity)
+});
+
+const fillExtrusionPatternUniforms = (context: Context, locations: UniformLocations): FillExtrusionPatternUniformsType => ({
+    'u_matrix': new UniformMatrix4f(context, locations.u_matrix),
+    'u_lightpos': new Uniform3f(context, locations.u_lightpos),
+    'u_lightintensity': new Uniform1f(context, locations.u_lightintensity),
+    'u_lightcolor': new Uniform3f(context, locations.u_lightcolor),
+    'u_vertical_gradient': new Uniform1f(context, locations.u_vertical_gradient),
+    'u_height_factor': new Uniform1f(context, locations.u_height_factor),
+    // pattern uniforms
+    '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_opacity': new Uniform1f(context, locations.u_opacity)
+});
+
+const fillExtrusionUniformValues = (
+    matrix: Float32Array,
+    painter: Painter,
+    shouldUseVerticalGradient: boolean,
+    opacity: number
+): UniformValues<FillExtrusionUniformsType> => {
+    const light = painter.style.light;
+    const _lp = light.properties.get('position');
+    const lightPos = [_lp.x, _lp.y, _lp.z];
+    const lightMat = mat3.create();
+    if (light.properties.get('anchor') === 'viewport') {
+        mat3.fromRotation(lightMat, -painter.transform.angle);
+    }
+    vec3.transformMat3(lightPos, lightPos, lightMat);
+
+    const lightColor = light.properties.get('color');
+
+    return {
+        'u_matrix': matrix,
+        'u_lightpos': lightPos,
+        'u_lightintensity': light.properties.get('intensity'),
+        'u_lightcolor': [lightColor.r, lightColor.g, lightColor.b],
+        'u_vertical_gradient': +shouldUseVerticalGradient,
+        'u_opacity': opacity
+    };
+};
+
+const fillExtrusionPatternUniformValues = (
+    matrix: Float32Array,
+    painter: Painter,
+    shouldUseVerticalGradient: boolean,
+    opacity: number,
+    coord: OverscaledTileID,
+    crossfade: CrossfadeParameters,
+    tile: Tile
+): UniformValues<FillExtrusionPatternUniformsType> => {
+    return extend(fillExtrusionUniformValues(matrix, painter, shouldUseVerticalGradient, opacity),
+        patternUniformValues(crossfade, painter, tile),
+        {
+            'u_height_factor': -Math.pow(2, coord.overscaledZ) / tile.tileSize / 8
+        });
+};
+
+export {
+    fillExtrusionUniforms,
+    fillExtrusionPatternUniforms,
+    fillExtrusionUniformValues,
+    fillExtrusionPatternUniformValues
+};

package/src/render/program/fill_program.js

@@ -0,0 +1,126 @@
+// @flow
+
+import {patternUniformValues} from './pattern';
+import {
+    Uniform1i,
+    Uniform1f,
+    Uniform2f,
+    Uniform3f,
+    UniformMatrix4f
+} from '../uniform_binding';
+import {extend} from '../../util/util';
+
+import type Painter from '../painter';
+import type {UniformValues, UniformLocations} from '../uniform_binding';
+import type Context from '../../gl/context';
+import type {CrossfadeParameters} from '../../style/evaluation_parameters';
+import type Tile from '../../source/tile';
+
+export type FillUniformsType = {|
+    'u_matrix': UniformMatrix4f
+|};
+
+export type FillOutlineUniformsType = {|
+    'u_matrix': UniformMatrix4f,
+    'u_world': Uniform2f
+|};
+
+export type FillPatternUniformsType = {|
+    'u_matrix': UniformMatrix4f,
+    // pattern uniforms:
+    'u_texsize': Uniform2f,
+    'u_image': Uniform1i,
+    'u_pixel_coord_upper': Uniform2f,
+    'u_pixel_coord_lower': Uniform2f,
+    'u_scale': Uniform3f,
+    'u_fade': Uniform1f
+|};
+
+export type FillOutlinePatternUniformsType = {|
+    'u_matrix': UniformMatrix4f,
+    'u_world': Uniform2f,
+    // pattern uniforms:
+    'u_texsize': Uniform2f,
+    'u_image': Uniform1i,
+    'u_pixel_coord_upper': Uniform2f,
+    'u_pixel_coord_lower': Uniform2f,
+    'u_scale': Uniform3f,
+    'u_fade': Uniform1f
+|};
+
+const fillUniforms = (context: Context, locations: UniformLocations): FillUniformsType => ({
+    'u_matrix': new UniformMatrix4f(context, locations.u_matrix)
+});
+
+const fillPatternUniforms = (context: Context, locations: UniformLocations): FillPatternUniformsType => ({
+    'u_matrix': new UniformMatrix4f(context, locations.u_matrix),
+    '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)
+
+});
+
+const fillOutlineUniforms = (context: Context, locations: UniformLocations): FillOutlineUniformsType => ({
+    'u_matrix': new UniformMatrix4f(context, locations.u_matrix),
+    'u_world': new Uniform2f(context, locations.u_world)
+});
+
+const fillOutlinePatternUniforms = (context: Context, locations: UniformLocations): FillOutlinePatternUniformsType => ({
+    '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_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)
+});
+
+const fillUniformValues = (matrix: Float32Array): UniformValues<FillUniformsType> => ({
+    'u_matrix': matrix
+});
+
+const fillPatternUniformValues = (
+    matrix: Float32Array,
+    painter: Painter,
+    crossfade: CrossfadeParameters,
+    tile: Tile
+): UniformValues<FillPatternUniformsType> => extend(
+    fillUniformValues(matrix),
+    patternUniformValues(crossfade, painter, tile)
+);
+
+const fillOutlineUniformValues = (
+    matrix: Float32Array,
+    drawingBufferSize: [number, number]
+): UniformValues<FillOutlineUniformsType> => ({
+    'u_matrix': matrix,
+    'u_world': drawingBufferSize
+});
+
+const fillOutlinePatternUniformValues = (
+    matrix: Float32Array,
+    painter: Painter,
+    crossfade: CrossfadeParameters,
+    tile: Tile,
+    drawingBufferSize: [number, number]
+): UniformValues<FillOutlinePatternUniformsType> => extend(
+    fillPatternUniformValues(matrix, painter, crossfade, tile),
+    {
+        'u_world': drawingBufferSize
+    }
+);
+
+export {
+    fillUniforms,
+    fillPatternUniforms,
+    fillOutlineUniforms,
+    fillOutlinePatternUniforms,
+    fillUniformValues,
+    fillPatternUniformValues,
+    fillOutlineUniformValues,
+    fillOutlinePatternUniformValues
+};

package/src/render/program/heatmap_program.js

@@ -0,0 +1,83 @@
+// @flow
+
+import {mat4} from 'gl-matrix';
+
+import {
+    Uniform1i,
+    Uniform1f,
+    Uniform2f,
+    UniformMatrix4f
+} from '../uniform_binding';
+import pixelsToTileUnits from '../../source/pixels_to_tile_units';
+
+import type Context from '../../gl/context';
+import type Tile from '../../source/tile';
+import type {UniformValues, UniformLocations} from '../uniform_binding';
+import type Painter from '../painter';
+import type HeatmapStyleLayer from '../../style/style_layer/heatmap_style_layer';
+
+export type HeatmapUniformsType = {|
+    'u_extrude_scale': Uniform1f,
+    'u_intensity': Uniform1f,
+    'u_matrix': UniformMatrix4f
+|};
+
+export type HeatmapTextureUniformsType = {|
+    'u_matrix': UniformMatrix4f,
+    'u_world': Uniform2f,
+    'u_image': Uniform1i,
+    'u_color_ramp': Uniform1i,
+    'u_opacity': Uniform1f
+|};
+
+const heatmapUniforms = (context: Context, locations: UniformLocations): HeatmapUniformsType => ({
+    'u_extrude_scale': new Uniform1f(context, locations.u_extrude_scale),
+    'u_intensity': new Uniform1f(context, locations.u_intensity),
+    'u_matrix': new UniformMatrix4f(context, locations.u_matrix)
+});
+
+const heatmapTextureUniforms = (context: Context, locations: UniformLocations): HeatmapTextureUniformsType => ({
+    '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)
+});
+
+const heatmapUniformValues = (
+    matrix: Float32Array,
+    tile: Tile,
+    zoom: number,
+    intensity: number
+): UniformValues<HeatmapUniformsType> => ({
+    'u_matrix': matrix,
+    'u_extrude_scale': pixelsToTileUnits(tile, 1, zoom),
+    'u_intensity': intensity
+});
+
+const heatmapTextureUniformValues = (
+    painter: Painter,
+    layer: HeatmapStyleLayer,
+    textureUnit: number,
+    colorRampUnit: number
+): UniformValues<HeatmapTextureUniformsType> => {
+    const matrix = mat4.create();
+    mat4.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')
+    };
+};
+
+export {
+    heatmapUniforms,
+    heatmapTextureUniforms,
+    heatmapUniformValues,
+    heatmapTextureUniformValues
+};