Merge branch 'master' of github.com:mapbox/mapbox-gl-native

Makefile

@@ -11,13 +11,10 @@ config-ios.gypi:
 	MASON_PLATFORM=ios ./configure config-ios.gypi
 
 # Builds the regular library
-mbgl: config.gypi mapboxgl.gyp node
+mbgl: config.gypi mapboxgl.gyp
 	deps/run_gyp mapboxgl.gyp -Iconfig.gypi --depth=. -Goutput_dir=.. --generator-output=./build/mbgl -f make
 	$(MAKE) -C build/mbgl BUILDTYPE=$(BUILDTYPE) V=$(V) mapboxgl
 
-node:
-	@if [ ! `which node` ]; then echo 'error: depends on node.js. please make sure node is on your PATH'; exit 1; fi;
-
 ##### Test cases ###############################################################
 
 build/test/Makefile: src common config.gypi test/test.gyp
@@ -31,7 +28,7 @@ test_%: build/test/Makefile
 	(cd build/$(BUILDTYPE) && exec ./test_$*)
 
 # build Mac OS X project for Xcode
-xtest: config.gypi clear_xcode_cache node
+xtest: config.gypi clear_xcode_cache
 	deps/run_gyp test/test.gyp -Iconfig.gypi --depth=. -Goutput_dir=.. --generator-output=./build -f xcode
 	open ./build/test/test.xcodeproj
 
@@ -39,7 +36,7 @@ xtest: config.gypi clear_xcode_cache node
 
 
 # Builds the linux app with make.
-linux: config.gypi linux/mapboxgl-app.gyp node
+linux: config.gypi linux/mapboxgl-app.gyp
 	deps/run_gyp linux/mapboxgl-app.gyp -Iconfig.gypi --depth=. -Goutput_dir=.. --generator-output=./build/linux -f make
 	$(MAKE) -C build/linux BUILDTYPE=$(BUILDTYPE) V=$(V) linuxapp
 
@@ -50,7 +47,7 @@ run-linux: linux
 
 
 # Builds the OS X app with make.
-osx: config.gypi macosx/mapboxgl-app.gyp node
+osx: config.gypi macosx/mapboxgl-app.gyp
 	deps/run_gyp macosx/mapboxgl-app.gyp -Iconfig.gypi --depth=. -Goutput_dir=.. --generator-output=./build/macosx -f make
 	$(MAKE) -C build/macosx BUILDTYPE=$(BUILDTYPE) V=$(V) osxapp
 
@@ -72,21 +69,21 @@ clear_xcode_cache:
     fi
 
 # build Mac OS X project for Xcode
-xproj-cli: config.gypi macosx/mapboxgl-app.gyp clear_xcode_cache node
+xproj-cli: config.gypi macosx/mapboxgl-app.gyp clear_xcode_cache
 	deps/run_gyp macosx/mapboxgl-app.gyp -Iconfig.gypi --depth=. --generator-output=./build -f xcode
 
 xproj: xproj-cli
 	open ./build/macosx/mapboxgl-app.xcodeproj
 
 # build iOS project for Xcode
-iproj-cli: config-ios.gypi ios/mapbox-gl-cocoa/app/mapboxgl-app.gyp clear_xcode_cache node
+iproj-cli: config-ios.gypi ios/mapbox-gl-cocoa/app/mapboxgl-app.gyp clear_xcode_cache
 	deps/run_gyp ios/mapbox-gl-cocoa/app/mapboxgl-app.gyp -Iconfig-ios.gypi --depth=. --generator-output=./build -f xcode
 
 iproj: iproj-cli
 	open ./build/ios/mapbox-gl-cocoa/app/mapboxgl-app.xcodeproj
 
 # build Linux project for Xcode (Runs on Mac OS X too, but without platform-specific code)
-lproj: config.gypi linux/mapboxgl-app.gyp clear_xcode_cache node
+lproj: config.gypi linux/mapboxgl-app.gyp clear_xcode_cache
 	deps/run_gyp linux/mapboxgl-app.gyp -Iconfig.gypi --depth=. --generator-output=./build -f xcode
 	open ./build/linux/mapboxgl-app.xcodeproj
 

README.md

@@ -1,4 +1,4 @@
-[![Travis](https://api.travis-ci.org/mapbox/mapbox-gl-native.svg)](https://travis-ci.org/mapbox/mapbox-gl-native/builds)
+[![Travis](https://api.travis-ci.org/mapbox/mapbox-gl-native.svg?branch=master)](https://travis-ci.org/mapbox/mapbox-gl-native/builds)
 
 An OpenGL renderer for [Mapbox Vector Tiles](https://www.mapbox.com/blog/vector-tiles),
 implemented in C++11, currently targeting iOS, OS X, and Ubuntu Linux.

include/mbgl/map/transform_state.hpp

@@ -29,10 +29,16 @@ public:
     const std::array<uint16_t, 2> getFramebufferDimensions() const;
     float getPixelRatio() const;
 
+    float worldSize() const;
+    float lngX(float lon) const;
+    float latY(float lat) const;
+    std::array<float, 2> locationCoordinate(float lon, float lat) const;
+
     // Zoom
     float getNormalizedZoom() const;
-    int32_t getIntegerZoom() const;
     double getZoom() const;
+    int32_t getIntegerZoom() const;
+    double getZoomFraction() const;
     double getScale() const;
 
     // Rotation

include/mbgl/platform/event.hpp

@@ -57,14 +57,13 @@ struct EventPermutation {
     }
 };
 
-#if !DEBUG
 constexpr EventSeverity disabledEventSeverities[] = {
-    EventSeverity::Debug,
-};
+#if DEBUG
+    EventSeverity(-1) // Avoid zero size array
 #else
-constexpr EventSeverity *disabledEventSeverities = nullptr;
+    EventSeverity::Debug
 #endif
-
+};
 
 constexpr Event disabledEvents[] = {
     Event(-1) // Avoid zero size array

include/mbgl/platform/log.hpp

@@ -19,9 +19,9 @@ public:
 
 class Log {
 private:
-    template <typename T>
-    constexpr static bool includes(const T e, T const *l, const size_t i = 0) {
-        return l == nullptr ? false : i >= sizeof l ? false : *(l + i) == e ? true : includes(e, l, i + 1);
+    template <typename T, size_t N>
+    constexpr static bool includes(const T e, const T (&l)[N], const size_t i = 0) {
+        return i < N && (l[i] == e || includes(e, l, i + 1));
     }
 
 public:

include/mbgl/style/property_key.hpp

@@ -61,7 +61,8 @@ enum class PropertyKey {
     RasterFade,
 
     BackgroundOpacity,
-    BackgroundColor
+    BackgroundColor,
+    BackgroundImage
 };
 
 }

include/mbgl/style/style_properties.hpp

@@ -94,6 +94,7 @@ struct BackgroundProperties {
     inline BackgroundProperties() {}
     float opacity = 1.0f;
     Color color = {{ 0, 0, 0, 1 }};
+    std::string image;
 };
 
 typedef mapbox::util::variant<

include/mbgl/util/mat3.hpp

@@ -32,6 +32,8 @@ typedef std::array<float, 9> mat3;
 namespace matrix {
 
 void identity(mat3& out);
+void translate(mat3& out, const mat3& a, float x, float y);
+void rotate(mat3& out, const mat3& a, float rad);
 void scale(mat3& out, const mat3& a, float x, float y);
 
 }

src/map/transform_state.cpp

@@ -83,11 +83,31 @@ const std::array<uint16_t, 2> TransformState::getFramebufferDimensions() const {
     return framebuffer;
 }
 
-
 float TransformState::getPixelRatio() const {
     return pixelRatio;
 }
 
+float TransformState::worldSize() const {
+    return scale * util::tileSize;
+}
+
+float TransformState::lngX(float lon) const {
+    return (180 + lon) * worldSize() / 360;
+}
+
+float TransformState::latY(float lat) const {
+    float y = 180 / M_PI * std::log(std::tan(M_PI / 4 + lat * M_PI / 360));
+    return (180 - y) * worldSize() / 360;
+}
+
+std::array<float, 2> TransformState::locationCoordinate(float lon, float lat) const {
+    float k = std::pow(2, getIntegerZoom()) / worldSize();
+    return {{
+        lngX(lon) * k,
+        latY(lat) * k
+    }};
+}
+
 
 #pragma mark - Zoom
 
@@ -95,12 +115,16 @@ float TransformState::getNormalizedZoom() const {
     return std::log(scale * util::tileSize / 512.0f) / M_LN2;
 }
 
+double TransformState::getZoom() const {
+    return std::log(scale) / M_LN2;
+}
+
 int32_t TransformState::getIntegerZoom() const {
     return std::floor(getZoom());
 }
 
-double TransformState::getZoom() const {
-    return std::log(scale) / M_LN2;
+double TransformState::getZoomFraction() const {
+    return getZoom() - getIntegerZoom();
 }
 
 double TransformState::getScale() const {

src/renderer/painter.cpp

@@ -7,6 +7,9 @@
 #include <mbgl/util/time.hpp>
 #include <mbgl/util/clip_ids.hpp>
 #include <mbgl/util/constants.hpp>
+#include <mbgl/util/mat3.hpp>
+#include <mbgl/geometry/sprite_atlas.hpp>
+
 #if defined(DEBUG)
 #include <mbgl/util/timer.hpp>
 #endif
@@ -208,24 +211,66 @@ void Painter::renderTileLayer(const Tile& tile, util::ptr<StyleLayer> layer_desc
 
 void Painter::renderBackground(util::ptr<StyleLayer> layer_desc) {
     const BackgroundProperties& properties = layer_desc->getProperties<BackgroundProperties>();
+    const std::shared_ptr<Sprite> sprite = map.getSprite();
 
-    Color color = properties.color;
-    color[0] *= properties.opacity;
-    color[1] *= properties.opacity;
-    color[2] *= properties.opacity;
-    color[3] *= properties.opacity;
+    if (properties.image.size() && sprite) {
+        if ((properties.opacity >= 1.0f) != (pass == RenderPass::Opaque))
+            return;
+
+        SpriteAtlas &spriteAtlas = *map.getSpriteAtlas();
+        SpriteAtlasPosition imagePos = spriteAtlas.getPosition(properties.image, *sprite, true);
+        float zoomFraction = map.getState().getZoomFraction();
+
+        useProgram(patternShader->program);
+        patternShader->u_matrix = identityMatrix;
+        patternShader->u_pattern_tl = imagePos.tl;
+        patternShader->u_pattern_br = imagePos.br;
+        patternShader->u_mix = zoomFraction;
+        patternShader->u_opacity = properties.opacity;
+
+        std::array<float, 2> size = imagePos.size;
+        double lon, lat;
+        map.getLonLat(lon, lat);
+        std::array<float, 2> center = map.getState().locationCoordinate(lon, lat);
+        float scale = 1 / std::pow(2, zoomFraction);
+
+        mat3 matrix;
+        matrix::identity(matrix);
+        matrix::scale(matrix, matrix,
+                      1.0f / size[0],
+                      1.0f / size[1]);
+        matrix::translate(matrix, matrix,
+                          std::fmod(center[0] * 512, size[0]),
+                          std::fmod(center[1] * 512, size[1]));
+        matrix::rotate(matrix, matrix, -map.getState().getAngle());
+        matrix::scale(matrix, matrix,
+                       scale * map.getState().getWidth()  / 2,
+                      -scale * map.getState().getHeight() / 2);
+        patternShader->u_patternmatrix = matrix;
+
+        backgroundBuffer.bind();
+        patternShader->bind(0);
+        spriteAtlas.bind(true);
+    } else {
+        Color color = properties.color;
+        color[0] *= properties.opacity;
+        color[1] *= properties.opacity;
+        color[2] *= properties.opacity;
+        color[3] *= properties.opacity;
+
+        if ((color[3] >= 1.0f) != (pass == RenderPass::Opaque))
+            return;
 
-    if ((color[3] >= 1.0f) == (pass == RenderPass::Opaque)) {
         useProgram(plainShader->program);
         plainShader->u_matrix = identityMatrix;
         plainShader->u_color = color;
         backgroundArray.bind(*plainShader, backgroundBuffer, BUFFER_OFFSET(0));
-
-        glDisable(GL_STENCIL_TEST);
-        depthRange(strata + strata_epsilon, 1.0f);
-        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-        glEnable(GL_STENCIL_TEST);
     }
+
+    glDisable(GL_STENCIL_TEST);
+    depthRange(strata + strata_epsilon, 1.0f);
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+    glEnable(GL_STENCIL_TEST);
 }
 
 mat4 Painter::translatedMatrix(const mat4& matrix, const std::array<float, 2> &translation, const Tile::ID &id, TranslateAnchorType anchor) {

src/style/style_layer.cpp

@@ -235,6 +235,7 @@ void StyleLayer::applyStyleProperties<BackgroundProperties>(const float z, const
     BackgroundProperties &background = properties.get<BackgroundProperties>();
     applyTransitionedStyleProperty(PropertyKey::BackgroundOpacity, background.opacity, z, now);
     applyTransitionedStyleProperty(PropertyKey::BackgroundColor, background.color, z, now);
+    applyStyleProperty(PropertyKey::BackgroundImage, background.image, z, now);
 }
 
 void StyleLayer::updateProperties(float z, const timestamp now) {

src/style/style_parser.cpp

@@ -640,6 +640,7 @@ void StyleParser::parseStyle(JSVal value, ClassProperties &klass) {
 
     parseOptionalProperty<Function<float>>("background-opacity", Key::BackgroundOpacity, klass, value);
     parseOptionalProperty<Function<Color>>("background-color", Key::BackgroundColor, klass, value);
+    parseOptionalProperty<std::string>("background-image", Key::BackgroundImage, klass, value);
 }
 
 void StyleParser::parseReference(JSVal value, util::ptr<StyleLayer> &layer) {

src/util/mat3.cpp

@@ -38,7 +38,51 @@ void matrix::identity(mat3& out) {
     out[8] = 1.0f;
 }
 
-void matrix::scale(mat3& out, const mat3& a, const float x, const float y) {
+void matrix::translate(mat3& out, const mat3& a, float x, float y) {
+    float a00 = a[0], a01 = a[1], a02 = a[2],
+          a10 = a[3], a11 = a[4], a12 = a[5],
+          a20 = a[6], a21 = a[7], a22 = a[8];
+
+    out[0] = a00;
+    out[1] = a01;
+    out[2] = a02;
+
+    out[3] = a10;
+    out[4] = a11;
+    out[5] = a12;
+
+    out[6] = x * a00 + y * a10 + a20;
+    out[7] = x * a01 + y * a11 + a21;
+    out[8] = x * a02 + y * a12 + a22;
+}
+
+void matrix::rotate(mat3& out, const mat3& a, float rad) {
+    float s = std::sin(rad),
+          c = std::cos(rad),
+          a00 = a[0],
+          a01 = a[1],
+          a02 = a[2],
+          a10 = a[3],
+          a11 = a[4],
+          a12 = a[5],
+          a20 = a[6],
+          a21 = a[7],
+          a22 = a[8];
+
+    out[0] = c * a00 + s * a10;
+    out[1] = c * a01 + s * a11;
+    out[2] = c * a02 + s * a12;
+
+    out[3] = c * a10 - s * a00;
+    out[4] = c * a11 - s * a01;
+    out[5] = c * a12 - s * a02;
+
+    out[6] = a20;
+    out[7] = a21;
+    out[8] = a22;
+};
+
+void matrix::scale(mat3& out, const mat3& a, float x, float y) {
     out[0] = x * a[0];
     out[1] = x * a[1];
     out[2] = x * a[2];

test/fixtures/fixture_request.cpp

@@ -55,7 +55,7 @@ void HTTPRequestBaton::start(const util::ptr<HTTPRequestBaton> &baton) {
     uv_async_send(baton->async);
 }
 
-void HTTPRequestBaton::stop(const util::ptr<HTTPRequestBaton> &) {
+void HTTPRequestBaton::stop(const util::ptr<HTTPRequestBaton> &/*baton*/) {
     fprintf(stderr, "HTTP request cannot be canceled because it is answered immediately");
     abort();
 }