[core] Implement data-driven styling for {text,icon}-{color,opacity,halo-color,halo-blur,halo-width} (#7939)

* Add symbol dds attributes and adapt style code generation

* Update to mapbox-gl-js/master

* Refactor SymbolFeature as a subclass of GeometryTileFeature

Prepares for enabling DDS on symbol paint properties by allowing the
SymbolFeatures, which we keep around after constructing SymbolLayout,
to be used in evaluating data-driven paint properties later in the
layout process.

* Draft approach for splitting icon/text paint properties

The `Program` types are set up to bind GL attributes to each of the
data-driven paint properties specified in the `PaintProperties` type
provided.  Since `SymbolPaintProperties` specifies both `Text*` and
`Icon*` properties, the symbolIcon, symbolIconSDF, and symbolGlyph
programs each attempt to bind roughly double the number of attributes
that they actually need.

This change addresses this by:
- Adding the more specific `IconPaintProperties` and `TextPaintProperties` types, which are subsets of the full `SymbolPaintProperties`.
- The symbol layer continues to use its `SymbolPaintProperties paint` member to track layer property state, but it provides helpers that construct objects of each the specific `{Icon,Text}PaintProperties::Evaluated` type, for use by the painter.
- The three symbol programs instantiate `Program<>` using the appropriate `{Icon,Text}PaintProperties` type.

* check in generated style code

* Populate paint buffers for symbol DDS properties

* Address first round of review comments

* Refactor VectorTile{Layer,Feature} to explicitly share data

* Update submodule

src/mbgl/programs/symbol_program.cpp

@@ -2,6 +2,7 @@
 #include <mbgl/renderer/render_tile.hpp>
 #include <mbgl/map/transform_state.hpp>
 #include <mbgl/style/layers/symbol_layer_impl.hpp>
+#include <mbgl/util/enum.hpp>
 
 namespace mbgl {
 
@@ -19,6 +20,7 @@ Values makeValues(const style::SymbolPropertyValues& values,
     std::array<float, 2> extrudeScale;
 
     const float scale = values.paintSize / values.sdfScale;
+    
     if (values.pitchAlignment == AlignmentType::Map) {
         extrudeScale.fill(tile.id.pixelsToTileUnits(1, state.getZoom()) * scale);
     } else {
@@ -27,7 +29,7 @@ Values makeValues(const style::SymbolPropertyValues& values,
             pixelsToGLUnits[1] * scale * state.getCameraToCenterDistance()
         }};
     }
-
+    
     // adjust min/max zooms for variable font sies
     float zoomAdjust = std::log(values.paintSize / values.layoutSize) / std::log(2);
 
@@ -35,7 +37,6 @@ Values makeValues(const style::SymbolPropertyValues& values,
         uniforms::u_matrix::Value{ tile.translatedMatrix(values.translate,
                                    values.translateAnchor,
                                    state) },
-        uniforms::u_opacity::Value{ values.opacity },
         uniforms::u_extrude_scale::Value{ extrudeScale },
         uniforms::u_texsize::Value{ std::array<float, 2> {{ float(texsize.width) / 4, float(texsize.height) / 4 }} },
         uniforms::u_zoom::Value{ float((state.getZoom() - zoomAdjust) * 10) },
@@ -62,84 +63,37 @@ SymbolIconProgram::uniformValues(const style::SymbolPropertyValues& values,
     );
 }
 
-static SymbolSDFProgram::UniformValues makeSDFValues(const style::SymbolPropertyValues& values,
-                                               const Size& texsize,
-                                               const std::array<float, 2>& pixelsToGLUnits,
-                                               const RenderTile& tile,
-                                               const TransformState& state,
-                                               float pixelRatio,
-                                               Color color,
-                                               float buffer,
-                                               float gammaAdjust)
-{
-    // The default gamma value has to be adjust for the current pixelratio so that we're not
-    // drawing blurry font on retina screens.
-    const float gammaBase = 0.105 * values.sdfScale / values.paintSize / pixelRatio;
-    const float gammaScale = (values.pitchAlignment == AlignmentType::Map
-        ? 1.0 / std::cos(state.getPitch())
-        : 1.0) / state.getCameraToCenterDistance();
-
-    return makeValues<SymbolSDFProgram::UniformValues>(
-        values,
-        texsize,
-        pixelsToGLUnits,
-        tile,
-        state,
-        uniforms::u_color::Value{ color },
-        uniforms::u_buffer::Value{ buffer },
-        uniforms::u_gamma::Value{ (gammaBase + gammaAdjust) * gammaScale },
-        uniforms::u_pitch::Value{ state.getPitch() },
-        uniforms::u_bearing::Value{ -1.0f * state.getAngle() },
-        uniforms::u_aspect_ratio::Value{ (state.getSize().width * 1.0f) / (state.getSize().height * 1.0f) },
-        uniforms::u_pitch_with_map::Value{ values.pitchAlignment == AlignmentType::Map }
-    );
-}
-
-SymbolSDFProgram::UniformValues
-SymbolSDFProgram::haloUniformValues(const style::SymbolPropertyValues& values,
+template <class PaintProperties>
+typename SymbolSDFProgram<PaintProperties>::UniformValues SymbolSDFProgram<PaintProperties>::uniformValues(const style::SymbolPropertyValues& values,
                               const Size& texsize,
                               const std::array<float, 2>& pixelsToGLUnits,
                               const RenderTile& tile,
                               const TransformState& state,
-                              float pixelRatio)
+                              const SymbolSDFPart part)
 {
     const float scale = values.paintSize / values.sdfScale;
-    const float sdfPx = 8.0f;
-    const float blurOffset = 1.19f;
-    const float haloOffset = 6.0f;
-
-    return makeSDFValues(
+    
+    const float gammaScale = scale * (values.pitchAlignment == AlignmentType::Map
+                              ? std::cos(state.getPitch())
+                              : 1.0) * state.getCameraToCenterDistance();
+    
+    return makeValues<SymbolSDFProgram<PaintProperties>::UniformValues>(
         values,
         texsize,
         pixelsToGLUnits,
         tile,
         state,
-        pixelRatio,
-        values.haloColor,
-        (haloOffset - values.haloWidth / scale) / sdfPx,
-        values.haloBlur * blurOffset / scale / sdfPx
+        uniforms::u_font_scale::Value{ scale },
+        uniforms::u_gamma_scale::Value{ gammaScale },
+        uniforms::u_pitch::Value{ state.getPitch() },
+        uniforms::u_bearing::Value{ -1.0f * state.getAngle() },
+        uniforms::u_aspect_ratio::Value{ (state.getSize().width * 1.0f) / (state.getSize().height * 1.0f) },
+        uniforms::u_pitch_with_map::Value{ values.pitchAlignment == AlignmentType::Map },
+        uniforms::u_is_halo::Value{ part == SymbolSDFPart::Halo }
     );
 }
 
-SymbolSDFProgram::UniformValues
-SymbolSDFProgram::foregroundUniformValues(const style::SymbolPropertyValues& values,
-                                    const Size& texsize,
-                                    const std::array<float, 2>& pixelsToGLUnits,
-                                    const RenderTile& tile,
-                                    const TransformState& state,
-                                    float pixelRatio)
-{
-    return makeSDFValues(
-        values,
-        texsize,
-        pixelsToGLUnits,
-        tile,
-        state,
-        pixelRatio,
-        values.color,
-        (256.0f - 64.0f) / 256.0f,
-        0
-    );
-}
+template class SymbolSDFProgram<style::IconPaintProperties>;
+template class SymbolSDFProgram<style::TextPaintProperties>;
 
 } // namespace mbgl