@scoova/mgl 1.0.0

package/src/render/program/background_program.ts

@@ -0,0 +1,100 @@
+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, ResolvedImage} from '@maplibre/maplibre-gl-style-spec';
+import type {CrossFaded} from '../../style/properties';
+import type {CrossfadeParameters} from '../../style/evaluation_parameters';
+import type {OverscaledTileID} from '../../source/tile_id';
+import {mat4} from 'gl-matrix';
+
+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: mat4, opacity: number, color: Color): UniformValues<BackgroundUniformsType> => ({
+    'u_matrix': matrix,
+    'u_opacity': opacity,
+    'u_color': color
+});
+
+const backgroundPatternUniformValues = (
+    matrix: mat4,
+    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.ts

@@ -0,0 +1,61 @@
+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';
+
+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': painter.pixelRatio,
+        'u_extrude_scale': extrudeScale
+    };
+};
+
+export {circleUniforms, circleUniformValues};

package/src/render/program/clipping_mask_program.ts

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

package/src/render/program/collision_program.ts

@@ -0,0 +1,47 @@
+import {Uniform1f, Uniform2f, UniformMatrix4f} from '../uniform_binding';
+import type {Context} from '../../gl/context';
+import type {UniformValues, UniformLocations} from '../uniform_binding';
+import type {Transform} from '../../geo/transform';
+import {mat4} from 'gl-matrix';
+
+export type CollisionUniformsType = {
+    'u_matrix': UniformMatrix4f;
+    'u_pixel_extrude_scale': Uniform2f;
+};
+
+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_pixel_extrude_scale': new Uniform2f(context, locations.u_pixel_extrude_scale)
+});
+
+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 = (transform: {width: number; height: number}, matrix: mat4): UniformValues<CollisionUniformsType> => {
+    return {
+        'u_matrix': matrix,
+        'u_pixel_extrude_scale': [1.0 / transform.width, 1.0 / transform.height],
+    };
+};
+
+const collisionCircleUniformValues = (matrix: mat4, invMatrix: mat4, 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.ts

@@ -0,0 +1,29 @@
+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 '@maplibre/maplibre-gl-style-spec';
+import {mat4} from 'gl-matrix';
+
+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: mat4, 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.ts

@@ -0,0 +1,120 @@
+import {patternUniformValues} from './pattern';
+import {
+    Uniform1i,
+    Uniform1f,
+    Uniform2f,
+    Uniform3f,
+    UniformMatrix4f
+} from '../uniform_binding';
+
+import {mat3, mat4, 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: mat4,
+    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] as vec3;
+    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: mat4,
+    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.ts

@@ -0,0 +1,121 @@
+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';
+import {mat4} from 'gl-matrix';
+
+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: mat4): UniformValues<FillUniformsType> => ({
+    'u_matrix': matrix
+});
+
+const fillPatternUniformValues = (
+    matrix: mat4,
+    painter: Painter,
+    crossfade: CrossfadeParameters,
+    tile: Tile
+): UniformValues<FillPatternUniformsType> => extend(
+    fillUniformValues(matrix),
+    patternUniformValues(crossfade, painter, tile)
+);
+
+const fillOutlineUniformValues = (matrix: mat4, drawingBufferSize: [number, number]): UniformValues<FillOutlineUniformsType> => ({
+    'u_matrix': matrix,
+    'u_world': drawingBufferSize
+});
+
+const fillOutlinePatternUniformValues = (
+    matrix: mat4,
+    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.ts

@@ -0,0 +1,76 @@
+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: mat4, 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
+};