8 files changed, 271 insertions, 9 deletions
diff --git a/src/mbgl/programs/attributes.hpp b/src/mbgl/programs/attributes.hpp
index e9ca18927e..cfd6a629de 100644
--- a/src/mbgl/programs/attributes.hpp
+++ b/src/mbgl/programs/attributes.hpp
@@ -24,6 +24,8 @@ MBGL_DEFINE_ATTRIBUTE(int16_t, 2, a_pos);
 MBGL_DEFINE_ATTRIBUTE(int16_t, 2, a_extrude);
 MBGL_DEFINE_ATTRIBUTE(int16_t, 4, a_pos_offset);
 MBGL_DEFINE_ATTRIBUTE(uint16_t, 2, a_texture_pos);
+MBGL_DEFINE_ATTRIBUTE(int16_t,  3, a_normal);
+MBGL_DEFINE_ATTRIBUTE(uint16_t, 1, a_edgedistance);
 
 template <typename T, std::size_t N>
 struct a_data {
diff --git a/src/mbgl/programs/extrusion_texture_program.cpp b/src/mbgl/programs/extrusion_texture_program.cpp
new file mode 100644
index 0000000000..afda4384b7
--- /dev/null
+++ b/src/mbgl/programs/extrusion_texture_program.cpp
@@ -0,0 +1,7 @@
+#include <mbgl/programs/extrusion_texture_program.hpp>
+
+namespace mbgl {
+
+static_assert(sizeof(ExtrusionTextureLayoutVertex) == 4, "expected ExtrusionTextureLayoutVertex size");
+
+} // namespace mbgl
diff --git a/src/mbgl/programs/extrusion_texture_program.hpp b/src/mbgl/programs/extrusion_texture_program.hpp
new file mode 100644
index 0000000000..1519aa095d
--- /dev/null
+++ b/src/mbgl/programs/extrusion_texture_program.hpp
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <mbgl/programs/program.hpp>
+#include <mbgl/programs/attributes.hpp>
+#include <mbgl/programs/uniforms.hpp>
+#include <mbgl/shaders/extrusion_texture.hpp>
+#include <mbgl/util/geometry.hpp>
+
+namespace mbgl {
+
+class ExtrusionTextureProgram : public Program<
+    shaders::extrusion_texture,
+    gl::Triangle,
+    gl::Attributes<attributes::a_pos>,
+    gl::Uniforms<
+        uniforms::u_matrix,
+        uniforms::u_world,
+        uniforms::u_image,
+        uniforms::u_opacity>,
+    style::PaintProperties<>> {
+public:
+    using Program::Program;
+
+    static LayoutVertex layoutVertex(Point<int16_t> p) {
+        return LayoutVertex{
+            {{
+                p.x,
+                p.y
+            }}
+        };
+    }
+};
+
+using ExtrusionTextureLayoutVertex = ExtrusionTextureProgram::LayoutVertex;
+using ExtrusionTextureAttributes = ExtrusionTextureProgram::Attributes;
+
+} // namespace mbgl
diff --git a/src/mbgl/programs/fill_extrusion_program.cpp b/src/mbgl/programs/fill_extrusion_program.cpp
new file mode 100644
index 0000000000..67426c8d9d
--- /dev/null
+++ b/src/mbgl/programs/fill_extrusion_program.cpp
@@ -0,0 +1,81 @@
+#include <mbgl/programs/fill_extrusion_program.hpp>
+#include <mbgl/sprite/sprite_atlas.hpp>
+#include <mbgl/style/cross_faded_property_evaluator.hpp>
+#include <mbgl/tile/tile_id.hpp>
+#include <mbgl/map/transform_state.hpp>
+#include <mbgl/util/mat3.hpp>
+
+namespace mbgl {
+
+using namespace style;
+
+static_assert(sizeof(FillExtrusionLayoutVertex) == 12, "expected FillExtrusionLayoutVertex size");
+
+std::array<float, 3> lightColor(const EvaluatedLight& light) {
+    const auto color = light.get<LightColor>();
+    return {{ color.r, color.g, color.b }};
+}
+
+std::array<float, 3> lightPosition(const EvaluatedLight& light, const TransformState& state) {
+    auto lightPos = light.get<LightPosition>().getCartesian();
+    mat3 lightMat;
+    matrix::identity(lightMat);
+    if (light.get<LightAnchor>() == LightAnchorType::Viewport) {
+        matrix::rotate(lightMat, lightMat, -state.getAngle());
+    }
+    matrix::transformMat3f(lightPos, lightPos, lightMat);
+    return lightPos;
+}
+
+float lightIntensity(const EvaluatedLight& light) {
+    return light.get<LightIntensity>();
+}
+
+FillExtrusionUniforms::Values
+FillExtrusionUniforms::values(mat4 matrix,
+                              const TransformState& state,
+                              const EvaluatedLight& light) {
+    return FillExtrusionUniforms::Values{
+        uniforms::u_matrix::Value{ matrix },
+        uniforms::u_lightcolor::Value{ lightColor(light) },
+        uniforms::u_lightpos::Value{ lightPosition(light, state) },
+        uniforms::u_lightintensity::Value{ lightIntensity(light) }
+    };
+}
+
+FillExtrusionPatternUniforms::Values
+FillExtrusionPatternUniforms::values(mat4 matrix,
+                                     const SpriteAtlasElement& a,
+                                     const SpriteAtlasElement& b,
+                                     const Faded<std::string>& fading,
+                                     const UnwrappedTileID& tileID,
+                                     const TransformState& state,
+                                     const float heightFactor,
+                                     const EvaluatedLight& light) {
+    int32_t tileSizeAtNearestZoom = util::tileSize * state.zoomScale(state.getIntegerZoom() - tileID.canonical.z);
+    int32_t pixelX = tileSizeAtNearestZoom * (tileID.canonical.x + tileID.wrap * state.zoomScale(tileID.canonical.z));
+    int32_t pixelY = tileSizeAtNearestZoom * tileID.canonical.y;
+
+    return FillExtrusionPatternUniforms::Values{
+        uniforms::u_matrix::Value{ matrix },
+        uniforms::u_pattern_tl_a::Value{ a.tl },
+        uniforms::u_pattern_br_a::Value{ a.br },
+        uniforms::u_pattern_tl_b::Value{ b.tl },
+        uniforms::u_pattern_br_b::Value{ b.br },
+        uniforms::u_pattern_size_a::Value{ a.size },
+        uniforms::u_pattern_size_b::Value{ b.size },
+        uniforms::u_scale_a::Value{ fading.fromScale },
+        uniforms::u_scale_b::Value{ fading.toScale },
+        uniforms::u_mix::Value{ fading.t },
+        uniforms::u_image::Value{ 0 },
+        uniforms::u_pixel_coord_upper::Value{ std::array<float, 2>{{ float(pixelX >> 16), float(pixelY >> 16) }} },
+        uniforms::u_pixel_coord_lower::Value{ std::array<float, 2>{{ float(pixelX & 0xFFFF), float(pixelY & 0xFFFF) }} },
+        uniforms::u_tile_units_to_pixels::Value{ 1.0f / tileID.pixelsToTileUnits(1.0f, state.getIntegerZoom()) },
+        uniforms::u_height_factor::Value{ heightFactor },
+        uniforms::u_lightcolor::Value{ lightColor(light) },
+        uniforms::u_lightpos::Value{ lightPosition(light, state) },
+        uniforms::u_lightintensity::Value{ lightIntensity(light) },
+    };
+}
+
+} // namespace mbgl
diff --git a/src/mbgl/programs/fill_extrusion_program.hpp b/src/mbgl/programs/fill_extrusion_program.hpp
new file mode 100644
index 0000000000..b84e50298c
--- /dev/null
+++ b/src/mbgl/programs/fill_extrusion_program.hpp
@@ -0,0 +1,129 @@
+#pragma once
+
+#include <mbgl/programs/program.hpp>
+#include <mbgl/programs/attributes.hpp>
+#include <mbgl/programs/uniforms.hpp>
+#include <mbgl/shaders/fill_extrusion.hpp>
+#include <mbgl/shaders/fill_extrusion_pattern.hpp>
+#include <mbgl/util/geometry.hpp>
+#include <mbgl/util/mat4.hpp>
+#include <mbgl/util/size.hpp>
+#include <mbgl/style/layers/fill_extrusion_layer_properties.hpp>
+#include <mbgl/style/style.hpp>
+#include <mbgl/style/light_impl.hpp>
+
+#include <string>
+
+namespace mbgl {
+
+class SpriteAtlasElement;
+class UnwrappedTileID;
+class TransformState;
+
+namespace style {
+template <class> class Faded;
+} // namespace style
+
+namespace uniforms {
+MBGL_DEFINE_UNIFORM_VECTOR(float, 3, u_lightpos);
+MBGL_DEFINE_UNIFORM_VECTOR(float, 3, u_lightcolor);
+MBGL_DEFINE_UNIFORM_SCALAR(float,    u_lightintensity);
+MBGL_DEFINE_UNIFORM_SCALAR(float,    u_height_factor);
+} // namespace uniforms
+
+struct FillExtrusionLayoutAttributes : gl::Attributes<
+    attributes::a_pos,
+    attributes::a_normal,
+    attributes::a_edgedistance>
+{};
+
+struct FillExtrusionUniforms : gl::Uniforms<
+    uniforms::u_matrix,
+    uniforms::u_lightcolor,
+    uniforms::u_lightpos,
+    uniforms::u_lightintensity>
+{
+    static Values values(mat4,
+                         const TransformState&,
+                         const style::EvaluatedLight&);
+};
+
+struct FillExtrusionPatternUniforms : gl::Uniforms<
+    uniforms::u_matrix,
+    uniforms::u_pattern_tl_a,
+    uniforms::u_pattern_br_a,
+    uniforms::u_pattern_tl_b,
+    uniforms::u_pattern_br_b,
+    uniforms::u_pattern_size_a,
+    uniforms::u_pattern_size_b,
+    uniforms::u_scale_a,
+    uniforms::u_scale_b,
+    uniforms::u_mix,
+    uniforms::u_image,
+    uniforms::u_pixel_coord_upper,
+    uniforms::u_pixel_coord_lower,
+    uniforms::u_tile_units_to_pixels,
+    uniforms::u_height_factor,
+    uniforms::u_lightcolor,
+    uniforms::u_lightpos,
+    uniforms::u_lightintensity>
+{
+    static Values values(mat4,
+                         const SpriteAtlasElement&,
+                         const SpriteAtlasElement&,
+                         const style::Faded<std::string>&,
+                         const UnwrappedTileID&,
+                         const TransformState&,
+                         const float,
+                         const style::EvaluatedLight&);
+};
+
+class FillExtrusionProgram : public Program<
+    shaders::fill_extrusion,
+    gl::Triangle,
+    FillExtrusionLayoutAttributes,
+    FillExtrusionUniforms,
+    style::FillExtrusionPaintProperties>
+{
+public:
+    using Program::Program;
+
+    static LayoutVertex layoutVertex(Point<int16_t> p, double nx, double ny, double nz, unsigned short t, uint16_t e) {
+        const auto factor = pow(2, 13);
+
+        return LayoutVertex {
+            {{
+                p.x,
+                p.y
+            }},
+            {{
+                // Multiply normal vector components by 2^14 to pack them into integers
+                // We pack a bool (`t`) into the x component indicating whether it is an upper or lower vertex
+                static_cast<int16_t>(floor(nx * factor) * 2 + t),
+                static_cast<int16_t>(ny * factor * 2),
+                static_cast<int16_t>(nz * factor * 2)
+                
+            }},
+            {{
+                // The edgedistance attribute is used for wrapping fill_extrusion patterns
+                e
+            }}
+        };
+    }
+};
+
+class FillExtrusionPatternProgram : public Program<
+    shaders::fill_extrusion_pattern,
+    gl::Triangle,
+    FillExtrusionLayoutAttributes,
+    FillExtrusionPatternUniforms,
+    style::FillExtrusionPaintProperties>
+{
+public:
+    using Program::Program;
+};
+
+using FillExtrusionLayoutVertex = FillExtrusionProgram::LayoutVertex;
+using FillExtrusionAttributes = FillExtrusionProgram::Attributes;
+
+} // namespace mbgl
diff --git a/src/mbgl/programs/fill_program.hpp b/src/mbgl/programs/fill_program.hpp
index 84ca2748d6..bbf5c39fb9 100644
--- a/src/mbgl/programs/fill_program.hpp
+++ b/src/mbgl/programs/fill_program.hpp
@@ -24,15 +24,6 @@ namespace style {
 template <class> class Faded;
 } // namespace style
 
-namespace uniforms {
-MBGL_DEFINE_UNIFORM_SCALAR(Size,     u_world);
-MBGL_DEFINE_UNIFORM_SCALAR(float,    u_scale_a);
-MBGL_DEFINE_UNIFORM_SCALAR(float,    u_scale_b);
-MBGL_DEFINE_UNIFORM_SCALAR(float,    u_tile_units_to_pixels);
-MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pixel_coord_upper);
-MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pixel_coord_lower);
-} // namespace uniforms
-
 struct FillLayoutAttributes : gl::Attributes<
     attributes::a_pos>
 {};
diff --git a/src/mbgl/programs/programs.hpp b/src/mbgl/programs/programs.hpp
index dbf5b9e87d..ff6b1cd505 100644
--- a/src/mbgl/programs/programs.hpp
+++ b/src/mbgl/programs/programs.hpp
@@ -1,7 +1,9 @@
 #pragma once
 
 #include <mbgl/programs/circle_program.hpp>
+#include <mbgl/programs/extrusion_texture_program.hpp>
 #include <mbgl/programs/fill_program.hpp>
+#include <mbgl/programs/fill_extrusion_program.hpp>
 #include <mbgl/programs/line_program.hpp>
 #include <mbgl/programs/raster_program.hpp>
 #include <mbgl/programs/symbol_program.hpp>
@@ -15,7 +17,10 @@ class Programs {
 public:
     Programs(gl::Context& context, const ProgramParameters& programParameters)
         : circle(context, programParameters),
+          extrusionTexture(context, programParameters),
           fill(context, programParameters),
+          fillExtrusion(context, programParameters),
+          fillExtrusionPattern(context, programParameters),
           fillPattern(context, programParameters),
           fillOutline(context, programParameters),
           fillOutlinePattern(context, programParameters),
@@ -31,7 +36,10 @@ public:
     }
 
     CircleProgram circle;
+    ExtrusionTextureProgram extrusionTexture;
     FillProgram fill;
+    FillExtrusionProgram fillExtrusion;
+    FillExtrusionPatternProgram fillExtrusionPattern;
     FillPatternProgram fillPattern;
     FillOutlineProgram fillOutline;
     FillOutlinePatternProgram fillOutlinePattern;
diff --git a/src/mbgl/programs/uniforms.hpp b/src/mbgl/programs/uniforms.hpp
index e0c5a0d361..972405d5a9 100644
--- a/src/mbgl/programs/uniforms.hpp
+++ b/src/mbgl/programs/uniforms.hpp
@@ -17,6 +17,8 @@ MBGL_DEFINE_UNIFORM_SCALAR(float, u_zoom);
 MBGL_DEFINE_UNIFORM_SCALAR(float, u_pitch);
 MBGL_DEFINE_UNIFORM_SCALAR(float, u_bearing);
 
+MBGL_DEFINE_UNIFORM_SCALAR(Size, u_world);
+
 MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_extrude_scale);
 
 MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pattern_tl_a);
@@ -25,9 +27,14 @@ MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pattern_tl_b);
 MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pattern_br_b);
 MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pattern_size_a);
 MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pattern_size_b);
+MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pixel_coord_upper);
+MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_pixel_coord_lower);
 
 MBGL_DEFINE_UNIFORM_SCALAR(float, u_mix);
 MBGL_DEFINE_UNIFORM_SCALAR(gl::TextureUnit, u_image);
+MBGL_DEFINE_UNIFORM_SCALAR(float,    u_scale_a);
+MBGL_DEFINE_UNIFORM_SCALAR(float,    u_scale_b);
+MBGL_DEFINE_UNIFORM_SCALAR(float,    u_tile_units_to_pixels);
 
 } // namespace uniforms
 } // namespace mbgl