Merge pull request #1 from mapbox/masterupstream/friedbunny-external-pr-14135

Merge Master

12 files changed, 188 insertions, 126 deletions

diff --git a/src/mbgl/renderer/layers/render_background_layer.cpp b/src/mbgl/renderer/layers/render_background_layer.cpp
index 32e05a38ab..269b227a7d 100644
--- a/src/mbgl/renderer/layers/render_background_layer.cpp
+++ b/src/mbgl/renderer/layers/render_background_layer.cpp
@@ -9,7 +9,6 @@
 #include <mbgl/util/tile_cover.hpp>
 #include <mbgl/map/transform_state.hpp>
 #include <mbgl/gfx/cull_face_mode.hpp>
-#include <mbgl/gl/context.hpp>
 
 namespace mbgl {
 
@@ -103,7 +102,7 @@ void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) {
                     parameters.state
                 ),
                 BackgroundPatternProgram::TextureBindings{
-                    textures::u_image::Value{ parameters.imageManager.textureBinding(parameters.context) },
+                    textures::image::Value{ parameters.imageManager.textureBinding(parameters.context) },
                 }
             );
         }
@@ -112,9 +111,9 @@ void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) {
             draw(
                 parameters.programs.getBackgroundLayerPrograms().background,
                 BackgroundProgram::LayoutUniformValues {
-                    uniforms::u_matrix::Value( parameters.matrixForTile(tileID) ),
-                    uniforms::u_color::Value( evaluated.get<BackgroundColor>() ),
-                    uniforms::u_opacity::Value( evaluated.get<BackgroundOpacity>() ),
+                    uniforms::matrix::Value( parameters.matrixForTile(tileID) ),
+                    uniforms::color::Value( evaluated.get<BackgroundColor>() ),
+                    uniforms::opacity::Value( evaluated.get<BackgroundOpacity>() ),
                 },
                 BackgroundProgram::TextureBindings{}
             );
diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp
index 60a3bf8e01..1c13a6152b 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.cpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.cpp
@@ -8,7 +8,6 @@
 #include <mbgl/style/layers/circle_layer_impl.hpp>
 #include <mbgl/geometry/feature_index.hpp>
 #include <mbgl/gfx/cull_face_mode.hpp>
-#include <mbgl/gl/context.hpp>
 #include <mbgl/util/math.hpp>
 #include <mbgl/util/intersection_tests.hpp>
 
@@ -66,23 +65,23 @@ void RenderCircleLayer::render(PaintParameters& parameters, RenderSource*) {
 
         const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID());
 
-        auto& programInstance = parameters.programs.getCircleLayerPrograms().circle.get(evaluated);
+        auto& programInstance = parameters.programs.getCircleLayerPrograms().circle;
    
         const auto allUniformValues = programInstance.computeAllUniformValues(
             CircleProgram::LayoutUniformValues {
-                uniforms::u_matrix::Value(
+                uniforms::matrix::Value(
                     tile.translatedMatrix(evaluated.get<CircleTranslate>(),
                                           evaluated.get<CircleTranslateAnchor>(),
                                           parameters.state)
                 ),
-                uniforms::u_scale_with_map::Value( scaleWithMap ),
-                uniforms::u_extrude_scale::Value( pitchWithMap
+                uniforms::scale_with_map::Value( scaleWithMap ),
+                uniforms::extrude_scale::Value( pitchWithMap
                     ? std::array<float, 2> {{
                         tile.id.pixelsToTileUnits(1, parameters.state.getZoom()),
                         tile.id.pixelsToTileUnits(1, parameters.state.getZoom()) }}
                     : parameters.pixelsToGLUnits ),
-                uniforms::u_camera_to_center_distance::Value( parameters.state.getCameraToCenterDistance() ),
-                uniforms::u_pitch_with_map::Value( pitchWithMap )
+                uniforms::camera_to_center_distance::Value( parameters.state.getCameraToCenterDistance() ),
+                uniforms::pitch_with_map::Value( pitchWithMap )
             },
             paintPropertyBinders,
             evaluated,
diff --git a/src/mbgl/renderer/layers/render_custom_layer.cpp b/src/mbgl/renderer/layers/render_custom_layer.cpp
index bcb0decb74..8ac7d29ff6 100644
--- a/src/mbgl/renderer/layers/render_custom_layer.cpp
+++ b/src/mbgl/renderer/layers/render_custom_layer.cpp
@@ -57,7 +57,8 @@ void RenderCustomLayer::render(PaintParameters& paintParameters, RenderSource*)
         MBGL_CHECK_ERROR(host->initialize());
     }
 
-    gl::Context& glContext = paintParameters.context;
+    // TODO: remove cast
+    gl::Context& glContext = reinterpret_cast<gl::Context&>(paintParameters.context);
     const TransformState& state = paintParameters.state;
 
     // Reset GL state to a known state so the CustomLayer always has a clean slate.
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
index 5af4732aa3..13ef84f169 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
@@ -51,6 +51,9 @@ bool RenderFillExtrusionLayer::hasCrossfade() const {
 }
 
 void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*) {
+    // TODO: remove cast
+    gl::Context& glContext = reinterpret_cast<gl::Context&>(parameters.context);
+
     if (parameters.pass == RenderPass::Opaque) {
         return;
     }
@@ -69,8 +72,8 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
         // Flag the depth buffer as no longer needing to be cleared for the remainder of this pass.
         parameters.staticData.depthRenderbuffer->shouldClear(false);
 
-        parameters.context.setStencilMode(gfx::StencilMode::disabled());
-        parameters.context.clear(Color{ 0.0f, 0.0f, 0.0f, 0.0f }, depthClearValue, {});
+        glContext.setStencilMode(gfx::StencilMode::disabled());
+        glContext.clear(Color{ 0.0f, 0.0f, 0.0f, 0.0f }, depthClearValue, {});
 
         auto draw = [&](auto& programInstance, const auto& tileBucket, auto&& uniformValues,
                         const optional<ImagePosition>& patternPositionA,
@@ -116,7 +119,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
                 FillExtrusionBucket& bucket = *bucket_;
 
                 draw(
-                    parameters.programs.getFillExtrusionLayerPrograms().fillExtrusion.get(evaluated),
+                    parameters.programs.getFillExtrusionLayerPrograms().fillExtrusion,
                     bucket,
                     FillExtrusionProgram::layoutUniformValues(
                         tile.translatedClipMatrix(evaluated.get<FillExtrusionTranslate>(),
@@ -143,7 +146,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
                 FillExtrusionBucket& bucket = *bucket_;
 
                 draw(
-                    parameters.programs.getFillExtrusionLayerPrograms().fillExtrusionPattern.get(evaluated),
+                    parameters.programs.getFillExtrusionLayerPrograms().fillExtrusionPattern,
                     bucket,
                     FillExtrusionPatternProgram::layoutUniformValues(
                         tile.translatedClipMatrix(evaluated.get<FillExtrusionTranslate>(),
@@ -160,7 +163,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
                     patternPosA,
                     patternPosB,
                     FillExtrusionPatternProgram::TextureBindings{
-                        textures::u_image::Value{ *geometryTile.iconAtlasTexture->resource, gfx::TextureFilterType::Linear },
+                        textures::image::Value{ *geometryTile.iconAtlasTexture->resource, gfx::TextureFilterType::Linear },
                     }
                 );
             }
@@ -179,9 +182,9 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
 
         const auto allUniformValues = programInstance.computeAllUniformValues(
             ExtrusionTextureProgram::LayoutUniformValues{
-                uniforms::u_matrix::Value( viewportMat ),
-                uniforms::u_world::Value( size ),
-                uniforms::u_opacity::Value( evaluated.get<FillExtrusionOpacity>() )
+                uniforms::matrix::Value( viewportMat ),
+                uniforms::world::Value( size ),
+                uniforms::opacity::Value( evaluated.get<FillExtrusionOpacity>() )
             },
             paintAttributeData,
             properties,
@@ -207,7 +210,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
             allUniformValues,
             allAttributeBindings,
             ExtrusionTextureProgram::TextureBindings{
-                textures::u_image::Value{ *renderTexture->getTexture().resource },
+                textures::image::Value{ *renderTexture->getTexture().resource },
             },
             getID());
     }
diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp
index 64f3448c69..205a38e380 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.cpp
@@ -63,6 +63,9 @@ bool RenderFillLayer::hasCrossfade() const {
 }
 
 void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
+    // TODO: remove cast
+    gl::Context& glContext = reinterpret_cast<gl::Context&>(parameters.context);
+
     if (unevaluated.get<FillPattern>().isUndefined()) {
         for (const RenderTile& tile : renderTiles) {
             auto bucket_ = tile.tile.getBucket<FillBucket>(*baseImpl);
@@ -71,24 +74,22 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
             }
             FillBucket& bucket = *bucket_;
 
-            auto draw = [&] (auto& program,
+            auto draw = [&] (auto& programInstance,
                              const auto& drawMode,
                              const auto& depthMode,
                              const auto& indexBuffer,
                              const auto& segments,
                              auto&& textureBindings) {
-                auto& programInstance = program.get(evaluated);
-
                 const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID());
 
                 const auto allUniformValues = programInstance.computeAllUniformValues(
                     FillProgram::LayoutUniformValues {
-                        uniforms::u_matrix::Value(
+                        uniforms::matrix::Value(
                             tile.translatedMatrix(evaluated.get<FillTranslate>(),
                                                   evaluated.get<FillTranslateAnchor>(),
                                                   parameters.state)
                         ),
-                        uniforms::u_world::Value( parameters.context.viewport.getCurrentValue().size ),
+                        uniforms::world::Value( glContext.viewport.getCurrentValue().size ),
                     },
                     paintPropertyBinders,
                     evaluated,
@@ -159,14 +160,12 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
             }
             FillBucket& bucket = *bucket_;
 
-            auto draw = [&] (auto& program,
+            auto draw = [&] (auto& programInstance,
                              const auto& drawMode,
                              const auto& depthMode,
                              const auto& indexBuffer,
                              const auto& segments,
                              auto&& textureBindings) {
-                auto& programInstance = program.get(evaluated);
-
                 const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID());
                 paintPropertyBinders.setPatternParameters(patternPosA, patternPosB, crossfade);
 
@@ -175,7 +174,7 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
                         tile.translatedMatrix(evaluated.get<FillTranslate>(),
                                               evaluated.get<FillTranslateAnchor>(),
                                               parameters.state),
-                        parameters.context.viewport.getCurrentValue().size,
+                        glContext.viewport.getCurrentValue().size,
                         geometryTile.iconAtlasTexture->size,
                         crossfade,
                         tile.id,
@@ -216,7 +215,7 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
                  *bucket.triangleIndexBuffer,
                  bucket.triangleSegments,
                  FillPatternProgram::TextureBindings{
-                     textures::u_image::Value{ *geometryTile.iconAtlasTexture->resource, gfx::TextureFilterType::Linear },
+                     textures::image::Value{ *geometryTile.iconAtlasTexture->resource, gfx::TextureFilterType::Linear },
                  });
 
             if (evaluated.get<FillAntialias>() && unevaluated.get<FillOutlineColor>().isUndefined()) {
@@ -226,7 +225,7 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
                      *bucket.lineIndexBuffer,
                      bucket.lineSegments,
                      FillOutlinePatternProgram::TextureBindings{
-                         textures::u_image::Value{ *geometryTile.iconAtlasTexture->resource, gfx::TextureFilterType::Linear },
+                         textures::image::Value{ *geometryTile.iconAtlasTexture->resource, gfx::TextureFilterType::Linear },
                      });
             }
         }
diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.cpp b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
index efc16fb28a..f8ba68965e 100644
--- a/src/mbgl/renderer/layers/render_heatmap_layer.cpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
@@ -52,12 +52,15 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) {
         return;
     }
 
+    // TODO: remove cast
+    gl::Context& glContext = reinterpret_cast<gl::Context&>(parameters.context);
+
     if (parameters.pass == RenderPass::Pass3D) {
         const auto& viewportSize = parameters.staticData.backendSize;
         const auto size = Size{viewportSize.width / 4, viewportSize.height / 4};
 
         if (!renderTexture || renderTexture->getSize() != size) {
-            if (parameters.context.supportsHalfFloatTextures) {
+            if (glContext.supportsHalfFloatTextures) {
                 renderTexture = OffscreenTexture(parameters.context, size, gfx::TextureChannelDataType::HalfFloat);
 
                 try {
@@ -65,11 +68,11 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) {
                 } catch (const std::runtime_error& ex) {
                     // can't render to a half-float texture; falling back to unsigned byte one
                     renderTexture = nullopt;
-                    parameters.context.supportsHalfFloatTextures = false;
+                    glContext.supportsHalfFloatTextures = false;
                 }
             }
 
-            if (!parameters.context.supportsHalfFloatTextures || !renderTexture) {
+            if (!glContext.supportsHalfFloatTextures || !renderTexture) {
                 renderTexture = OffscreenTexture(parameters.context, size, gfx::TextureChannelDataType::UnsignedByte);
                 renderTexture->bind();
             }
@@ -82,7 +85,7 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) {
             colorRampTexture = parameters.context.createTexture(colorRamp, gfx::TextureChannelDataType::UnsignedByte);
         }
 
-        parameters.context.clear(Color{ 0.0f, 0.0f, 0.0f, 1.0f }, {}, {});
+        glContext.clear(Color{ 0.0f, 0.0f, 0.0f, 1.0f }, {}, {});
 
         for (const RenderTile& tile : renderTiles) {
             auto bucket_ = tile.tile.getBucket<HeatmapBucket>(*baseImpl);
@@ -99,13 +102,13 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) {
 
             const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID());
 
-            auto& programInstance = parameters.programs.getHeatmapLayerPrograms().heatmap.get(evaluated);
+            auto& programInstance = parameters.programs.getHeatmapLayerPrograms().heatmap;
        
             const auto allUniformValues = programInstance.computeAllUniformValues(
                 HeatmapProgram::LayoutUniformValues {
-                    uniforms::u_intensity::Value( evaluated.get<style::HeatmapIntensity>() ),
-                    uniforms::u_matrix::Value( tile.matrix ),
-                    uniforms::heatmap::u_extrude_scale::Value( extrudeScale )
+                    uniforms::intensity::Value( evaluated.get<style::HeatmapIntensity>() ),
+                    uniforms::matrix::Value( tile.matrix ),
+                    uniforms::heatmap::extrude_scale::Value( extrudeScale )
                 },
                 paintPropertyBinders,
                 evaluated,
@@ -148,9 +151,9 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) {
 
         const auto allUniformValues = programInstance.computeAllUniformValues(
             HeatmapTextureProgram::LayoutUniformValues{
-                uniforms::u_matrix::Value( viewportMat ),
-                uniforms::u_world::Value( size ),
-                uniforms::u_opacity::Value( evaluated.get<HeatmapOpacity>() )
+                uniforms::matrix::Value( viewportMat ),
+                uniforms::world::Value( size ),
+                uniforms::opacity::Value( evaluated.get<HeatmapOpacity>() )
             },
             paintAttributeData,
             properties,
@@ -176,8 +179,8 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) {
             allUniformValues,
             allAttributeBindings,
             HeatmapTextureProgram::TextureBindings{
-                textures::u_image::Value{ *renderTexture->getTexture().resource, gfx::TextureFilterType::Linear },
-                textures::u_color_ramp::Value{ *colorRampTexture->resource, gfx::TextureFilterType::Linear },
+                textures::image::Value{ *renderTexture->getTexture().resource, gfx::TextureFilterType::Linear },
+                textures::color_ramp::Value{ *colorRampTexture->resource, gfx::TextureFilterType::Linear },
             },
             getID()
         );
diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.cpp b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
index 00ecad444c..1d030f5946 100644
--- a/src/mbgl/renderer/layers/render_hillshade_layer.cpp
+++ b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
@@ -10,7 +10,6 @@
 #include <mbgl/tile/tile.hpp>
 #include <mbgl/style/layers/hillshade_layer_impl.hpp>
 #include <mbgl/gfx/cull_face_mode.hpp>
-#include <mbgl/gl/context.hpp>
 #include <mbgl/util/geo.hpp>
 #include <mbgl/util/offscreen_texture.hpp>
 
@@ -77,12 +76,12 @@ void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src
 
         const auto allUniformValues = programInstance.computeAllUniformValues(
             HillshadeProgram::LayoutUniformValues {
-                uniforms::u_matrix::Value( matrix ),
-                uniforms::u_highlight::Value( evaluated.get<HillshadeHighlightColor>() ),
-                uniforms::u_shadow::Value( evaluated.get<HillshadeShadowColor>() ),
-                uniforms::u_accent::Value( evaluated.get<HillshadeAccentColor>() ),
-                uniforms::u_light::Value( getLight(parameters) ),
-                uniforms::u_latrange::Value( getLatRange(id) ),
+                uniforms::matrix::Value( matrix ),
+                uniforms::highlight::Value( evaluated.get<HillshadeHighlightColor>() ),
+                uniforms::shadow::Value( evaluated.get<HillshadeShadowColor>() ),
+                uniforms::accent::Value( evaluated.get<HillshadeAccentColor>() ),
+                uniforms::light::Value( getLight(parameters) ),
+                uniforms::latrange::Value( getLatRange(id) ),
             },
             paintAttributeData,
             evaluated,
@@ -141,10 +140,10 @@ void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src
 
             const auto allUniformValues = programInstance.computeAllUniformValues(
                 HillshadePrepareProgram::LayoutUniformValues {
-                    uniforms::u_matrix::Value( mat ),
-                    uniforms::u_dimension::Value( {{stride, stride}} ),
-                    uniforms::u_zoom::Value( float(tile.id.canonical.z) ),
-                    uniforms::u_maxzoom::Value( float(maxzoom) ),
+                    uniforms::matrix::Value( mat ),
+                    uniforms::dimension::Value( {{stride, stride}} ),
+                    uniforms::zoom::Value( float(tile.id.canonical.z) ),
+                    uniforms::maxzoom::Value( float(maxzoom) ),
                 },
                 paintAttributeData,
                 properties,
@@ -170,7 +169,7 @@ void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src
                 allUniformValues,
                 allAttributeBindings,
                 HillshadePrepareProgram::TextureBindings{
-                    textures::u_image::Value{ *bucket.dem->resource },
+                    textures::image::Value{ *bucket.dem->resource },
                 },
                 getID()
             );
@@ -187,7 +186,7 @@ void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src
                      bucket.segments,
                      tile.id,
                      HillshadeProgram::TextureBindings{
-                         textures::u_image::Value{ *bucket.texture->resource,  gfx::TextureFilterType::Linear },
+                         textures::image::Value{ *bucket.texture->resource,  gfx::TextureFilterType::Linear },
                      });
             } else {
                 // Draw the full tile.
@@ -197,7 +196,7 @@ void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src
                      parameters.staticData.rasterSegments,
                      tile.id,
                      HillshadeProgram::TextureBindings{
-                         textures::u_image::Value{ *bucket.texture->resource,  gfx::TextureFilterType::Linear },
+                         textures::image::Value{ *bucket.texture->resource,  gfx::TextureFilterType::Linear },
                      });
             }
         }
diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp
index eee151ccaa..2d246df7f4 100644
--- a/src/mbgl/renderer/layers/render_line_layer.cpp
+++ b/src/mbgl/renderer/layers/render_line_layer.cpp
@@ -9,7 +9,6 @@
 #include <mbgl/tile/tile.hpp>
 #include <mbgl/style/layers/line_layer_impl.hpp>
 #include <mbgl/gfx/cull_face_mode.hpp>
-#include <mbgl/gl/context.hpp>
 #include <mbgl/geometry/feature_index.hpp>
 #include <mbgl/util/math.hpp>
 #include <mbgl/util/intersection_tests.hpp>
@@ -34,10 +33,7 @@ void RenderLineLayer::transition(const TransitionParameters& parameters) {
 }
 
 void RenderLineLayer::evaluate(const PropertyEvaluationParameters& parameters) {
-    style::Properties<LineFloorwidth>::Unevaluated extra(unevaluated.get<style::LineWidth>());
-    evaluated = RenderLinePaintProperties::PossiblyEvaluated(
-        unevaluated.evaluate(parameters).concat(extra.evaluate(parameters)));
-
+    evaluated = unevaluated.evaluate(parameters);
     crossfade = parameters.getCrossfadeParameters();
 
     passes = (evaluated.get<style::LineOpacity>().constantOr(1.0) > 0
@@ -66,11 +62,10 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
         }
         LineBucket& bucket = *bucket_;
 
-        auto draw = [&](auto& program, auto&& uniformValues,
+        auto draw = [&](auto& programInstance,
+                        auto&& uniformValues,
                         const optional<ImagePosition>& patternPositionA,
                         const optional<ImagePosition>& patternPositionB, auto&& textureBindings) {
-            auto& programInstance = program.get(evaluated);
-
             const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID());
 
             paintPropertyBinders.setPatternParameters(patternPositionA, patternPositionB, crossfade);
@@ -145,10 +140,10 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
                      texsize,
                      crossfade,
                      parameters.pixelRatio),
-                     *posA,
-                     *posB,
+                     posA,
+                     posB,
                      LinePatternProgram::TextureBindings{
-                         textures::u_image::Value{ *geometryTile.iconAtlasTexture->resource, gfx::TextureFilterType::Linear },
+                         textures::image::Value{ *geometryTile.iconAtlasTexture->resource, gfx::TextureFilterType::Linear },
                      });
         } else if (!unevaluated.get<LineGradient>().getValue().isUndefined()) {
             if (!colorRampTexture) {
@@ -164,7 +159,7 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
                     {},
                     {},
                     LineGradientProgram::TextureBindings{
-                        textures::u_image::Value{ *colorRampTexture->resource, gfx::TextureFilterType::Linear },
+                        textures::image::Value{ *colorRampTexture->resource, gfx::TextureFilterType::Linear },
                     });
         } else {
             draw(parameters.programs.getLineLayerPrograms().line,
diff --git a/src/mbgl/renderer/layers/render_line_layer.hpp b/src/mbgl/renderer/layers/render_line_layer.hpp
index 186b740234..cb4492ebc3 100644
--- a/src/mbgl/renderer/layers/render_line_layer.hpp
+++ b/src/mbgl/renderer/layers/render_line_layer.hpp
@@ -10,15 +10,6 @@
 
 namespace mbgl {
 
-struct LineFloorwidth : style::DataDrivenPaintProperty<float, attributes::a_floorwidth, uniforms::u_floorwidth> {
-    using EvaluatorType = DataDrivenPropertyEvaluator<float, true>;
-    static float defaultValue() { return 1.0; }
-};
-
-class RenderLinePaintProperties : public style::ConcatenateProperties<
-    style::LinePaintProperties,
-    style::Properties<LineFloorwidth>> {};
-
 class RenderLineLayer: public RenderLayer {
 public:
     using StyleLayerImpl = style::LineLayer::Impl;
@@ -44,7 +35,7 @@ public:
 
     // Paint properties
     style::LinePaintProperties::Unevaluated unevaluated;
-    RenderLinePaintProperties::PossiblyEvaluated evaluated;
+    style::LinePaintProperties::PossiblyEvaluated evaluated;
 
     const style::LineLayer::Impl& impl() const;
 
diff --git a/src/mbgl/renderer/layers/render_raster_layer.cpp b/src/mbgl/renderer/layers/render_raster_layer.cpp
index c8f00eb1fd..94c4a8dc42 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.cpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.cpp
@@ -8,7 +8,6 @@
 #include <mbgl/programs/raster_program.hpp>
 #include <mbgl/tile/tile.hpp>
 #include <mbgl/gfx/cull_face_mode.hpp>
-#include <mbgl/gl/context.hpp>
 #include <mbgl/style/layers/raster_layer_impl.hpp>
 
 namespace mbgl {
@@ -85,17 +84,17 @@ void RenderRasterLayer::render(PaintParameters& parameters, RenderSource* source
 
         const auto allUniformValues = programInstance.computeAllUniformValues(
             RasterProgram::LayoutUniformValues {
-                uniforms::u_matrix::Value( matrix ),
-                uniforms::u_opacity::Value( evaluated.get<RasterOpacity>() ),
-                uniforms::u_fade_t::Value( 1 ),
-                uniforms::u_brightness_low::Value( evaluated.get<RasterBrightnessMin>() ),
-                uniforms::u_brightness_high::Value( evaluated.get<RasterBrightnessMax>() ),
-                uniforms::u_saturation_factor::Value( saturationFactor(evaluated.get<RasterSaturation>()) ),
-                uniforms::u_contrast_factor::Value( contrastFactor(evaluated.get<RasterContrast>()) ),
-                uniforms::u_spin_weights::Value( spinWeights(evaluated.get<RasterHueRotate>()) ),
-                uniforms::u_buffer_scale::Value( 1.0f ),
-                uniforms::u_scale_parent::Value( 1.0f ),
-                uniforms::u_tl_parent::Value( std::array<float, 2> {{ 0.0f, 0.0f }} ),
+                uniforms::matrix::Value( matrix ),
+                uniforms::opacity::Value( evaluated.get<RasterOpacity>() ),
+                uniforms::fade_t::Value( 1 ),
+                uniforms::brightness_low::Value( evaluated.get<RasterBrightnessMin>() ),
+                uniforms::brightness_high::Value( evaluated.get<RasterBrightnessMax>() ),
+                uniforms::saturation_factor::Value( saturationFactor(evaluated.get<RasterSaturation>()) ),
+                uniforms::contrast_factor::Value( contrastFactor(evaluated.get<RasterContrast>()) ),
+                uniforms::spin_weights::Value( spinWeights(evaluated.get<RasterHueRotate>()) ),
+                uniforms::buffer_scale::Value( 1.0f ),
+                uniforms::scale_parent::Value( 1.0f ),
+                uniforms::tl_parent::Value( std::array<float, 2> {{ 0.0f, 0.0f }} ),
             },
             paintAttributeData,
             evaluated,
@@ -138,8 +137,8 @@ void RenderRasterLayer::render(PaintParameters& parameters, RenderSource* source
                      *bucket.indexBuffer,
                      bucket.segments,
                      RasterProgram::TextureBindings{
-                         textures::u_image0::Value{ *bucket.texture->resource, filter },
-                         textures::u_image1::Value{ *bucket.texture->resource, filter },
+                         textures::image0::Value{ *bucket.texture->resource, filter },
+                         textures::image1::Value{ *bucket.texture->resource, filter },
                      });
             }
         }
@@ -162,8 +161,8 @@ void RenderRasterLayer::render(PaintParameters& parameters, RenderSource* source
                      *bucket.indexBuffer,
                      bucket.segments,
                      RasterProgram::TextureBindings{
-                         textures::u_image0::Value{ *bucket.texture->resource, filter },
-                         textures::u_image1::Value{ *bucket.texture->resource, filter },
+                         textures::image0::Value{ *bucket.texture->resource, filter },
+                         textures::image1::Value{ *bucket.texture->resource, filter },
                      });
             } else {
                 // Draw the full tile.
@@ -172,8 +171,8 @@ void RenderRasterLayer::render(PaintParameters& parameters, RenderSource* source
                      parameters.staticData.quadTriangleIndexBuffer,
                      parameters.staticData.rasterSegments,
                      RasterProgram::TextureBindings{
-                         textures::u_image0::Value{ *bucket.texture->resource, filter },
-                         textures::u_image1::Value{ *bucket.texture->resource, filter },
+                         textures::image0::Value{ *bucket.texture->resource, filter },
+                         textures::image1::Value{ *bucket.texture->resource, filter },
                      });
             }
         }
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.cpp b/src/mbgl/renderer/layers/render_symbol_layer.cpp
index 31d92dd414..d7951c647a 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.cpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp
@@ -5,6 +5,7 @@
 #include <mbgl/renderer/render_tile.hpp>
 #include <mbgl/renderer/paint_parameters.hpp>
 #include <mbgl/text/glyph_atlas.hpp>
+#include <mbgl/text/shaping.hpp>
 #include <mbgl/programs/programs.hpp>
 #include <mbgl/programs/symbol_program.hpp>
 #include <mbgl/programs/collision_box_program.hpp>
@@ -13,8 +14,8 @@
 #include <mbgl/tile/geometry_tile_data.hpp>
 #include <mbgl/style/layers/symbol_layer_impl.hpp>
 #include <mbgl/gfx/cull_face_mode.hpp>
-#include <mbgl/gl/context.hpp>
 #include <mbgl/layout/symbol_projection.hpp>
+#include <mbgl/layout/symbol_layout.hpp>
 #include <mbgl/util/math.hpp>
 
 #include <cmath>
@@ -23,6 +24,19 @@ namespace mbgl {
 
 using namespace style;
 
+namespace {
+Point<float> calculateVariableRenderShift(style::SymbolAnchorType anchor, float width, float height, float radialOffset, float textBoxScale, float renderTextSize) {
+    AnchorAlignment alignment = AnchorAlignment::getAnchorAlignment(anchor);
+    float shiftX = -(alignment.horizontalAlign - 0.5f) * width;
+    float shiftY = -(alignment.verticalAlign - 0.5f) * height;
+    Point<float> offset = SymbolLayout::evaluateRadialOffset(anchor, radialOffset);
+    return Point<float>(
+        (shiftX / textBoxScale + offset.x) * renderTextSize,
+        (shiftY / textBoxScale + offset.y) * renderTextSize
+    );
+}
+} // namespace
+
 RenderSymbolLayer::RenderSymbolLayer(Immutable<style::SymbolLayer::Impl> _impl)
     : RenderLayer(std::move(_impl)),
       unevaluated(impl().paint.untransitioned()) {
@@ -89,17 +103,14 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
         const auto& evaluated_ = bucketPaintProperties.evaluated;
         const auto& layout = bucket.layout;
 
-        auto draw = [&] (auto& program,
+        auto draw = [&] (auto& programInstance,
                          auto&& uniformValues,
                          const auto& buffers,
                          const auto& symbolSizeBinder,
                          const SymbolPropertyValues& values_,
                          const auto& binders,
                          const auto& paintProperties,
-                         auto&& textureBindings)
-        {
-            auto& programInstance = program.get(paintProperties);
-
+                         auto&& textureBindings) {
             const auto allUniformValues = programInstance.computeAllUniformValues(
                 std::move(uniformValues),
                 *symbolSizeBinder,
@@ -172,7 +183,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
             if (bucket.sdfIcons) {
                 if (values.hasHalo) {
                     draw(parameters.programs.getSymbolLayerPrograms().symbolIconSDF,
-                         SymbolSDFIconProgram::layoutUniformValues(false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Halo),
+                         SymbolSDFIconProgram::layoutUniformValues(false, false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Halo),
                          bucket.icon,
                          bucket.iconSizeBinder,
                          values,
@@ -185,7 +196,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
 
                 if (values.hasFill) {
                     draw(parameters.programs.getSymbolLayerPrograms().symbolIconSDF,
-                         SymbolSDFIconProgram::layoutUniformValues(false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Fill),
+                         SymbolSDFIconProgram::layoutUniformValues(false, false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Fill),
                          bucket.icon,
                          bucket.iconSizeBinder,
                          values,
@@ -197,7 +208,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
                 }
             } else {
                 draw(parameters.programs.getSymbolLayerPrograms().symbolIcon,
-                     SymbolIconProgram::layoutUniformValues(false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange),
+                     SymbolIconProgram::layoutUniformValues(false, false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange),
                      bucket.icon,
                      bucket.iconSizeBinder,
                      values,
@@ -215,6 +226,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
 
             auto values = textPropertyValues(evaluated_, layout);
             const auto& paintPropertyValues = textPaintProperties(evaluated_);
+            bool hasVariablePacement = false;
 
             const bool alongLine = layout.get<SymbolPlacement>() != SymbolPlacementType::Point &&
                 layout.get<TextRotationAlignment>() == AlignmentType::Map;
@@ -229,13 +241,79 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
                                     parameters.state);
 
                 parameters.context.updateVertexBuffer(*bucket.text.dynamicVertexBuffer, std::move(bucket.text.dynamicVertices));
+            } else if (!layout.get<TextVariableAnchor>().empty()) {
+                bucket.text.dynamicVertices.clear();
+
+                const auto partiallyEvaluatedSize = bucket.textSizeBinder->evaluateForZoom(parameters.state.getZoom());
+                const float tileScale = std::pow(2, parameters.state.getZoom() - tile.tile.id.overscaledZ);
+                const bool rotateWithMap = layout.get<TextRotationAlignment>() == AlignmentType::Map;
+                const bool pitchWithMap = layout.get<TextPitchAlignment>() == AlignmentType::Map;
+                const float pixelsToTileUnits = tile.id.pixelsToTileUnits(1.0, parameters.state.getZoom());
+                const auto labelPlaneMatrix = getLabelPlaneMatrix(tile.matrix, pitchWithMap, rotateWithMap, parameters.state, pixelsToTileUnits);
+
+                for (const PlacedSymbol& symbol : bucket.text.placedSymbols) {
+                    optional<VariableOffset> variableOffset;
+                    if (!symbol.hidden && symbol.crossTileID != 0u) {
+                        auto it = parameters.variableOffsets.get().find(symbol.crossTileID);
+                        if (it != parameters.variableOffsets.get().end()) {
+                            variableOffset = it->second;
+                            hasVariablePacement |= true;
+                        }
+                    }
+
+                    if (!variableOffset) {
+                        // These symbols are from a justification that is not being used, or a label that wasn't placed
+                        // so we don't need to do the extra math to figure out what incremental shift to apply.
+                        hideGlyphs(symbol.glyphOffsets.size(), bucket.text.dynamicVertices);
+                    } else {
+                        const Point<float> tileAnchor = symbol.anchorPoint;
+                        const auto projectedAnchor = project(tileAnchor, pitchWithMap ? tile.matrix : labelPlaneMatrix);
+                        const float perspectiveRatio = 0.5f + 0.5f * (parameters.state.getCameraToCenterDistance() / projectedAnchor.second);
+                        float renderTextSize = evaluateSizeForFeature(partiallyEvaluatedSize, symbol) * perspectiveRatio / util::ONE_EM;
+                        if (pitchWithMap) {
+                            // Go from size in pixels to equivalent size in tile units
+                            renderTextSize *= bucket.tilePixelRatio / tileScale;
+                        }
+
+                        auto shift = calculateVariableRenderShift(
+                                (*variableOffset).anchor,
+                                (*variableOffset).width,
+                                (*variableOffset).height,
+                                (*variableOffset).radialOffset,
+                                (*variableOffset).textBoxScale,
+                                renderTextSize);
+
+                        // Usual case is that we take the projected anchor and add the pixel-based shift
+                        // calculated above. In the (somewhat weird) case of pitch-aligned text, we add an equivalent
+                        // tile-unit based shift to the anchor before projecting to the label plane.
+                        Point<float> shiftedAnchor;
+                        if (pitchWithMap) {
+                            shiftedAnchor = project(Point<float>(tileAnchor.x + shift.x, tileAnchor.y + shift.y),
+                                                    labelPlaneMatrix).first;
+                        } else {
+                            if (rotateWithMap) {
+                                auto rotated = util::rotate(shift, -parameters.state.getPitch());
+                                shiftedAnchor = Point<float>(projectedAnchor.first.x + rotated.x,
+                                                             projectedAnchor.first.y + rotated.y);
+                            } else {
+                                 shiftedAnchor = Point<float>(projectedAnchor.first.x + shift.x,
+                                                              projectedAnchor.first.y + shift.y);
+                            }
+                        }
+
+                        for (std::size_t i = 0; i < symbol.glyphOffsets.size(); i++) {
+                            addDynamicAttributes(shiftedAnchor, 0, bucket.text.dynamicVertices);
+                        }
+                    }
+                }
+                parameters.context.updateVertexBuffer(*bucket.text.dynamicVertexBuffer, std::move(bucket.text.dynamicVertices));
             }
 
             const Size texsize = geometryTile.glyphAtlasTexture->size;
 
             if (values.hasHalo) {
                 draw(parameters.programs.getSymbolLayerPrograms().symbolGlyph,
-                     SymbolSDFTextProgram::layoutUniformValues(true, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Halo),
+                     SymbolSDFTextProgram::layoutUniformValues(true, hasVariablePacement, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Halo),
                      bucket.text,
                      bucket.textSizeBinder,
                      values,
@@ -248,7 +326,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
 
             if (values.hasFill) {
                 draw(parameters.programs.getSymbolLayerPrograms().symbolGlyph,
-                     SymbolSDFTextProgram::layoutUniformValues(true, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Fill),
+                     SymbolSDFTextProgram::layoutUniformValues(true, hasVariablePacement, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Fill),
                      bucket.text,
                      bucket.textSizeBinder,
                      values,
@@ -280,9 +358,9 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
                 parameters.colorModeForRenderPass(),
                 gfx::CullFaceMode::disabled(),
                 CollisionBoxProgram::LayoutUniformValues {
-                    uniforms::u_matrix::Value( tile.matrix ),
-                    uniforms::u_extrude_scale::Value( extrudeScale ),
-                    uniforms::u_camera_to_center_distance::Value( parameters.state.getCameraToCenterDistance() )
+                    uniforms::matrix::Value( tile.matrix ),
+                    uniforms::extrude_scale::Value( extrudeScale ),
+                    uniforms::camera_to_center_distance::Value( parameters.state.getCameraToCenterDistance() )
                 },
                 *bucket.collisionBox.vertexBuffer,
                 *bucket.collisionBox.dynamicVertexBuffer,
@@ -316,10 +394,10 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
                 parameters.colorModeForRenderPass(),
                 gfx::CullFaceMode::disabled(),
                 CollisionCircleProgram::LayoutUniformValues {
-                    uniforms::u_matrix::Value( tile.matrix ),
-                    uniforms::u_extrude_scale::Value( extrudeScale ),
-                    uniforms::u_overscale_factor::Value( float(tile.tile.id.overscaleFactor()) ),
-                    uniforms::u_camera_to_center_distance::Value( parameters.state.getCameraToCenterDistance() )
+                    uniforms::matrix::Value( tile.matrix ),
+                    uniforms::extrude_scale::Value( extrudeScale ),
+                    uniforms::overscale_factor::Value( float(tile.tile.id.overscaleFactor()) ),
+                    uniforms::camera_to_center_distance::Value( parameters.state.getCameraToCenterDistance() )
                 },
                 *bucket.collisionCircle.vertexBuffer,
                 *bucket.collisionCircle.dynamicVertexBuffer,
@@ -392,12 +470,9 @@ style::SymbolPropertyValues RenderSymbolLayer::textPropertyValues(const style::S
     };
 }
 
-RenderLayer::RenderTiles RenderSymbolLayer::filterRenderTiles(RenderTiles tiles) const {
+void RenderSymbolLayer::setRenderTiles(RenderTiles tiles, const TransformState& state) {
     auto filterFn = [](auto& tile){ return !tile.tile.isRenderable(); };
-    return RenderLayer::filterRenderTiles(std::move(tiles), filterFn);
-}
-
-void RenderSymbolLayer::sortRenderTiles(const TransformState& state) {
+    renderTiles = RenderLayer::filterRenderTiles(std::move(tiles), filterFn);
     // Sort symbol tiles in opposite y position, so tiles with overlapping symbols are drawn
     // on top of each other, with lower symbols being drawn on top of higher symbols.
     std::sort(renderTiles.begin(), renderTiles.end(), [&state](const auto& a, const auto& b) {
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.hpp b/src/mbgl/renderer/layers/render_symbol_layer.hpp
index e44ad398f4..4de5c8538a 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.hpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.hpp
@@ -57,7 +57,7 @@ class BucketParameters;
 class SymbolLayout;
 class GeometryTileLayer;
 
-class RenderSymbolLayer: public RenderLayer, public RenderLayerSymbolInterface {
+class RenderSymbolLayer final: public RenderLayer, public RenderLayerSymbolInterface {
 public:
     RenderSymbolLayer(Immutable<style::SymbolLayer::Impl>);
     ~RenderSymbolLayer() final = default;
@@ -67,6 +67,7 @@ public:
     bool hasTransition() const override;
     bool hasCrossfade() const override;
     void render(PaintParameters&, RenderSource*) override;
+    void setRenderTiles(RenderTiles, const TransformState&) override;
 
     static style::IconPaintProperties::PossiblyEvaluated iconPaintProperties(const style::SymbolPaintProperties::PossiblyEvaluated&);
     static style::TextPaintProperties::PossiblyEvaluated textPaintProperties(const style::SymbolPaintProperties::PossiblyEvaluated&);
@@ -91,8 +92,6 @@ protected:
                                                           const style::SymbolLayoutProperties::PossiblyEvaluated&);
     static style::SymbolPropertyValues textPropertyValues(const style::SymbolPaintProperties::PossiblyEvaluated&,
                                                           const style::SymbolLayoutProperties::PossiblyEvaluated&);
-    RenderTiles filterRenderTiles(RenderTiles) const final;
-    void sortRenderTiles(const TransformState&) final;
     void updateBucketPaintProperties(Bucket*) const final;
 };