@mapwhit/tilerenderer 0.47.1

package/src/render/program/clipping_mask_program.js

@@ -0,0 +1,11 @@
+const { UniformMatrix4f } = require('../uniform_binding');
+
+const clippingMaskUniforms = (context, locations) => ({
+  u_matrix: new UniformMatrix4f(context, locations.u_matrix)
+});
+
+const clippingMaskUniformValues = matrix => ({
+  u_matrix: matrix
+});
+
+module.exports = { clippingMaskUniforms, clippingMaskUniformValues };

package/src/render/program/collision_program.js

@@ -0,0 +1,28 @@
+const { Uniform1f, Uniform2f, UniformMatrix4f } = require('../uniform_binding');
+const pixelsToTileUnits = require('../../source/pixels_to_tile_units');
+
+const collisionUniforms = (context, locations) => ({
+  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 collisionUniformValues = (matrix, transform, tile) => {
+  const pixelRatio = pixelsToTileUnits(tile, 1, transform.zoom);
+  const scale = 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
+  };
+};
+
+module.exports = { collisionUniforms, collisionUniformValues };

package/src/render/program/debug_program.js

@@ -0,0 +1,13 @@
+const { UniformColor, UniformMatrix4f } = require('../uniform_binding');
+
+const debugUniforms = (context, locations) => ({
+  u_color: new UniformColor(context, locations.u_color),
+  u_matrix: new UniformMatrix4f(context, locations.u_matrix)
+});
+
+const debugUniformValues = (matrix, color) => ({
+  u_matrix: matrix,
+  u_color: color
+});
+
+module.exports = { debugUniforms, debugUniformValues };

package/src/render/program/fill_extrusion_program.js

@@ -0,0 +1,76 @@
+const { patternUniformValues } = require('./pattern');
+const { Uniform1i, Uniform1f, Uniform2f, Uniform3f, Uniform4f, UniformMatrix4f } = require('../uniform_binding');
+
+const { mat3, vec3 } = require('@mapbox/gl-matrix');
+
+const fillExtrusionUniforms = (context, locations) => ({
+  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, locations) => ({
+  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),
+  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 Uniform4f(context, locations.u_scale),
+  u_fade: new Uniform1f(context, locations.u_fade),
+  u_opacity: new Uniform1f(context, locations.u_opacity)
+});
+
+const fillExtrusionUniformValues = (matrix, painter, shouldUseVerticalGradient, opacity) => {
+  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,
+  painter,
+  shouldUseVerticalGradient,
+  opacity,
+  coord,
+  crossfade,
+  tile
+) => {
+  return Object.assign(
+    fillExtrusionUniformValues(matrix, painter, shouldUseVerticalGradient, opacity),
+    patternUniformValues(crossfade, painter, tile),
+    {
+      u_height_factor: -(2 ** coord.overscaledZ) / tile.tileSize / 8
+    }
+  );
+};
+
+module.exports = {
+  fillExtrusionUniforms,
+  fillExtrusionPatternUniforms,
+  fillExtrusionUniformValues,
+  fillExtrusionPatternUniformValues
+};

package/src/render/program/fill_program.js

@@ -0,0 +1,60 @@
+const { patternUniformValues } = require('./pattern');
+const { Uniform1i, Uniform1f, Uniform2f, Uniform4f, UniformMatrix4f } = require('../uniform_binding');
+
+const fillUniforms = (context, locations) => ({
+  u_matrix: new UniformMatrix4f(context, locations.u_matrix)
+});
+
+const fillPatternUniforms = (context, locations) => ({
+  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 Uniform4f(context, locations.u_scale),
+  u_fade: new Uniform1f(context, locations.u_fade)
+});
+
+const fillOutlineUniforms = (context, locations) => ({
+  u_matrix: new UniformMatrix4f(context, locations.u_matrix),
+  u_world: new Uniform2f(context, locations.u_world)
+});
+
+const fillOutlinePatternUniforms = (context, locations) => ({
+  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 Uniform4f(context, locations.u_scale),
+  u_fade: new Uniform1f(context, locations.u_fade)
+});
+
+const fillUniformValues = matrix => ({
+  u_matrix: matrix
+});
+
+const fillPatternUniformValues = (matrix, painter, crossfade, tile) =>
+  Object.assign(fillUniformValues(matrix), patternUniformValues(crossfade, painter, tile));
+
+const fillOutlineUniformValues = (matrix, drawingBufferSize) => ({
+  u_matrix: matrix,
+  u_world: drawingBufferSize
+});
+
+const fillOutlinePatternUniformValues = (matrix, painter, crossfade, tile, drawingBufferSize) =>
+  Object.assign(fillPatternUniformValues(matrix, painter, crossfade, tile), {
+    u_world: drawingBufferSize
+  });
+
+module.exports = {
+  fillUniforms,
+  fillPatternUniforms,
+  fillOutlineUniforms,
+  fillOutlinePatternUniforms,
+  fillUniformValues,
+  fillPatternUniformValues,
+  fillOutlineUniformValues,
+  fillOutlinePatternUniformValues
+};

package/src/render/program/heatmap_program.js

@@ -0,0 +1,46 @@
+const { mat4 } = require('@mapbox/gl-matrix');
+
+const { Uniform1i, Uniform1f, Uniform2f, UniformMatrix4f } = require('../uniform_binding');
+const pixelsToTileUnits = require('../../source/pixels_to_tile_units');
+
+const heatmapUniforms = (context, locations) => ({
+  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, locations) => ({
+  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, tile, zoom, intensity) => ({
+  u_matrix: matrix,
+  u_extrude_scale: pixelsToTileUnits(tile, 1, zoom),
+  u_intensity: intensity
+});
+
+const heatmapTextureUniformValues = (painter, layer, textureUnit, colorRampUnit) => {
+  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')
+  };
+};
+
+module.exports = {
+  heatmapUniforms,
+  heatmapTextureUniforms,
+  heatmapUniformValues,
+  heatmapTextureUniformValues
+};

package/src/render/program/hillshade_program.js

@@ -0,0 +1,77 @@
+const assert = require('assert');
+const { mat4 } = require('@mapbox/gl-matrix');
+
+const { Uniform1i, Uniform1f, Uniform2f, UniformColor, UniformMatrix4f } = require('../uniform_binding');
+const EXTENT = require('../../data/extent');
+const Coordinate = require('../../geo/coordinate');
+
+const hillshadeUniforms = (context, locations) => ({
+  u_matrix: new UniformMatrix4f(context, locations.u_matrix),
+  u_image: new Uniform1i(context, locations.u_image),
+  u_latrange: new Uniform2f(context, locations.u_latrange),
+  u_light: new Uniform2f(context, locations.u_light),
+  u_shadow: new UniformColor(context, locations.u_shadow),
+  u_highlight: new UniformColor(context, locations.u_highlight),
+  u_accent: new UniformColor(context, locations.u_accent)
+});
+
+const hillshadePrepareUniforms = (context, locations) => ({
+  u_matrix: new UniformMatrix4f(context, locations.u_matrix),
+  u_image: new Uniform1i(context, locations.u_image),
+  u_dimension: new Uniform2f(context, locations.u_dimension),
+  u_zoom: new Uniform1f(context, locations.u_zoom),
+  u_maxzoom: new Uniform1f(context, locations.u_maxzoom)
+});
+
+const hillshadeUniformValues = (painter, tile, layer) => {
+  const shadow = layer.paint.get('hillshade-shadow-color');
+  const highlight = layer.paint.get('hillshade-highlight-color');
+  const accent = layer.paint.get('hillshade-accent-color');
+
+  let azimuthal = layer.paint.get('hillshade-illumination-direction') * (Math.PI / 180);
+  // modify azimuthal angle by map rotation if light is anchored at the viewport
+  if (layer.paint.get('hillshade-illumination-anchor') === 'viewport') {
+    azimuthal -= painter.transform.angle;
+  }
+  const align = !painter.options.moving;
+  return {
+    u_matrix: painter.transform.calculatePosMatrix(tile.tileID.toUnwrapped(), align),
+    u_image: 0,
+    u_latrange: getTileLatRange(painter, tile.tileID),
+    u_light: [layer.paint.get('hillshade-exaggeration'), azimuthal],
+    u_shadow: shadow,
+    u_highlight: highlight,
+    u_accent: accent
+  };
+};
+
+const hillshadeUniformPrepareValues = (tile, maxzoom) => {
+  assert(tile.dem);
+  const stride = tile.dem.stride;
+  const matrix = mat4.create();
+  // Flip rendering at y axis.
+  mat4.ortho(matrix, 0, EXTENT, -EXTENT, 0, 0, 1);
+  mat4.translate(matrix, matrix, [0, -EXTENT, 0]);
+
+  return {
+    u_matrix: matrix,
+    u_image: 1,
+    u_dimension: [stride, stride],
+    u_zoom: tile.tileID.overscaledZ,
+    u_maxzoom: maxzoom
+  };
+};
+
+function getTileLatRange(painter, tileID) {
+  // for scaling the magnitude of a points slope by its latitude
+  const coordinate0 = tileID.toCoordinate();
+  const coordinate1 = new Coordinate(coordinate0.column, coordinate0.row + 1, coordinate0.zoom);
+  return [painter.transform.coordinateLocation(coordinate0).lat, painter.transform.coordinateLocation(coordinate1).lat];
+}
+
+module.exports = {
+  hillshadeUniforms,
+  hillshadePrepareUniforms,
+  hillshadeUniformValues,
+  hillshadeUniformPrepareValues
+};

package/src/render/program/line_program.js

@@ -0,0 +1,119 @@
+const { Uniform1i, Uniform1f, Uniform2f, Uniform4f, UniformMatrix4f } = require('../uniform_binding');
+const pixelsToTileUnits = require('../../source/pixels_to_tile_units');
+const browser = require('../../util/browser');
+
+const lineUniforms = (context, locations) => ({
+  u_matrix: new UniformMatrix4f(context, locations.u_matrix),
+  u_ratio: new Uniform1f(context, locations.u_ratio),
+  u_gl_units_to_pixels: new Uniform2f(context, locations.u_gl_units_to_pixels)
+});
+
+const lineGradientUniforms = (context, locations) => ({
+  u_matrix: new UniformMatrix4f(context, locations.u_matrix),
+  u_ratio: new Uniform1f(context, locations.u_ratio),
+  u_gl_units_to_pixels: new Uniform2f(context, locations.u_gl_units_to_pixels),
+  u_image: new Uniform1i(context, locations.u_image)
+});
+
+const linePatternUniforms = (context, locations) => ({
+  u_matrix: new UniformMatrix4f(context, locations.u_matrix),
+  u_texsize: new Uniform2f(context, locations.u_texsize),
+  u_ratio: new Uniform1f(context, locations.u_ratio),
+  u_image: new Uniform1i(context, locations.u_image),
+  u_gl_units_to_pixels: new Uniform2f(context, locations.u_gl_units_to_pixels),
+  u_scale: new Uniform4f(context, locations.u_scale),
+  u_fade: new Uniform1f(context, locations.u_fade)
+});
+
+const lineSDFUniforms = (context, locations) => ({
+  u_matrix: new UniformMatrix4f(context, locations.u_matrix),
+  u_ratio: new Uniform1f(context, locations.u_ratio),
+  u_gl_units_to_pixels: new Uniform2f(context, locations.u_gl_units_to_pixels),
+  u_patternscale_a: new Uniform2f(context, locations.u_patternscale_a),
+  u_patternscale_b: new Uniform2f(context, locations.u_patternscale_b),
+  u_sdfgamma: new Uniform1f(context, locations.u_sdfgamma),
+  u_image: new Uniform1i(context, locations.u_image),
+  u_tex_y_a: new Uniform1f(context, locations.u_tex_y_a),
+  u_tex_y_b: new Uniform1f(context, locations.u_tex_y_b),
+  u_mix: new Uniform1f(context, locations.u_mix)
+});
+
+const lineUniformValues = (painter, tile, layer) => {
+  const transform = painter.transform;
+
+  return {
+    u_matrix: calculateMatrix(painter, tile, layer),
+    u_ratio: 1 / pixelsToTileUnits(tile, 1, transform.zoom),
+    u_gl_units_to_pixels: [1 / transform.pixelsToGLUnits[0], 1 / transform.pixelsToGLUnits[1]]
+  };
+};
+
+const lineGradientUniformValues = (painter, tile, layer) => {
+  return Object.assign(lineUniformValues(painter, tile, layer), {
+    u_image: 0
+  });
+};
+
+const linePatternUniformValues = (painter, tile, layer, crossfade) => {
+  const transform = painter.transform;
+  const tileZoomRatio = calculateTileRatio(tile, transform);
+  return {
+    u_matrix: calculateMatrix(painter, tile, layer),
+    u_texsize: tile.imageAtlasTexture.size,
+    // camera zoom ratio
+    u_ratio: 1 / pixelsToTileUnits(tile, 1, transform.zoom),
+    u_image: 0,
+    // this assumes all images in the icon atlas texture have the same pixel ratio
+    u_scale: [browser.devicePixelRatio, tileZoomRatio, crossfade.fromScale, crossfade.toScale],
+    u_fade: crossfade.t,
+    u_gl_units_to_pixels: [1 / transform.pixelsToGLUnits[0], 1 / transform.pixelsToGLUnits[1]]
+  };
+};
+
+const lineSDFUniformValues = (painter, tile, layer, dasharray, crossfade) => {
+  const transform = painter.transform;
+  const lineAtlas = painter.lineAtlas;
+  const tileRatio = calculateTileRatio(tile, transform);
+
+  const round = layer.layout.get('line-cap') === 'round';
+
+  const posA = lineAtlas.getDash(dasharray.from, round);
+  const posB = lineAtlas.getDash(dasharray.to, round);
+
+  const widthA = posA.width * crossfade.fromScale;
+  const widthB = posB.width * crossfade.toScale;
+
+  return Object.assign(lineUniformValues(painter, tile, layer), {
+    u_patternscale_a: [tileRatio / widthA, -posA.height / 2],
+    u_patternscale_b: [tileRatio / widthB, -posB.height / 2],
+    u_sdfgamma: lineAtlas.width / (Math.min(widthA, widthB) * 256 * browser.devicePixelRatio) / 2,
+    u_image: 0,
+    u_tex_y_a: posA.y,
+    u_tex_y_b: posB.y,
+    u_mix: crossfade.t
+  });
+};
+
+function calculateTileRatio(tile, transform) {
+  return 1 / pixelsToTileUnits(tile, 1, transform.tileZoom);
+}
+
+function calculateMatrix(painter, tile, layer) {
+  return painter.translatePosMatrix(
+    tile.tileID.posMatrix,
+    tile,
+    layer.paint.get('line-translate'),
+    layer.paint.get('line-translate-anchor')
+  );
+}
+
+module.exports = {
+  lineUniforms,
+  lineGradientUniforms,
+  linePatternUniforms,
+  lineSDFUniforms,
+  lineUniformValues,
+  lineGradientUniformValues,
+  linePatternUniformValues,
+  lineSDFUniformValues
+};

package/src/render/program/pattern.js

@@ -0,0 +1,57 @@
+const assert = require('assert');
+const browser = require('../../util/browser');
+const pixelsToTileUnits = require('../../source/pixels_to_tile_units');
+
+function patternUniformValues(crossfade, painter, tile) {
+  const tileRatio = 1 / pixelsToTileUnits(tile, 1, painter.transform.tileZoom);
+
+  const numTiles = 2 ** tile.tileID.overscaledZ;
+  const tileSizeAtNearestZoom = (tile.tileSize * 2 ** painter.transform.tileZoom) / numTiles;
+
+  const pixelX = tileSizeAtNearestZoom * (tile.tileID.canonical.x + tile.tileID.wrap * numTiles);
+  const pixelY = tileSizeAtNearestZoom * tile.tileID.canonical.y;
+
+  return {
+    u_image: 0,
+    u_texsize: tile.imageAtlasTexture.size,
+    // this assumes all images in the icon atlas texture have the same pixel ratio
+    u_scale: [browser.devicePixelRatio, tileRatio, crossfade.fromScale, crossfade.toScale],
+    u_fade: crossfade.t,
+    // split the pixel coord into two pairs of 16 bit numbers. The glsl spec only guarantees 16 bits of precision.
+    u_pixel_coord_upper: [pixelX >> 16, pixelY >> 16],
+    u_pixel_coord_lower: [pixelX & 0xffff, pixelY & 0xffff]
+  };
+}
+
+function bgPatternUniformValues(image, crossfade, painter, tile) {
+  const imagePosA = painter.imageManager.getPattern(image.from);
+  const imagePosB = painter.imageManager.getPattern(image.to);
+  assert(imagePosA && imagePosB);
+  const { width, height } = painter.imageManager.getPixelSize();
+
+  const numTiles = 2 ** tile.tileID.overscaledZ;
+  const tileSizeAtNearestZoom = (tile.tileSize * 2 ** painter.transform.tileZoom) / numTiles;
+
+  const pixelX = tileSizeAtNearestZoom * (tile.tileID.canonical.x + tile.tileID.wrap * numTiles);
+  const pixelY = tileSizeAtNearestZoom * tile.tileID.canonical.y;
+
+  return {
+    u_image: 0,
+    u_pattern_tl_a: imagePosA.tl,
+    u_pattern_br_a: imagePosA.br,
+    u_pattern_tl_b: imagePosB.tl,
+    u_pattern_br_b: imagePosB.br,
+    u_texsize: [width, height],
+    u_mix: crossfade.t,
+    u_pattern_size_a: imagePosA.displaySize,
+    u_pattern_size_b: imagePosB.displaySize,
+    u_scale_a: crossfade.fromScale,
+    u_scale_b: crossfade.toScale,
+    u_tile_units_to_pixels: 1 / pixelsToTileUnits(tile, 1, painter.transform.tileZoom),
+    // split the pixel coord into two pairs of 16 bit numbers. The glsl spec only guarantees 16 bits of precision.
+    u_pixel_coord_upper: [pixelX >> 16, pixelY >> 16],
+    u_pixel_coord_lower: [pixelX & 0xffff, pixelY & 0xffff]
+  };
+}
+
+module.exports = { bgPatternUniformValues, patternUniformValues };

package/src/render/program/program_uniforms.js

@@ -0,0 +1,46 @@
+const { fillExtrusionUniforms, fillExtrusionPatternUniforms } = require('./fill_extrusion_program');
+const {
+  fillUniforms,
+  fillPatternUniforms,
+  fillOutlineUniforms,
+  fillOutlinePatternUniforms
+} = require('./fill_program');
+const { circleUniforms } = require('./circle_program');
+const { collisionUniforms } = require('./collision_program');
+const { debugUniforms } = require('./debug_program');
+const { clippingMaskUniforms } = require('./clipping_mask_program');
+const { heatmapUniforms, heatmapTextureUniforms } = require('./heatmap_program');
+const { hillshadeUniforms, hillshadePrepareUniforms } = require('./hillshade_program');
+const { lineUniforms, lineGradientUniforms, linePatternUniforms, lineSDFUniforms } = require('./line_program');
+const { rasterUniforms } = require('./raster_program');
+const { symbolIconUniforms, symbolSDFUniforms } = require('./symbol_program');
+const { backgroundUniforms, backgroundPatternUniforms } = require('./background_program');
+
+const programUniforms = {
+  fillExtrusion: fillExtrusionUniforms,
+  fillExtrusionPattern: fillExtrusionPatternUniforms,
+  fill: fillUniforms,
+  fillPattern: fillPatternUniforms,
+  fillOutline: fillOutlineUniforms,
+  fillOutlinePattern: fillOutlinePatternUniforms,
+  circle: circleUniforms,
+  collisionBox: collisionUniforms,
+  collisionCircle: collisionUniforms,
+  debug: debugUniforms,
+  clippingMask: clippingMaskUniforms,
+  heatmap: heatmapUniforms,
+  heatmapTexture: heatmapTextureUniforms,
+  hillshade: hillshadeUniforms,
+  hillshadePrepare: hillshadePrepareUniforms,
+  line: lineUniforms,
+  lineGradient: lineGradientUniforms,
+  linePattern: linePatternUniforms,
+  lineSDF: lineSDFUniforms,
+  raster: rasterUniforms,
+  symbolIcon: symbolIconUniforms,
+  symbolSDF: symbolSDFUniforms,
+  background: backgroundUniforms,
+  backgroundPattern: backgroundPatternUniforms
+};
+
+module.exports = { programUniforms };

package/src/render/program/raster_program.js

@@ -0,0 +1,50 @@
+const { Uniform1i, Uniform1f, Uniform2f, Uniform3f, UniformMatrix4f } = require('../uniform_binding');
+
+const rasterUniforms = (context, locations) => ({
+  u_matrix: new UniformMatrix4f(context, locations.u_matrix),
+  u_tl_parent: new Uniform2f(context, locations.u_tl_parent),
+  u_scale_parent: new Uniform1f(context, locations.u_scale_parent),
+  u_buffer_scale: new Uniform1f(context, locations.u_buffer_scale),
+  u_fade_t: new Uniform1f(context, locations.u_fade_t),
+  u_opacity: new Uniform1f(context, locations.u_opacity),
+  u_image0: new Uniform1i(context, locations.u_image0),
+  u_image1: new Uniform1i(context, locations.u_image1),
+  u_brightness_low: new Uniform1f(context, locations.u_brightness_low),
+  u_brightness_high: new Uniform1f(context, locations.u_brightness_high),
+  u_saturation_factor: new Uniform1f(context, locations.u_saturation_factor),
+  u_contrast_factor: new Uniform1f(context, locations.u_contrast_factor),
+  u_spin_weights: new Uniform3f(context, locations.u_spin_weights)
+});
+
+const rasterUniformValues = (matrix, parentTL, parentScaleBy, fade, layer) => ({
+  u_matrix: matrix,
+  u_tl_parent: parentTL,
+  u_scale_parent: parentScaleBy,
+  u_buffer_scale: 1,
+  u_fade_t: fade.mix,
+  u_opacity: fade.opacity * layer.paint.get('raster-opacity'),
+  u_image0: 0,
+  u_image1: 1,
+  u_brightness_low: layer.paint.get('raster-brightness-min'),
+  u_brightness_high: layer.paint.get('raster-brightness-max'),
+  u_saturation_factor: saturationFactor(layer.paint.get('raster-saturation')),
+  u_contrast_factor: contrastFactor(layer.paint.get('raster-contrast')),
+  u_spin_weights: spinWeights(layer.paint.get('raster-hue-rotate'))
+});
+
+function spinWeights(angle) {
+  angle *= Math.PI / 180;
+  const s = Math.sin(angle);
+  const c = Math.cos(angle);
+  return [(2 * c + 1) / 3, (-Math.sqrt(3) * s - c + 1) / 3, (Math.sqrt(3) * s - c + 1) / 3];
+}
+
+function contrastFactor(contrast) {
+  return contrast > 0 ? 1 / (1 - contrast) : 1 + contrast;
+}
+
+function saturationFactor(saturation) {
+  return saturation > 0 ? 1 - 1 / (1.001 - saturation) : -saturation;
+}
+
+module.exports = { rasterUniforms, rasterUniformValues };