Tons o' code generationupstream/generate-tons

22 files changed, 241 insertions, 369 deletions

diff --git a/src/mbgl/renderer/buckets/circle_bucket.cpp b/src/mbgl/renderer/buckets/circle_bucket.cpp
index d07c1f8dbe..49488ab976 100644
--- a/src/mbgl/renderer/buckets/circle_bucket.cpp
+++ b/src/mbgl/renderer/buckets/circle_bucket.cpp
@@ -15,11 +15,8 @@ CircleBucket::CircleBucket(const BucketParameters& parameters, const std::vector
       mode(parameters.mode) {
     for (const auto& layer : layers) {
         paintPropertyBinders.emplace(
-            std::piecewise_construct,
-            std::forward_as_tuple(layer->getID()),
-            std::forward_as_tuple(
-                layer->as<RenderCircleLayer>()->evaluated,
-                parameters.tileID.overscaledZ));
+            layer->getID(),
+            layer->as<RenderCircleLayer>()->evaluated.createBinders(parameters.tileID.overscaledZ));
     }
 }
 
@@ -92,13 +89,14 @@ void CircleBucket::addFeature(const GeometryTileFeature& feature,
 }
 
 template <class Property>
-static float get(const RenderCircleLayer& layer, const std::map<std::string, CircleProgram::PaintPropertyBinders>& paintPropertyBinders) {
-    auto it = paintPropertyBinders.find(layer.getID());
-    if (it == paintPropertyBinders.end() || !it->second.statistics<Property>().max()) {
-        return layer.evaluated.get<Property>().constantOr(Property::defaultValue());
-    } else {
-        return *it->second.statistics<Property>().max();
-    }
+static float get(const RenderCircleLayer&, const std::map<std::string, CircleProgram::PaintPropertyBinders>&) {
+//    auto it = paintPropertyBinders.find(layer.getID());
+//    if (it == paintPropertyBinders.end() || !it->second.statistics<Property>().max()) {
+//        return layer.evaluated.get<Property>().constantOr(Property::defaultValue());
+//    } else {
+//        return *it->second.statistics<Property>().max();
+//    }
+    return 0;
 }
 
 float CircleBucket::getQueryRadius(const RenderLayer& layer) const {
@@ -110,7 +108,7 @@ float CircleBucket::getQueryRadius(const RenderLayer& layer) const {
 
     float radius = get<CircleRadius>(*circleLayer, paintPropertyBinders);
     float stroke = get<CircleStrokeWidth>(*circleLayer, paintPropertyBinders);
-    auto translate = circleLayer->evaluated.get<CircleTranslate>();
+    auto translate = circleLayer->evaluated.circleTranslate;
     return radius + stroke + util::length(translate[0], translate[1]);
 }
 
diff --git a/src/mbgl/renderer/buckets/fill_bucket.cpp b/src/mbgl/renderer/buckets/fill_bucket.cpp
index 14be98c3af..e9aa6dcb4d 100644
--- a/src/mbgl/renderer/buckets/fill_bucket.cpp
+++ b/src/mbgl/renderer/buckets/fill_bucket.cpp
@@ -31,11 +31,8 @@ FillBucket::FillBucket(const BucketParameters& parameters, const std::vector<con
     : Bucket(LayerType::Fill) {
     for (const auto& layer : layers) {
         paintPropertyBinders.emplace(
-            std::piecewise_construct,
-            std::forward_as_tuple(layer->getID()),
-            std::forward_as_tuple(
-                layer->as<RenderFillLayer>()->evaluated,
-                parameters.tileID.overscaledZ));
+            layer->getID(),
+            layer->as<RenderFillLayer>()->evaluated.createBinders(parameters.tileID.overscaledZ));
     }
 }
 
@@ -130,7 +127,7 @@ float FillBucket::getQueryRadius(const RenderLayer& layer) const {
         return 0;
     }
 
-    const std::array<float, 2>& translate = layer.as<RenderFillLayer>()->evaluated.get<FillTranslate>();
+    const std::array<float, 2>& translate = layer.as<RenderFillLayer>()->evaluated.fillTranslate;
     return util::length(translate[0], translate[1]);
 
 }
diff --git a/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp b/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp
index c6dba38db1..61ef692e45 100644
--- a/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp
+++ b/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp
@@ -37,11 +37,9 @@ struct GeometryTooLongException : std::exception {};
 FillExtrusionBucket::FillExtrusionBucket(const BucketParameters& parameters, const std::vector<const RenderLayer*>& layers)
     : Bucket(LayerType::FillExtrusion) {
     for (const auto& layer : layers) {
-        paintPropertyBinders.emplace(std::piecewise_construct,
-                                     std::forward_as_tuple(layer->getID()),
-                                     std::forward_as_tuple(
-                                                           layer->as<RenderFillExtrusionLayer>()->evaluated,
-                                                           parameters.tileID.overscaledZ));
+        paintPropertyBinders.emplace(
+            layer->getID(),
+            layer->as<RenderFillExtrusionLayer>()->evaluated.createBinders(parameters.tileID.overscaledZ));
     }
 }
 
@@ -167,7 +165,7 @@ float FillExtrusionBucket::getQueryRadius(const RenderLayer& layer) const {
         return 0;
     }
 
-    const std::array<float, 2>& translate = layer.as<RenderFillExtrusionLayer>()->evaluated.get<FillExtrusionTranslate>();
+    const std::array<float, 2>& translate = layer.as<RenderFillExtrusionLayer>()->evaluated.fillExtrusionTranslate;
     return util::length(translate[0], translate[1]);
 }
 
diff --git a/src/mbgl/renderer/buckets/heatmap_bucket.cpp b/src/mbgl/renderer/buckets/heatmap_bucket.cpp
index eff0c60280..15c946674c 100644
--- a/src/mbgl/renderer/buckets/heatmap_bucket.cpp
+++ b/src/mbgl/renderer/buckets/heatmap_bucket.cpp
@@ -15,11 +15,8 @@ HeatmapBucket::HeatmapBucket(const BucketParameters& parameters, const std::vect
       mode(parameters.mode) {
     for (const auto& layer : layers) {
         paintPropertyBinders.emplace(
-            std::piecewise_construct,
-            std::forward_as_tuple(layer->getID()),
-            std::forward_as_tuple(
-                layer->as<RenderHeatmapLayer>()->evaluated,
-                parameters.tileID.overscaledZ));
+            layer->getID(),
+            layer->as<RenderHeatmapLayer>()->evaluated.createBinders(parameters.tileID.overscaledZ));
     }
 }
 
diff --git a/src/mbgl/renderer/buckets/line_bucket.cpp b/src/mbgl/renderer/buckets/line_bucket.cpp
index a10551a7d2..9ef04e694f 100644
--- a/src/mbgl/renderer/buckets/line_bucket.cpp
+++ b/src/mbgl/renderer/buckets/line_bucket.cpp
@@ -20,11 +20,8 @@ LineBucket::LineBucket(const BucketParameters& parameters,
       zoom(parameters.tileID.overscaledZ) {
     for (const auto& layer : layers) {
         paintPropertyBinders.emplace(
-            std::piecewise_construct,
-            std::forward_as_tuple(layer->getID()),
-            std::forward_as_tuple(
-                layer->as<RenderLineLayer>()->evaluated,
-                parameters.tileID.overscaledZ));
+            layer->getID(),
+            layer->as<RenderLineLayer>()->evaluated.createBinders(parameters.tileID.overscaledZ));
     }
 }
 
@@ -89,15 +86,15 @@ void LineBucket::addGeometry(const GeometryCoordinates& coordinates, const Geome
         return;
     }
 
-    const LineJoinType joinType = layout.evaluate<LineJoin>(zoom, feature);
+    const LineJoinType joinType = layout.lineJoin.evaluate(feature, zoom, LineJoin::defaultValue());
 
-    const float miterLimit = joinType == LineJoinType::Bevel ? 1.05f : float(layout.get<LineMiterLimit>());
+    const float miterLimit = joinType == LineJoinType::Bevel ? 1.05f : float(layout.lineMiterLimit);
 
     const double sharpCornerOffset = SHARP_CORNER_OFFSET * (float(util::EXTENT) / (util::tileSize * overscaling));
 
     const GeometryCoordinate firstCoordinate = coordinates[first];
-    const LineCapType beginCap = layout.get<LineCap>();
-    const LineCapType endCap = type == FeatureType::Polygon ? LineCapType::Butt : LineCapType(layout.get<LineCap>());
+    const LineCapType beginCap = layout.lineCap;
+    const LineCapType endCap = type == FeatureType::Polygon ? LineCapType::Butt : LineCapType(layout.lineCap);
 
     double distance = 0;
     bool startOfLine = true;
@@ -203,7 +200,7 @@ void LineBucket::addGeometry(const GeometryCoordinates& coordinates, const Geome
 
         if (middleVertex) {
             if (currentJoin == LineJoinType::Round) {
-                if (miterLength < layout.get<LineRoundLimit>()) {
+                if (miterLength < layout.lineRoundLimit) {
                     currentJoin = LineJoinType::Miter;
                 } else if (miterLength <= 2) {
                     currentJoin = LineJoinType::FakeRound;
@@ -466,19 +463,36 @@ bool LineBucket::hasData() const {
     return !segments.empty();
 }
 
-template <class Property>
-static float get(const RenderLineLayer& layer, const std::map<std::string, LineProgram::PaintPropertyBinders>& paintPropertyBinders) {
+static float getLineWidth(const RenderLineLayer& layer, const std::map<std::string, LineProgram::PaintPropertyBinders>& paintPropertyBinders) {
     auto it = paintPropertyBinders.find(layer.getID());
-    if (it == paintPropertyBinders.end() || !it->second.statistics<Property>().max()) {
-        return layer.evaluated.get<Property>().constantOr(Property::defaultValue());
+    if (it == paintPropertyBinders.end() || !it->second.lineWidth->statistics.max()) {
+        return layer.evaluated.lineWidth.constantOr(LineWidth::defaultValue());
     } else {
-        return *it->second.statistics<Property>().max();
+        return *it->second.lineWidth->statistics.max();
+    }
+}
+
+static float getLineGapWidth(const RenderLineLayer& layer, const std::map<std::string, LineProgram::PaintPropertyBinders>& paintPropertyBinders) {
+    auto it = paintPropertyBinders.find(layer.getID());
+    if (it == paintPropertyBinders.end() || !it->second.lineGapWidth->statistics.max()) {
+        return layer.evaluated.lineGapWidth.constantOr(LineGapWidth::defaultValue());
+    } else {
+        return *it->second.lineGapWidth->statistics.max();
+    }
+}
+
+static float getLineOffset(const RenderLineLayer& layer, const std::map<std::string, LineProgram::PaintPropertyBinders>& paintPropertyBinders) {
+    auto it = paintPropertyBinders.find(layer.getID());
+    if (it == paintPropertyBinders.end() || !it->second.lineOffset->statistics.max()) {
+        return layer.evaluated.lineOffset.constantOr(LineOffset::defaultValue());
+    } else {
+        return *it->second.lineOffset->statistics.max();
     }
 }
 
 float LineBucket::getLineWidth(const RenderLineLayer& layer) const {
-    float lineWidth = get<LineWidth>(layer, paintPropertyBinders);
-    float gapWidth = get<LineGapWidth>(layer, paintPropertyBinders);
+    float lineWidth = ::mbgl::getLineWidth(layer, paintPropertyBinders);
+    float gapWidth = ::mbgl::getLineGapWidth(layer, paintPropertyBinders);
 
     if (gapWidth) {
         return gapWidth + 2 * lineWidth;
@@ -494,8 +508,8 @@ float LineBucket::getQueryRadius(const RenderLayer& layer) const {
 
     auto lineLayer = layer.as<RenderLineLayer>();
 
-    const std::array<float, 2>& translate = lineLayer->evaluated.get<LineTranslate>();
-    float offset = get<LineOffset>(*lineLayer, paintPropertyBinders);
+    const std::array<float, 2>& translate = lineLayer->evaluated.lineTranslate;
+    float offset = getLineOffset(*lineLayer, paintPropertyBinders);
     return getLineWidth(*lineLayer) / 2.0 + std::abs(offset) + util::length(translate[0], translate[1]);
 }
 
diff --git a/src/mbgl/renderer/buckets/symbol_bucket.cpp b/src/mbgl/renderer/buckets/symbol_bucket.cpp
index a3f652fc6e..add38b0052 100644
--- a/src/mbgl/renderer/buckets/symbol_bucket.cpp
+++ b/src/mbgl/renderer/buckets/symbol_bucket.cpp
@@ -32,12 +32,10 @@ SymbolBucket::SymbolBucket(style::SymbolLayoutProperties::PossiblyEvaluated layo
 
     for (const auto& pair : layerPaintProperties) {
         paintPropertyBinders.emplace(
-            std::piecewise_construct,
-            std::forward_as_tuple(pair.first),
-            std::forward_as_tuple(
-                std::piecewise_construct,
-                std::forward_as_tuple(pair.second.first, zoom),
-                std::forward_as_tuple(pair.second.second, zoom)));
+            pair.first,
+            std::make_pair(
+                pair.second.first.createBinders(zoom),
+                pair.second.second.createBinders(zoom)));
     }
 }
 
diff --git a/src/mbgl/renderer/layers/render_background_layer.cpp b/src/mbgl/renderer/layers/render_background_layer.cpp
index 2dc5fe7339..8d022ce8c9 100644
--- a/src/mbgl/renderer/layers/render_background_layer.cpp
+++ b/src/mbgl/renderer/layers/render_background_layer.cpp
@@ -35,7 +35,7 @@ void RenderBackgroundLayer::transition(const TransitionParameters &parameters) {
 void RenderBackgroundLayer::evaluate(const PropertyEvaluationParameters &parameters) {
     evaluated = unevaluated.evaluate(parameters);
 
-    passes = evaluated.get<style::BackgroundOpacity>() > 0 ? RenderPass::Translucent
+    passes = evaluated.backgroundOpacity > 0 ? RenderPass::Translucent
                                                            : RenderPass::None;
 }
 
@@ -47,19 +47,19 @@ void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) {
     // Note that for bottommost layers without a pattern, the background color is drawn with
     // glClear rather than this method.
 
-    const Properties<>::PossiblyEvaluated properties;
-    const BackgroundProgram::PaintPropertyBinders paintAttributeData(properties, 0);
+    static const NoProperties::PossiblyEvaluated properties;
+    static const NoProperties::Binders binders;
 
     auto draw = [&](auto& program, auto&& uniformValues) {
         const auto allUniformValues = program.computeAllUniformValues(
             std::move(uniformValues),
-            paintAttributeData,
+            binders,
             properties,
             parameters.state.getZoom()
         );
         const auto allAttributeBindings = program.computeAllAttributeBindings(
             parameters.staticData.tileVertexBuffer,
-            paintAttributeData,
+            binders,
             properties
         );
 
@@ -79,9 +79,9 @@ void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) {
         );
     };
 
-    if (!evaluated.get<BackgroundPattern>().to.empty()) {
-        optional<ImagePosition> imagePosA = parameters.imageManager.getPattern(evaluated.get<BackgroundPattern>().from);
-        optional<ImagePosition> imagePosB = parameters.imageManager.getPattern(evaluated.get<BackgroundPattern>().to);
+    if (!evaluated.backgroundPattern.to.empty()) {
+        optional<ImagePosition> imagePosA = parameters.imageManager.getPattern(evaluated.backgroundPattern.from);
+        optional<ImagePosition> imagePosB = parameters.imageManager.getPattern(evaluated.backgroundPattern.to);
 
         if (!imagePosA || !imagePosB)
             return;
@@ -93,11 +93,11 @@ void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) {
                 parameters.programs.backgroundPattern,
                 BackgroundPatternUniforms::values(
                     parameters.matrixForTile(tileID),
-                    evaluated.get<BackgroundOpacity>(),
+                    evaluated.backgroundOpacity,
                     parameters.imageManager.getPixelSize(),
                     *imagePosA,
                     *imagePosB,
-                    evaluated.get<BackgroundPattern>(),
+                    evaluated.backgroundPattern,
                     tileID,
                     parameters.state
                 )
@@ -109,8 +109,8 @@ void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) {
                 parameters.programs.background,
                 BackgroundProgram::UniformValues {
                     uniforms::u_matrix::Value{ parameters.matrixForTile(tileID) },
-                    uniforms::u_color::Value{ evaluated.get<BackgroundColor>() },
-                    uniforms::u_opacity::Value{ evaluated.get<BackgroundOpacity>() },
+                    uniforms::u_color::Value{ evaluated.backgroundColor },
+                    uniforms::u_opacity::Value{ evaluated.backgroundOpacity },
                 }
             );
         }
diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp
index ce63ada770..8f50c0a5be 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.cpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.cpp
@@ -34,12 +34,12 @@ void RenderCircleLayer::transition(const TransitionParameters& parameters) {
 void RenderCircleLayer::evaluate(const PropertyEvaluationParameters& parameters) {
     evaluated = unevaluated.evaluate(parameters);
 
-    passes = ((evaluated.get<style::CircleRadius>().constantOr(1) > 0 ||
-               evaluated.get<style::CircleStrokeWidth>().constantOr(1) > 0)
-              && (evaluated.get<style::CircleColor>().constantOr(Color::black()).a > 0 ||
-                  evaluated.get<style::CircleStrokeColor>().constantOr(Color::black()).a > 0)
-              && (evaluated.get<style::CircleOpacity>().constantOr(1) > 0 ||
-                  evaluated.get<style::CircleStrokeOpacity>().constantOr(1) > 0))
+    passes = ((evaluated.circleRadius.constantOr(1) > 0 ||
+               evaluated.circleStrokeWidth.constantOr(1) > 0)
+              && (evaluated.circleColor.constantOr(Color::black()).a > 0 ||
+                  evaluated.circleStrokeColor.constantOr(Color::black()).a > 0)
+              && (evaluated.circleOpacity.constantOr(1) > 0 ||
+                  evaluated.circleStrokeOpacity.constantOr(1) > 0))
              ? RenderPass::Translucent : RenderPass::None;
 }
 
@@ -52,8 +52,8 @@ void RenderCircleLayer::render(PaintParameters& parameters, RenderSource*) {
         return;
     }
 
-    const bool scaleWithMap = evaluated.get<CirclePitchScale>() == CirclePitchScaleType::Map;
-    const bool pitchWithMap = evaluated.get<CirclePitchAlignment>() == AlignmentType::Map;
+    const bool scaleWithMap = evaluated.circlePitchScale == CirclePitchScaleType::Map;
+    const bool pitchWithMap = evaluated.circlePitchAlignment == AlignmentType::Map;
 
     for (const RenderTile& tile : renderTiles) {
         auto bucket_ = tile.tile.getBucket<CircleBucket>(*baseImpl);
@@ -69,8 +69,8 @@ void RenderCircleLayer::render(PaintParameters& parameters, RenderSource*) {
         const auto allUniformValues = programInstance.computeAllUniformValues(
             CircleProgram::UniformValues {
                 uniforms::u_matrix::Value{
-                    tile.translatedMatrix(evaluated.get<CircleTranslate>(),
-                                          evaluated.get<CircleTranslateAnchor>(),
+                    tile.translatedMatrix(evaluated.circleTranslate,
+                                          evaluated.circleTranslateAnchor,
                                           parameters.state)
                 },
                 uniforms::u_scale_with_map::Value{ scaleWithMap },
@@ -139,21 +139,21 @@ bool RenderCircleLayer::queryIntersectsFeature(
     // Translate query geometry
     const GeometryCoordinates& translatedQueryGeometry = FeatureIndex::translateQueryGeometry(
             queryGeometry,
-            evaluated.get<style::CircleTranslate>(),
-            evaluated.get<style::CircleTranslateAnchor>(),
+            evaluated.circleTranslate,
+            evaluated.circleTranslateAnchor,
             transformState.getAngle(),
             pixelsToTileUnits).value_or(queryGeometry);
 
     // Evaluate functions
-    auto radius = evaluated.evaluate<style::CircleRadius>(zoom, feature);
-    auto stroke = evaluated.evaluate<style::CircleStrokeWidth>(zoom, feature);
+    auto radius = evaluated.circleRadius.evaluate(feature, zoom, CircleRadius::defaultValue());
+    auto stroke = evaluated.circleStrokeWidth.evaluate(feature, zoom, CircleStrokeWidth::defaultValue());
     auto size = radius + stroke;
 
     // For pitch-alignment: map, compare feature geometry to query geometry in the plane of the tile
     // Otherwise, compare geometry in the plane of the viewport
     // A circle with fixed scaling relative to the viewport gets larger in tile space as it moves into the distance
     // A circle with fixed scaling relative to the map gets smaller in viewport space as it moves into the distance
-    bool alignWithMap = evaluated.evaluate<style::CirclePitchAlignment>(zoom, feature) == AlignmentType::Map;
+    bool alignWithMap = evaluated.circlePitchAlignment == AlignmentType::Map;
     const GeometryCoordinates& transformedQueryGeometry = alignWithMap ?
         translatedQueryGeometry :
         projectQueryGeometry(translatedQueryGeometry, posMatrix, transformState.getSize());
@@ -167,8 +167,8 @@ bool RenderCircleLayer::queryIntersectsFeature(
             float adjustedSize = transformedSize;
             vec4 center = {{ static_cast<double>(point.x), static_cast<double>(point.y), 0, 1 }};
             matrix::transformMat4(center, center, posMatrix);
-            auto pitchScale = evaluated.evaluate<style::CirclePitchScale>(zoom, feature);
-            auto pitchAlignment = evaluated.evaluate<style::CirclePitchAlignment>(zoom, feature);
+            auto pitchScale = evaluated.circlePitchScale;
+            auto pitchAlignment = evaluated.circlePitchAlignment;
             if (pitchScale == CirclePitchScaleType::Viewport && pitchAlignment == AlignmentType::Map) {
                 adjustedSize *= center[3] / transformState.getCameraToCenterDistance();
             } else if (pitchScale == CirclePitchScaleType::Map && pitchAlignment == AlignmentType::Viewport) {
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
index 2f720284fc..8d9bae64a1 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
@@ -37,7 +37,7 @@ void RenderFillExtrusionLayer::transition(const TransitionParameters& parameters
 void RenderFillExtrusionLayer::evaluate(const PropertyEvaluationParameters& parameters) {
     evaluated = unevaluated.evaluate(parameters);
 
-    passes = (evaluated.get<style::FillExtrusionOpacity>() > 0)
+    passes = (evaluated.fillExtrusionOpacity > 0)
                  ? (RenderPass::Translucent | RenderPass::Pass3D)
                  : RenderPass::None;
 }
@@ -98,7 +98,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
                 getID());
         };
 
-        if (evaluated.get<FillExtrusionPattern>().from.empty()) {
+        if (evaluated.fillExtrusionPattern.from.empty()) {
             for (const RenderTile& tile : renderTiles) {
                 auto bucket_ = tile.tile.getBucket<FillExtrusionBucket>(*baseImpl);
                 if (!bucket_) {
@@ -110,8 +110,8 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
                     parameters.programs.fillExtrusion.get(evaluated),
                     bucket,
                     FillExtrusionUniforms::values(
-                        tile.translatedClipMatrix(evaluated.get<FillExtrusionTranslate>(),
-                                                  evaluated.get<FillExtrusionTranslateAnchor>(),
+                        tile.translatedClipMatrix(evaluated.fillExtrusionTranslate,
+                                                  evaluated.fillExtrusionTranslateAnchor,
                                                   parameters.state),
                         parameters.state,
                         parameters.evaluatedLight
@@ -120,9 +120,9 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
             }
         } else {
             optional<ImagePosition> imagePosA =
-                parameters.imageManager.getPattern(evaluated.get<FillExtrusionPattern>().from);
+                parameters.imageManager.getPattern(evaluated.fillExtrusionPattern.from);
             optional<ImagePosition> imagePosB =
-                parameters.imageManager.getPattern(evaluated.get<FillExtrusionPattern>().to);
+                parameters.imageManager.getPattern(evaluated.fillExtrusionPattern.to);
 
             if (!imagePosA || !imagePosB) {
                 return;
@@ -141,11 +141,11 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
                     parameters.programs.fillExtrusionPattern.get(evaluated),
                     bucket,
                     FillExtrusionPatternUniforms::values(
-                        tile.translatedClipMatrix(evaluated.get<FillExtrusionTranslate>(),
-                                                  evaluated.get<FillExtrusionTranslateAnchor>(),
+                        tile.translatedClipMatrix(evaluated.fillExtrusionTranslate,
+                                                  evaluated.fillExtrusionTranslateAnchor,
                                                   parameters.state),
                         parameters.imageManager.getPixelSize(), *imagePosA, *imagePosB,
-                        evaluated.get<FillExtrusionPattern>(), tile.id, parameters.state,
+                        evaluated.fillExtrusionPattern, tile.id, parameters.state,
                         -std::pow(2, tile.id.canonical.z) / util::tileSize / 8.0f,
                         parameters.evaluatedLight
                     )
@@ -161,24 +161,24 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
         mat4 viewportMat;
         matrix::ortho(viewportMat, 0, size.width, size.height, 0, 0, 1);
 
-        const Properties<>::PossiblyEvaluated properties;
-        const ExtrusionTextureProgram::PaintPropertyBinders paintAttributeData{ properties, 0 };
-        
+        static const NoProperties::PossiblyEvaluated properties;
+        static const NoProperties::Binders binders;
+
         auto& programInstance = parameters.programs.extrusionTexture;
 
         const auto allUniformValues = programInstance.computeAllUniformValues(
             ExtrusionTextureProgram::UniformValues{
                 uniforms::u_matrix::Value{ viewportMat }, uniforms::u_world::Value{ size },
                 uniforms::u_image::Value{ 0 },
-                uniforms::u_opacity::Value{ evaluated.get<FillExtrusionOpacity>() }
+                uniforms::u_opacity::Value{ evaluated.fillExtrusionOpacity }
             },
-            paintAttributeData,
+            binders,
             properties,
             parameters.state.getZoom()
         );
         const auto allAttributeBindings = programInstance.computeAllAttributeBindings(
             parameters.staticData.extrusionTextureVertexBuffer,
-            paintAttributeData,
+            binders,
             properties
         );
 
@@ -208,8 +208,8 @@ bool RenderFillExtrusionLayer::queryIntersectsFeature(
 
     auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry(
             queryGeometry,
-            evaluated.get<style::FillExtrusionTranslate>(),
-            evaluated.get<style::FillExtrusionTranslateAnchor>(),
+            evaluated.fillExtrusionTranslate,
+            evaluated.fillExtrusionTranslateAnchor,
             transformState.getAngle(),
             pixelsToTileUnits);
 
diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp
index f03eb66c88..928fdc44bc 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.cpp
@@ -35,19 +35,19 @@ void RenderFillLayer::transition(const TransitionParameters& parameters) {
 void RenderFillLayer::evaluate(const PropertyEvaluationParameters& parameters) {
     evaluated = unevaluated.evaluate(parameters);
 
-    if (unevaluated.get<style::FillOutlineColor>().isUndefined()) {
-        evaluated.get<style::FillOutlineColor>() = evaluated.get<style::FillColor>();
+    if (unevaluated.fillOutlineColor.isUndefined()) {
+        evaluated.fillOutlineColor = evaluated.fillColor;
     }
 
     passes = RenderPass::None;
 
-    if (evaluated.get<style::FillAntialias>()) {
+    if (evaluated.fillAntialias) {
         passes |= RenderPass::Translucent;
     }
 
-    if (!unevaluated.get<style::FillPattern>().isUndefined()
-        || evaluated.get<style::FillColor>().constantOr(Color()).a < 1.0f
-        || evaluated.get<style::FillOpacity>().constantOr(0) < 1.0f) {
+    if (!unevaluated.fillPattern.isUndefined()
+        || evaluated.fillColor.constantOr(Color()).a < 1.0f
+        || evaluated.fillOpacity.constantOr(0) < 1.0f) {
         passes |= RenderPass::Translucent;
     } else {
         passes |= RenderPass::Opaque;
@@ -59,7 +59,7 @@ bool RenderFillLayer::hasTransition() const {
 }
 
 void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
-    if (evaluated.get<FillPattern>().from.empty()) {
+    if (evaluated.fillPattern.from.empty()) {
         for (const RenderTile& tile : renderTiles) {
             auto bucket_ = tile.tile.getBucket<FillBucket>(*baseImpl);
             if (!bucket_) {
@@ -79,8 +79,8 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
                 const auto allUniformValues = programInstance.computeAllUniformValues(
                     FillProgram::UniformValues {
                         uniforms::u_matrix::Value{
-                            tile.translatedMatrix(evaluated.get<FillTranslate>(),
-                                                  evaluated.get<FillTranslateAnchor>(),
+                            tile.translatedMatrix(evaluated.fillTranslate,
+                                                  evaluated.fillTranslateAnchor,
                                                   parameters.state)
                         },
                         uniforms::u_world::Value{ parameters.context.viewport.getCurrentValue().size },
@@ -113,8 +113,8 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
 
             // Only draw the fill when it's opaque and we're drawing opaque fragments,
             // or when it's translucent and we're drawing translucent fragments.
-            if ((evaluated.get<FillColor>().constantOr(Color()).a >= 1.0f
-              && evaluated.get<FillOpacity>().constantOr(0) >= 1.0f) == (parameters.pass == RenderPass::Opaque)) {
+            if ((evaluated.fillColor.constantOr(Color()).a >= 1.0f
+              && evaluated.fillOpacity.constantOr(0) >= 1.0f) == (parameters.pass == RenderPass::Opaque)) {
                 draw(parameters.programs.fill,
                      gl::Triangles(),
                      parameters.depthModeForSublayer(1, parameters.pass == RenderPass::Opaque
@@ -124,11 +124,11 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
                      bucket.triangleSegments);
             }
 
-            if (evaluated.get<FillAntialias>() && parameters.pass == RenderPass::Translucent) {
+            if (evaluated.fillAntialias && parameters.pass == RenderPass::Translucent) {
                 draw(parameters.programs.fillOutline,
                      gl::Lines{ 2.0f },
                      parameters.depthModeForSublayer(
-                         unevaluated.get<FillOutlineColor>().isUndefined() ? 2 : 0,
+                         unevaluated.fillOutlineColor.isUndefined() ? 2 : 0,
                          gl::DepthMode::ReadOnly),
                      *bucket.lineIndexBuffer,
                      bucket.lineSegments);
@@ -139,8 +139,8 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
             return;
         }
 
-        optional<ImagePosition> imagePosA = parameters.imageManager.getPattern(evaluated.get<FillPattern>().from);
-        optional<ImagePosition> imagePosB = parameters.imageManager.getPattern(evaluated.get<FillPattern>().to);
+        optional<ImagePosition> imagePosA = parameters.imageManager.getPattern(evaluated.fillPattern.from);
+        optional<ImagePosition> imagePosB = parameters.imageManager.getPattern(evaluated.fillPattern.to);
 
         if (!imagePosA || !imagePosB) {
             return;
@@ -166,14 +166,14 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
 
                 const auto allUniformValues = programInstance.computeAllUniformValues(
                     FillPatternUniforms::values(
-                        tile.translatedMatrix(evaluated.get<FillTranslate>(),
-                                              evaluated.get<FillTranslateAnchor>(),
+                        tile.translatedMatrix(evaluated.fillTranslate,
+                                              evaluated.fillTranslateAnchor,
                                               parameters.state),
                         parameters.context.viewport.getCurrentValue().size,
                         parameters.imageManager.getPixelSize(),
                         *imagePosA,
                         *imagePosB,
-                        evaluated.get<FillPattern>(),
+                        evaluated.fillPattern,
                         tile.id,
                         parameters.state
                     ),
@@ -209,7 +209,7 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
                  *bucket.triangleIndexBuffer,
                  bucket.triangleSegments);
 
-            if (evaluated.get<FillAntialias>() && unevaluated.get<FillOutlineColor>().isUndefined()) {
+            if (evaluated.fillAntialias && unevaluated.fillOutlineColor.isUndefined()) {
                 draw(parameters.programs.fillOutlinePattern,
                      gl::Lines { 2.0f },
                      parameters.depthModeForSublayer(2, gl::DepthMode::ReadOnly),
@@ -230,8 +230,8 @@ bool RenderFillLayer::queryIntersectsFeature(
 
     auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry(
             queryGeometry,
-            evaluated.get<style::FillTranslate>(),
-            evaluated.get<style::FillTranslateAnchor>(),
+            evaluated.fillTranslate,
+            evaluated.fillTranslateAnchor,
             transformState.getAngle(),
             pixelsToTileUnits);
 
diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.cpp b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
index c9ca477cbb..f7ceee651c 100644
--- a/src/mbgl/renderer/layers/render_heatmap_layer.cpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
@@ -36,7 +36,7 @@ void RenderHeatmapLayer::transition(const TransitionParameters& parameters) {
 void RenderHeatmapLayer::evaluate(const PropertyEvaluationParameters& parameters) {
     evaluated = unevaluated.evaluate(parameters);
 
-    passes = (evaluated.get<style::HeatmapOpacity>() > 0)
+    passes = (evaluated.heatmapOpacity > 0)
             ? (RenderPass::Translucent | RenderPass::Pass3D)
             : RenderPass::None;
 }
@@ -101,7 +101,7 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) {
        
             const auto allUniformValues = programInstance.computeAllUniformValues(
                 HeatmapProgram::UniformValues {
-                    uniforms::u_intensity::Value{ evaluated.get<style::HeatmapIntensity>() },
+                    uniforms::u_intensity::Value{ evaluated.heatmapIntensity },
                     uniforms::u_matrix::Value{ tile.matrix },
                     uniforms::heatmap::u_extrude_scale::Value{ extrudeScale }
                 },
@@ -140,8 +140,8 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) {
         mat4 viewportMat;
         matrix::ortho(viewportMat, 0, size.width, size.height, 0, 0, 1);
 
-        const Properties<>::PossiblyEvaluated properties;
-        const HeatmapTextureProgram::PaintPropertyBinders paintAttributeData{ properties, 0 };
+        static const NoProperties::PossiblyEvaluated properties;
+        static const NoProperties::Binders binders;
 
         auto& programInstance = parameters.programs.heatmapTexture;
 
@@ -150,15 +150,15 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) {
                 uniforms::u_matrix::Value{ viewportMat }, uniforms::u_world::Value{ size },
                 uniforms::u_image::Value{ 0 },
                 uniforms::u_color_ramp::Value{ 1 },
-                uniforms::u_opacity::Value{ evaluated.get<HeatmapOpacity>() }
+                uniforms::u_opacity::Value{ evaluated.heatmapOpacity }
             },
-            paintAttributeData,
+            binders,
             properties,
             parameters.state.getZoom()
         );
         const auto allAttributeBindings = programInstance.computeAllAttributeBindings(
             parameters.staticData.extrusionTextureVertexBuffer,
-            paintAttributeData,
+            binders,
             properties
         );
 
@@ -180,7 +180,7 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) {
 }
 
 void RenderHeatmapLayer::updateColorRamp() {
-    auto colorValue = unevaluated.get<HeatmapColor>().getValue();
+    auto colorValue = unevaluated.heatmapColor.getValue();
     if (colorValue.isUndefined()) {
         colorValue = HeatmapLayer::getDefaultHeatmapColor();
     }
diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.cpp b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
index 8bcd3f1837..a4cbda473e 100644
--- a/src/mbgl/renderer/layers/render_hillshade_layer.cpp
+++ b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
@@ -36,9 +36,9 @@ const std::array<float, 2> RenderHillshadeLayer::getLatRange(const UnwrappedTile
 }
 
 const std::array<float, 2> RenderHillshadeLayer::getLight(const PaintParameters& parameters){
-    float azimuthal = evaluated.get<HillshadeIlluminationDirection>() * util::DEG2RAD;
-    if (evaluated.get<HillshadeIlluminationAnchor>() == HillshadeIlluminationAnchorType::Viewport) azimuthal = azimuthal - parameters.state.getAngle();
-    return {{evaluated.get<HillshadeExaggeration>(), azimuthal}};
+    float azimuthal = evaluated.hillshadeIlluminationDirection * util::DEG2RAD;
+    if (evaluated.hillshadeIlluminationAnchor == HillshadeIlluminationAnchorType::Viewport) azimuthal = azimuthal - parameters.state.getAngle();
+    return {{evaluated.hillshadeExaggeration, azimuthal}};
 }
 
 void RenderHillshadeLayer::transition(const TransitionParameters& parameters) {
@@ -47,7 +47,7 @@ void RenderHillshadeLayer::transition(const TransitionParameters& parameters) {
 
 void RenderHillshadeLayer::evaluate(const PropertyEvaluationParameters& parameters) {
     evaluated = unevaluated.evaluate(parameters);
-    passes = (evaluated.get<style::HillshadeExaggeration >() > 0)
+    passes = (evaluated.hillshadeExaggeration > 0)
                  ? (RenderPass::Translucent | RenderPass::Pass3D)
                  : RenderPass::None;
 }
@@ -71,25 +71,25 @@ void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src
                      const UnwrappedTileID& id) {
         auto& programInstance = parameters.programs.hillshade;
 
-        const HillshadeProgram::PaintPropertyBinders paintAttributeData{ evaluated, 0 };
+        static const NoProperties::Binders binders;
 
         const auto allUniformValues = programInstance.computeAllUniformValues(
             HillshadeProgram::UniformValues {
                 uniforms::u_matrix::Value{ matrix },
                 uniforms::u_image::Value{ 0 },
-                uniforms::u_highlight::Value{ evaluated.get<HillshadeHighlightColor>() },
-                uniforms::u_shadow::Value{ evaluated.get<HillshadeShadowColor>() },
-                uniforms::u_accent::Value{ evaluated.get<HillshadeAccentColor>() },
+                uniforms::u_highlight::Value{ evaluated.hillshadeHighlightColor },
+                uniforms::u_shadow::Value{ evaluated.hillshadeShadowColor },
+                uniforms::u_accent::Value{ evaluated.hillshadeAccentColor },
                 uniforms::u_light::Value{ getLight(parameters) },
                 uniforms::u_latrange::Value{ getLatRange(id) },
             },
-            paintAttributeData,
+            binders,
             evaluated,
             parameters.state.getZoom()
         );
         const auto allAttributeBindings = programInstance.computeAllAttributeBindings(
             vertexBuffer,
-            paintAttributeData,
+            binders,
             evaluated
         );
 
@@ -130,9 +130,10 @@ void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src
             view.bind();
             
             parameters.context.bindTexture(*bucket.dem, 0, gl::TextureFilter::Nearest, gl::TextureMipMap::No, gl::TextureWrap::Clamp, gl::TextureWrap::Clamp);
-            const Properties<>::PossiblyEvaluated properties;
-            const HillshadePrepareProgram::PaintPropertyBinders paintAttributeData{ properties, 0 };
-            
+
+            static const NoProperties::PossiblyEvaluated properties;
+            static const NoProperties::Binders binders;
+
             auto& programInstance = parameters.programs.hillshadePrepare;
 
             const auto allUniformValues = programInstance.computeAllUniformValues(
@@ -143,13 +144,13 @@ void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src
                     uniforms::u_maxzoom::Value{ float(maxzoom) },
                     uniforms::u_image::Value{ 0 }
                 },
-                paintAttributeData,
+                binders,
                 properties,
                 parameters.state.getZoom()
             );
             const auto allAttributeBindings = programInstance.computeAllAttributeBindings(
                 parameters.staticData.rasterVertexBuffer,
-                paintAttributeData,
+                binders,
                 properties
             );
 
@@ -189,8 +190,6 @@ void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src
                      tile.id);
             }
         }
-        
-
     }
 }
 
diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp
index 4b6ea35e67..1c5e726096 100644
--- a/src/mbgl/renderer/layers/render_line_layer.cpp
+++ b/src/mbgl/renderer/layers/render_line_layer.cpp
@@ -34,17 +34,18 @@ void RenderLineLayer::transition(const TransitionParameters& parameters) {
 }
 
 void RenderLineLayer::evaluate(const PropertyEvaluationParameters& parameters) {
-    style::Properties<LineFloorwidth>::Unevaluated extra(unevaluated.get<style::LineWidth>());
-
-    auto dashArrayParams = parameters;
-    dashArrayParams.useIntegerZoom = true;
-
-    evaluated = RenderLinePaintProperties::PossiblyEvaluated(
-        unevaluated.evaluate(parameters).concat(extra.evaluate(dashArrayParams)));
-
-    passes = (evaluated.get<style::LineOpacity>().constantOr(1.0) > 0
-              && evaluated.get<style::LineColor>().constantOr(Color::black()).a > 0
-              && evaluated.get<style::LineWidth>().constantOr(1.0) > 0)
+//    style::Properties<LineFloorwidth>::Unevaluated extra(unevaluated.lineWidth);
+//
+//    auto dashArrayParams = parameters;
+//    dashArrayParams.useIntegerZoom = true;
+//
+//    evaluated = RenderLinePaintProperties::PossiblyEvaluated(
+//        unevaluated.evaluate(parameters).concat(extra.evaluate(dashArrayParams)));
+    evaluated = unevaluated.evaluate(parameters);
+
+    passes = (evaluated.lineOpacity.constantOr(1.0) > 0
+              && evaluated.lineColor.constantOr(Color::black()).a > 0
+              && evaluated.lineWidth.constantOr(1.0) > 0)
              ? RenderPass::Translucent : RenderPass::None;
 }
 
@@ -97,11 +98,11 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
             );
         };
 
-        if (!evaluated.get<LineDasharray>().from.empty()) {
-            const LinePatternCap cap = bucket.layout.get<LineCap>() == LineCapType::Round
+        if (!evaluated.lineDasharray.from.empty()) {
+            const LinePatternCap cap = bucket.layout.lineCap == LineCapType::Round
                 ? LinePatternCap::Round : LinePatternCap::Square;
-            LinePatternPos posA = parameters.lineAtlas.getDashPosition(evaluated.get<LineDasharray>().from, cap);
-            LinePatternPos posB = parameters.lineAtlas.getDashPosition(evaluated.get<LineDasharray>().to, cap);
+            LinePatternPos posA = parameters.lineAtlas.getDashPosition(evaluated.lineDasharray.from, cap);
+            LinePatternPos posB = parameters.lineAtlas.getDashPosition(evaluated.lineDasharray.to, cap);
 
             parameters.lineAtlas.bind(parameters.context, 0);
 
@@ -116,9 +117,9 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
                      posB,
                      parameters.lineAtlas.getSize().width));
 
-        } else if (!evaluated.get<LinePattern>().from.empty()) {
-            optional<ImagePosition> posA = parameters.imageManager.getPattern(evaluated.get<LinePattern>().from);
-            optional<ImagePosition> posB = parameters.imageManager.getPattern(evaluated.get<LinePattern>().to);
+        } else if (!evaluated.linePattern.from.empty()) {
+            optional<ImagePosition> posA = parameters.imageManager.getPattern(evaluated.linePattern.from);
+            optional<ImagePosition> posB = parameters.imageManager.getPattern(evaluated.linePattern.to);
 
             if (!posA || !posB)
                 return;
@@ -187,13 +188,13 @@ bool RenderLineLayer::queryIntersectsFeature(
     // Translate query geometry
     auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry(
             queryGeometry,
-            evaluated.get<style::LineTranslate>(),
-            evaluated.get<style::LineTranslateAnchor>(),
+            evaluated.lineTranslate,
+            evaluated.lineTranslateAnchor,
             transformState.getAngle(),
             pixelsToTileUnits);
 
     // Evaluate function
-    auto offset = evaluated.get<style::LineOffset>()
+    auto offset = evaluated.lineOffset
                           .evaluate(feature, zoom, style::LineOffset::defaultValue()) * pixelsToTileUnits;
 
     // Apply offset to geometry
@@ -208,9 +209,9 @@ bool RenderLineLayer::queryIntersectsFeature(
 }
 
 float RenderLineLayer::getLineWidth(const GeometryTileFeature& feature, const float zoom) const {
-    float lineWidth = evaluated.get<style::LineWidth>()
+    float lineWidth = evaluated.lineWidth
             .evaluate(feature, zoom, style::LineWidth::defaultValue());
-    float gapWidth = evaluated.get<style::LineGapWidth>()
+    float gapWidth = evaluated.lineGapWidth
             .evaluate(feature, zoom, style::LineGapWidth::defaultValue());
     if (gapWidth) {
         return gapWidth + 2 * lineWidth;
diff --git a/src/mbgl/renderer/layers/render_line_layer.hpp b/src/mbgl/renderer/layers/render_line_layer.hpp
index 5d5d79c044..1f47d39846 100644
--- a/src/mbgl/renderer/layers/render_line_layer.hpp
+++ b/src/mbgl/renderer/layers/render_line_layer.hpp
@@ -11,9 +11,10 @@ struct LineFloorwidth : style::DataDrivenPaintProperty<float, attributes::a_floo
     static float defaultValue() { return 1; }
 };
 
-class RenderLinePaintProperties : public style::ConcatenateProperties<
-    style::LinePaintProperties::PropertyTypes,
-    TypeList<LineFloorwidth>>::Type {};
+//class RenderLinePaintProperties : public style::ConcatenateProperties<
+//    style::LinePaintProperties::PropertyTypes,
+//    TypeList<LineFloorwidth>>::Type {};
+using RenderLinePaintProperties = style::LinePaintProperties;
 
 class RenderLineLayer: public RenderLayer {
 public:
diff --git a/src/mbgl/renderer/layers/render_raster_layer.cpp b/src/mbgl/renderer/layers/render_raster_layer.cpp
index e2524697b5..62a1735b43 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.cpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.cpp
@@ -34,7 +34,7 @@ void RenderRasterLayer::transition(const TransitionParameters& parameters) {
 void RenderRasterLayer::evaluate(const PropertyEvaluationParameters& parameters) {
     evaluated = unevaluated.evaluate(parameters);
 
-    passes = evaluated.get<style::RasterOpacity>() > 0 ? RenderPass::Translucent : RenderPass::None;
+    passes = evaluated.rasterOpacity > 0 ? RenderPass::Translucent : RenderPass::None;
 }
 
 bool RenderRasterLayer::hasTransition() const {
@@ -73,7 +73,7 @@ void RenderRasterLayer::render(PaintParameters& parameters, RenderSource* source
     if (parameters.pass != RenderPass::Translucent)
         return;
 
-    RasterProgram::PaintPropertyBinders paintAttributeData{ evaluated, 0 };
+    static const NoProperties::Binders binders;
 
     auto draw = [&] (const mat4& matrix,
                      const auto& vertexBuffer,
@@ -86,24 +86,24 @@ void RenderRasterLayer::render(PaintParameters& parameters, RenderSource* source
                 uniforms::u_matrix::Value{ matrix },
                 uniforms::u_image0::Value{ 0 },
                 uniforms::u_image1::Value{ 1 },
-                uniforms::u_opacity::Value{ evaluated.get<RasterOpacity>() },
+                uniforms::u_opacity::Value{ evaluated.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_brightness_low::Value{ evaluated.rasterBrightnessMin },
+                uniforms::u_brightness_high::Value{ evaluated.rasterBrightnessMax },
+                uniforms::u_saturation_factor::Value{ saturationFactor(evaluated.rasterSaturation) },
+                uniforms::u_contrast_factor::Value{ contrastFactor(evaluated.rasterContrast) },
+                uniforms::u_spin_weights::Value{ spinWeights(evaluated.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 }} },
             },
-            paintAttributeData,
+            binders,
             evaluated,
             parameters.state.getZoom()
         );
         const auto allAttributeBindings = programInstance.computeAllAttributeBindings(
             vertexBuffer,
-            paintAttributeData,
+            binders,
             evaluated
         );
 
@@ -123,7 +123,7 @@ void RenderRasterLayer::render(PaintParameters& parameters, RenderSource* source
         );
     };
 
-    const gl::TextureFilter filter = evaluated.get<RasterResampling>() == RasterResamplingType::Nearest ? gl::TextureFilter::Nearest : gl::TextureFilter::Linear;
+    const gl::TextureFilter filter = evaluated.rasterResampling == RasterResamplingType::Nearest ? gl::TextureFilter::Nearest : gl::TextureFilter::Linear;
 
     if (RenderImageSource* imageSource = source->as<RenderImageSource>()) {
         if (imageSource->isEnabled() && imageSource->isLoaded() && !imageSource->bucket->needsUpload()) {
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.cpp b/src/mbgl/renderer/layers/render_symbol_layer.cpp
index f9e4e7c043..12c5ba43b9 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.cpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp
@@ -55,13 +55,13 @@ void RenderSymbolLayer::transition(const TransitionParameters& parameters) {
 void RenderSymbolLayer::evaluate(const PropertyEvaluationParameters& parameters) {
     evaluated = unevaluated.evaluate(parameters);
 
-    auto hasIconOpacity = evaluated.get<style::IconColor>().constantOr(Color::black()).a > 0 ||
-                          evaluated.get<style::IconHaloColor>().constantOr(Color::black()).a > 0;
-    auto hasTextOpacity = evaluated.get<style::TextColor>().constantOr(Color::black()).a > 0 ||
-                          evaluated.get<style::TextHaloColor>().constantOr(Color::black()).a > 0;
+    auto hasIconOpacity = evaluated.iconColor.constantOr(Color::black()).a > 0 ||
+                          evaluated.iconHaloColor.constantOr(Color::black()).a > 0;
+    auto hasTextOpacity = evaluated.textColor.constantOr(Color::black()).a > 0 ||
+                          evaluated.textHaloColor.constantOr(Color::black()).a > 0;
 
-    passes = ((evaluated.get<style::IconOpacity>().constantOr(1) > 0 && hasIconOpacity && iconSize > 0)
-              || (evaluated.get<style::TextOpacity>().constantOr(1) > 0 && hasTextOpacity && textSize > 0))
+    passes = ((evaluated.iconOpacity.constantOr(1) > 0 && hasIconOpacity && iconSize > 0)
+              || (evaluated.textOpacity.constantOr(1) > 0 && hasTextOpacity && textSize > 0))
              ? RenderPass::Translucent : RenderPass::None;
 }
 
@@ -133,8 +133,8 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
             auto values = iconPropertyValues(layout);
             auto paintPropertyValues = iconPaintProperties();
 
-            const bool alongLine = layout.get<SymbolPlacement>() != SymbolPlacementType::Point &&
-                layout.get<IconRotationAlignment>() == AlignmentType::Map;
+            const bool alongLine = layout.symbolPlacement != SymbolPlacementType::Point &&
+                layout.iconRotationAlignment == AlignmentType::Map;
 
             if (alongLine) {
                 reprojectLineLabels(bucket.icon.dynamicVertices,
@@ -148,7 +148,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
                 parameters.context.updateVertexBuffer(*bucket.icon.dynamicVertexBuffer, std::move(bucket.icon.dynamicVertices));
             }
 
-            const bool iconScaled = layout.get<IconSize>().constantOr(1.0) != 1.0 || bucket.iconsNeedLinear;
+            const bool iconScaled = layout.iconSize.constantOr(1.0) != 1.0 || bucket.iconsNeedLinear;
             const bool iconTransformed = values.rotationAlignment == AlignmentType::Map || parameters.state.getPitch() != 0;
 
             parameters.context.bindTexture(*geometryTile.iconAtlasTexture, 0,
@@ -194,8 +194,8 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
             auto values = textPropertyValues(layout);
             auto paintPropertyValues = textPaintProperties();
 
-            const bool alongLine = layout.get<SymbolPlacement>() != SymbolPlacementType::Point &&
-                layout.get<TextRotationAlignment>() == AlignmentType::Map;
+            const bool alongLine = layout.symbolPlacement != SymbolPlacementType::Point &&
+                layout.textRotationAlignment == AlignmentType::Map;
 
             if (alongLine) {
                 reprojectLineLabels(bucket.text.dynamicVertices,
@@ -233,9 +233,6 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
         }
 
         if (bucket.hasCollisionBoxData()) {
-            static const style::Properties<>::PossiblyEvaluated properties {};
-            static const CollisionBoxProgram::PaintPropertyBinders paintAttributeData(properties, 0);
-
             auto pixelRatio = tile.id.pixelsToTileUnits(1, parameters.state.getZoom());
             const float scale = std::pow(2, parameters.state.getZoom() - tile.tile.id.overscaledZ);
             std::array<float,2> extrudeScale =
@@ -259,16 +256,10 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
                 *bucket.collisionBox.dynamicVertexBuffer,
                 *bucket.collisionBox.indexBuffer,
                 bucket.collisionBox.segments,
-                paintAttributeData,
-                properties,
-                parameters.state.getZoom(),
                 getID()
             );
         }
         if (bucket.hasCollisionCircleData()) {
-            static const style::Properties<>::PossiblyEvaluated properties {};
-            static const CollisionBoxProgram::PaintPropertyBinders paintAttributeData(properties, 0);
-
             auto pixelRatio = tile.id.pixelsToTileUnits(1, parameters.state.getZoom());
             const float scale = std::pow(2, parameters.state.getZoom() - tile.tile.id.overscaledZ);
             std::array<float,2> extrudeScale =
@@ -294,9 +285,6 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
                 *bucket.collisionCircle.dynamicVertexBuffer,
                 *bucket.collisionCircle.indexBuffer,
                 bucket.collisionCircle.segments,
-                paintAttributeData,
-                properties,
-                parameters.state.getZoom(),
                 getID()
             );
 
@@ -306,52 +294,52 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
 
 style::IconPaintProperties::PossiblyEvaluated RenderSymbolLayer::iconPaintProperties() const {
     return style::IconPaintProperties::PossiblyEvaluated {
-            evaluated.get<style::IconOpacity>(),
-            evaluated.get<style::IconColor>(),
-            evaluated.get<style::IconHaloColor>(),
-            evaluated.get<style::IconHaloWidth>(),
-            evaluated.get<style::IconHaloBlur>(),
-            evaluated.get<style::IconTranslate>(),
-            evaluated.get<style::IconTranslateAnchor>()
+        evaluated.iconOpacity,
+        evaluated.iconColor,
+        evaluated.iconHaloColor,
+        evaluated.iconHaloWidth,
+        evaluated.iconHaloBlur,
+        evaluated.iconTranslate,
+        evaluated.iconTranslateAnchor
     };
 }
 
 style::TextPaintProperties::PossiblyEvaluated RenderSymbolLayer::textPaintProperties() const {
     return style::TextPaintProperties::PossiblyEvaluated {
-            evaluated.get<style::TextOpacity>(),
-            evaluated.get<style::TextColor>(),
-            evaluated.get<style::TextHaloColor>(),
-            evaluated.get<style::TextHaloWidth>(),
-            evaluated.get<style::TextHaloBlur>(),
-            evaluated.get<style::TextTranslate>(),
-            evaluated.get<style::TextTranslateAnchor>()
+        evaluated.textOpacity,
+        evaluated.textColor,
+        evaluated.textHaloColor,
+        evaluated.textHaloWidth,
+        evaluated.textHaloBlur,
+        evaluated.textTranslate,
+        evaluated.textTranslateAnchor
     };
 }
 
 
 style::SymbolPropertyValues RenderSymbolLayer::iconPropertyValues(const style::SymbolLayoutProperties::PossiblyEvaluated& layout_) const {
     return style::SymbolPropertyValues {
-            layout_.get<style::IconPitchAlignment>(),
-            layout_.get<style::IconRotationAlignment>(),
-            layout_.get<style::IconKeepUpright>(),
-            evaluated.get<style::IconTranslate>(),
-            evaluated.get<style::IconTranslateAnchor>(),
-            evaluated.get<style::IconHaloColor>().constantOr(Color::black()).a > 0 &&
-            evaluated.get<style::IconHaloWidth>().constantOr(1),
-            evaluated.get<style::IconColor>().constantOr(Color::black()).a > 0
+        layout_.iconPitchAlignment,
+        layout_.iconRotationAlignment,
+        layout_.iconKeepUpright,
+        evaluated.iconTranslate,
+        evaluated.iconTranslateAnchor,
+        evaluated.iconHaloColor.constantOr(Color::black()).a > 0 &&
+        evaluated.iconHaloWidth.constantOr(1),
+        evaluated.iconColor.constantOr(Color::black()).a > 0
     };
 }
 
 style::SymbolPropertyValues RenderSymbolLayer::textPropertyValues(const style::SymbolLayoutProperties::PossiblyEvaluated& layout_) const {
     return style::SymbolPropertyValues {
-            layout_.get<style::TextPitchAlignment>(),
-            layout_.get<style::TextRotationAlignment>(),
-            layout_.get<style::TextKeepUpright>(),
-            evaluated.get<style::TextTranslate>(),
-            evaluated.get<style::TextTranslateAnchor>(),
-            evaluated.get<style::TextHaloColor>().constantOr(Color::black()).a > 0 &&
-            evaluated.get<style::TextHaloWidth>().constantOr(1),
-            evaluated.get<style::TextColor>().constantOr(Color::black()).a > 0
+        layout_.textPitchAlignment,
+        layout_.textRotationAlignment,
+        layout_.textKeepUpright,
+        evaluated.textTranslate,
+        evaluated.textTranslateAnchor,
+        evaluated.textHaloColor.constantOr(Color::black()).a > 0 &&
+        evaluated.textHaloWidth.constantOr(1),
+        evaluated.textColor.constantOr(Color::black()).a > 0
     };
 }
 
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.hpp b/src/mbgl/renderer/layers/render_symbol_layer.hpp
index 5b73b30294..f977e81308 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.hpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.hpp
@@ -10,29 +10,6 @@ namespace mbgl {
 
 namespace style {
 
-// {icon,text}-specific paint-property packs for use in the symbol Programs.
-// Since each program deals either with icons or text, using a smaller property set
-// lets us avoid unnecessarily binding attributes for properties the program wouldn't use.
-class IconPaintProperties : public Properties<
-        IconOpacity,
-        IconColor,
-        IconHaloColor,
-        IconHaloWidth,
-        IconHaloBlur,
-        IconTranslate,
-        IconTranslateAnchor
-> {};
-
-class TextPaintProperties : public Properties<
-        TextOpacity,
-        TextColor,
-        TextHaloColor,
-        TextHaloWidth,
-        TextHaloBlur,
-        TextTranslate,
-        TextTranslateAnchor
-> {};
-
 // Repackaging evaluated values from SymbolLayoutProperties + SymbolPaintProperties
 // for genericity over icons vs. text.
 class SymbolPropertyValues {
diff --git a/src/mbgl/renderer/paint_property_binder.hpp b/src/mbgl/renderer/paint_property_binder.hpp
index aade672ae7..7773e79314 100644
--- a/src/mbgl/renderer/paint_property_binder.hpp
+++ b/src/mbgl/renderer/paint_property_binder.hpp
@@ -273,100 +273,4 @@ struct InterpolationUniform : gl::UniformScalar<InterpolationUniform<Attr>, floa
     }
 };
 
-template <class Ps>
-class PaintPropertyBinders;
-
-template <class... Ps>
-class PaintPropertyBinders<TypeList<Ps...>> {
-public:
-    template <class P>
-    using Binder = PaintPropertyBinder<typename P::Type, typename P::Attribute::Type>;
-
-    using Binders = IndexedTuple<
-        TypeList<Ps...>,
-        TypeList<std::unique_ptr<Binder<Ps>>...>>;
-
-    template <class EvaluatedProperties>
-    PaintPropertyBinders(const EvaluatedProperties& properties, float z)
-        : binders(Binder<Ps>::create(properties.template get<Ps>(), z, Ps::defaultValue())...) {
-        (void)z; // Workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56958
-    }
-
-    PaintPropertyBinders(PaintPropertyBinders&&) = default;
-    PaintPropertyBinders(const PaintPropertyBinders&) = delete;
-
-    void populateVertexVectors(const GeometryTileFeature& feature, std::size_t length) {
-        util::ignore({
-            (binders.template get<Ps>()->populateVertexVector(feature, length), 0)...
-        });
-    }
-
-    void upload(gl::Context& context) {
-        util::ignore({
-            (binders.template get<Ps>()->upload(context), 0)...
-        });
-    }
-
-    template <class P>
-    using Attribute = ZoomInterpolatedAttribute<typename P::Attribute>;
-
-    using Attributes = gl::Attributes<Attribute<Ps>...>;
-    using AttributeBindings = typename Attributes::Bindings;
-
-    template <class EvaluatedProperties>
-    AttributeBindings attributeBindings(const EvaluatedProperties& currentProperties) const {
-        return AttributeBindings {
-            binders.template get<Ps>()->attributeBinding(currentProperties.template get<Ps>())...
-        };
-    }
-
-    using Uniforms = gl::Uniforms<InterpolationUniform<typename Ps::Attribute>..., typename Ps::Uniform...>;
-    using UniformValues = typename Uniforms::Values;
-
-    template <class EvaluatedProperties>
-    UniformValues uniformValues(float currentZoom, const EvaluatedProperties& currentProperties) const {
-        (void)currentZoom; // Workaround for https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56958
-        return UniformValues {
-            typename InterpolationUniform<typename Ps::Attribute>::Value {
-                binders.template get<Ps>()->interpolationFactor(currentZoom)
-            }...,
-            typename Ps::Uniform::Value {
-                binders.template get<Ps>()->uniformValue(currentProperties.template get<Ps>())
-            }...
-        };
-    }
-
-    template <class P>
-    const auto& statistics() const {
-        return binders.template get<P>()->statistics;
-    }
-
-
-    using Bitset = std::bitset<sizeof...(Ps)>;
-
-    template <class EvaluatedProperties>
-    static Bitset constants(const EvaluatedProperties& currentProperties) {
-        Bitset result;
-        util::ignore({
-            result.set(TypeIndex<Ps, Ps...>::value,
-                       currentProperties.template get<Ps>().isConstant())...
-        });
-        return result;
-    }
-
-    template <class EvaluatedProperties>
-    static std::vector<std::string> defines(const EvaluatedProperties& currentProperties) {
-        std::vector<std::string> result;
-        util::ignore({
-            (result.push_back(currentProperties.template get<Ps>().isConstant()
-                ? std::string("#define HAS_UNIFORM_") + Ps::Uniform::name()
-                : std::string()), 0)...
-        });
-        return result;
-    }
-
-private:
-    Binders binders;
-};
-
 } // namespace mbgl
diff --git a/src/mbgl/renderer/render_light.hpp b/src/mbgl/renderer/render_light.hpp
index f13f925318..03865d2365 100644
--- a/src/mbgl/renderer/render_light.hpp
+++ b/src/mbgl/renderer/render_light.hpp
@@ -9,7 +9,7 @@ class TransitionParameters;
 class PropertyEvaluationParameters;
 
 using TransitioningLight = style::LightProperties::Unevaluated;
-using EvaluatedLight     = style::LightProperties::PossiblyEvaluated;
+using EvaluatedLight     = style::LightProperties::Evaluated;
 
 class RenderLight {
 public:
diff --git a/src/mbgl/renderer/render_tile.cpp b/src/mbgl/renderer/render_tile.cpp
index 64790938ef..cf7156c7e6 100644
--- a/src/mbgl/renderer/render_tile.cpp
+++ b/src/mbgl/renderer/render_tile.cpp
@@ -71,8 +71,8 @@ void RenderTile::finishRender(PaintParameters& parameters) {
     if (!used || parameters.debugOptions == MapDebugOptions::NoDebug)
         return;
 
-    static const style::Properties<>::PossiblyEvaluated properties {};
-    static const DebugProgram::PaintPropertyBinders paintAttributeData(properties, 0);
+    static const NoProperties::PossiblyEvaluated properties;
+    static const NoProperties::Binders paintAttributeData;
 
     auto& program = parameters.programs.debug;
 
diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp
index fea27403c9..4af07551bf 100644
--- a/src/mbgl/renderer/renderer_impl.cpp
+++ b/src/mbgl/renderer/renderer_impl.cpp
@@ -306,9 +306,9 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
             const BackgroundPaintProperties::PossiblyEvaluated& paint = background->evaluated;
             if (parameters.contextMode == GLContextMode::Unique
                     && layerImpl.get() == layerImpls->at(0).get()
-                    && paint.get<BackgroundPattern>().from.empty()) {
+                    && paint.backgroundPattern.from.empty()) {
                 // This is a solid background. We can use glClear().
-                backgroundColor = paint.get<BackgroundColor>() * paint.get<BackgroundOpacity>();
+                backgroundColor = paint.backgroundColor * paint.backgroundOpacity;
             } else {
                 // This is a textured background, or not the bottommost layer. We need to render it with a quad.
                 order.emplace_back(RenderItem { *layer, nullptr });
@@ -481,8 +481,8 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
     {
         MBGL_DEBUG_GROUP(parameters.context, "clipping masks");
 
-        static const Properties<>::PossiblyEvaluated properties {};
-        static const ClippingMaskProgram::PaintPropertyBinders paintAttributeData(properties, 0);
+        static const NoProperties::PossiblyEvaluated properties;
+        static const NoProperties::Binders binders;
 
         for (const auto& clipID : parameters.clipIDGenerator.getClipIDs()) {
             auto& program = parameters.staticData.programs.clippingMask;
@@ -506,13 +506,13 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
                     ClippingMaskProgram::UniformValues {
                         uniforms::u_matrix::Value{ parameters.matrixForTile(clipID.first) },
                     },
-                    paintAttributeData,
+                    binders,
                     properties,
                     parameters.state.getZoom()
                 ),
                 program.computeAllAttributeBindings(
                     parameters.staticData.tileVertexBuffer,
-                    paintAttributeData,
+                    binders,
                     properties
                 ),
                 "clipping"
diff --git a/src/mbgl/renderer/sources/render_image_source.cpp b/src/mbgl/renderer/sources/render_image_source.cpp
index 2ce046a7a0..eaa02f5395 100644
--- a/src/mbgl/renderer/sources/render_image_source.cpp
+++ b/src/mbgl/renderer/sources/render_image_source.cpp
@@ -55,8 +55,8 @@ void RenderImageSource::finishRender(PaintParameters& parameters) {
         return;
     }
 
-    static const style::Properties<>::PossiblyEvaluated properties {};
-    static const DebugProgram::PaintPropertyBinders paintAttributeData(properties, 0);
+    static const NoProperties::PossiblyEvaluated properties;
+    static const NoProperties::Binders binders;
 
     auto& programInstance = parameters.programs.debug;
 
@@ -74,13 +74,13 @@ void RenderImageSource::finishRender(PaintParameters& parameters) {
                     uniforms::u_matrix::Value{ matrix },
                     uniforms::u_color::Value{ Color::red() }
                 },
-                paintAttributeData,
+                binders,
                 properties,
                 parameters.state.getZoom()
             ),
             programInstance.computeAllAttributeBindings(
                 parameters.staticData.tileVertexBuffer,
-                paintAttributeData,
+                binders,
                 properties
             ),
             "image"