[core] Separate pattern size from draw-time variables

Part of https://github.com/mapbox/mapbox-gl-shaders/issues/1.

6 files changed, 65 insertions, 103 deletions

diff --git a/package.json b/package.json
index ff341ffc7c..1b0da8c4df 100644
--- a/package.json
+++ b/package.json
@@ -21,9 +21,9 @@
     "csscolorparser": "^1.0.2",
     "ejs": "^2.4.1",
     "express": "^4.11.1",
-    "mapbox-gl-shaders": "mapbox/mapbox-gl-shaders#09ee512cd59a8fb1a241c78833b7c8022bf4f263",
+    "mapbox-gl-shaders": "mapbox/mapbox-gl-shaders#59e998295d548f208ee3ec10cdd21ff2630e2079",
     "mapbox-gl-style-spec": "mapbox/mapbox-gl-style-spec#2461efc3d883f2f2e56a6c6b2bfd7d54bbfe9f86",
-    "mapbox-gl-test-suite": "mapbox/mapbox-gl-test-suite#ce8146c048487dab444d92ce06ef0b0ca8515c73",
+    "mapbox-gl-test-suite": "mapbox/mapbox-gl-test-suite#3d06b422b1aa81aec71b4c67128f3d947205d6af",
     "node-gyp": "^3.3.1",
     "request": "^2.72.0",
     "tape": "^4.5.1"
diff --git a/src/mbgl/map/transform_state.hpp b/src/mbgl/map/transform_state.hpp
index 0489b69dd4..83e4f64b07 100644
--- a/src/mbgl/map/transform_state.hpp
+++ b/src/mbgl/map/transform_state.hpp
@@ -72,6 +72,9 @@ public:
     Point<double> project(const LatLng&) const;
     LatLng unproject(const Point<double>&, double worldSize, LatLng::WrapMode = LatLng::Unwrapped) const;
 
+    double zoomScale(double zoom) const;
+    double scaleZoom(double scale) const;
+
 private:
     bool rotatedNorth() const;
     void constrain(double& scale, double& x, double& y) const;
@@ -85,8 +88,6 @@ private:
     // logical dimensions
     uint16_t width = 0, height = 0;
 
-    double zoomScale(double zoom) const;
-    double scaleZoom(double scale) const;
     double worldSize() const;
 
     mat4 coordinatePointMatrix(double z) const;
diff --git a/src/mbgl/renderer/painter_background.cpp b/src/mbgl/renderer/painter_background.cpp
index 402d0d23ba..43e0b4c7c8 100644
--- a/src/mbgl/renderer/painter_background.cpp
+++ b/src/mbgl/renderer/painter_background.cpp
@@ -71,37 +71,17 @@ void Painter::renderBackground(const BackgroundLayer& layer) {
 
         if (isPatterned) {
             patternShader->u_matrix = vtxMatrix;
-
-            std::array<int, 2> imageSizeScaledA = {{
-                (int)((*imagePosA).size[0] * properties.backgroundPattern.value.fromScale),
-                (int)((*imagePosA).size[1] * properties.backgroundPattern.value.fromScale)
-            }};
-            std::array<int, 2> imageSizeScaledB = {{
-                (int)((*imagePosB).size[0] * properties.backgroundPattern.value.toScale),
-                (int)((*imagePosB).size[1] * properties.backgroundPattern.value.toScale)
-            }};
-
-            patternShader->u_patternscale_a = {{
-                1.0f / id.pixelsToTileUnits(imageSizeScaledA[0], state.getIntegerZoom()),
-                1.0f / id.pixelsToTileUnits(imageSizeScaledA[1], state.getIntegerZoom())
-            }};
-            patternShader->u_patternscale_b = {{
-                1.0f / id.pixelsToTileUnits(imageSizeScaledB[0], state.getIntegerZoom()),
-                1.0f / id.pixelsToTileUnits(imageSizeScaledB[1], state.getIntegerZoom())
-            }};
-
-            float offsetAx = (std::fmod(util::tileSize, imageSizeScaledA[0]) * id.canonical.x) /
-                             (float)imageSizeScaledA[0];
-            float offsetAy = (std::fmod(util::tileSize, imageSizeScaledA[1]) * id.canonical.y) /
-                             (float)imageSizeScaledA[1];
-
-            float offsetBx = (std::fmod(util::tileSize, imageSizeScaledB[0]) * id.canonical.x) /
-                             (float)imageSizeScaledB[0];
-            float offsetBy = (std::fmod(util::tileSize, imageSizeScaledB[1]) * id.canonical.y) /
-                             (float)imageSizeScaledB[1];
-
-            patternShader->u_offset_a = std::array<float, 2>{{offsetAx, offsetAy}};
-            patternShader->u_offset_b = std::array<float, 2>{{offsetBx, offsetBy}};
+            patternShader->u_pattern_size_a = imagePosA->size;
+            patternShader->u_pattern_size_b = imagePosB->size;
+            patternShader->u_scale_a = properties.backgroundPattern.value.fromScale;
+            patternShader->u_scale_b = properties.backgroundPattern.value.toScale;
+            patternShader->u_tile_units_to_pixels = 1.0f / id.pixelsToTileUnits(1.0f, state.getIntegerZoom());
+
+            GLint tileSizeAtNearestZoom = util::tileSize * state.zoomScale(state.getIntegerZoom() - id.canonical.z);
+            GLint pixelX = tileSizeAtNearestZoom * (id.canonical.x + id.wrap * state.zoomScale(id.canonical.z));
+            GLint pixelY = tileSizeAtNearestZoom * id.canonical.y;
+            patternShader->u_pixel_coord_upper = {{ float(pixelX >> 16), float(pixelY >> 16) }};
+            patternShader->u_pixel_coord_lower = {{ float(pixelX & 0xFFFF), float(pixelY & 0xFFFF) }};
         } else {
             plainShader->u_matrix = vtxMatrix;
         }
diff --git a/src/mbgl/renderer/painter_fill.cpp b/src/mbgl/renderer/painter_fill.cpp
index d99069c6b3..3bf30362c6 100644
--- a/src/mbgl/renderer/painter_fill.cpp
+++ b/src/mbgl/renderer/painter_fill.cpp
@@ -82,37 +82,17 @@ void Painter::renderFill(FillBucket& bucket,
             patternShader->u_opacity = properties.fillOpacity;
             patternShader->u_image = 0;
             patternShader->u_mix = properties.fillPattern.value.t;
-
-            std::array<int, 2> imageSizeScaledA = {{
-                (int)((*posA).size[0] * properties.fillPattern.value.fromScale),
-                (int)((*posA).size[1] * properties.fillPattern.value.fromScale)
-            }};
-            std::array<int, 2> imageSizeScaledB = {{
-                (int)((*posB).size[0] * properties.fillPattern.value.toScale),
-                (int)((*posB).size[1] * properties.fillPattern.value.toScale)
-            }};
-
-            patternShader->u_patternscale_a = {
-                { 1.0f / tileID.pixelsToTileUnits(imageSizeScaledA[0], state.getIntegerZoom()),
-                  1.0f / tileID.pixelsToTileUnits(imageSizeScaledB[1], state.getIntegerZoom()) }
-            };
-            patternShader->u_patternscale_b = {
-                { 1.0f / tileID.pixelsToTileUnits(imageSizeScaledB[0], state.getIntegerZoom()),
-                  1.0f / tileID.pixelsToTileUnits(imageSizeScaledB[1], state.getIntegerZoom()) }
-            };
-
-            float offsetAx = (std::fmod(util::tileSize, imageSizeScaledA[0]) * tileID.canonical.x) /
-                             (float)imageSizeScaledA[0];
-            float offsetAy = (std::fmod(util::tileSize, imageSizeScaledA[1]) * tileID.canonical.y) /
-                             (float)imageSizeScaledA[1];
-
-            float offsetBx = (std::fmod(util::tileSize, imageSizeScaledB[0]) * tileID.canonical.x) /
-                             (float)imageSizeScaledB[0];
-            float offsetBy = (std::fmod(util::tileSize, imageSizeScaledB[1]) * tileID.canonical.y) /
-                             (float)imageSizeScaledB[1];
-
-            patternShader->u_offset_a = std::array<float, 2>{{offsetAx, offsetAy}};
-            patternShader->u_offset_b = std::array<float, 2>{{offsetBx, offsetBy}};
+            patternShader->u_pattern_size_a = imagePosA->size;
+            patternShader->u_pattern_size_b = imagePosB->size;
+            patternShader->u_scale_a = properties.fillPattern.value.fromScale;
+            patternShader->u_scale_b = properties.fillPattern.value.toScale;
+            patternShader->u_tile_units_to_pixels = 1.0f / tileID.pixelsToTileUnits(1.0f, state.getIntegerZoom());
+
+            GLint tileSizeAtNearestZoom = util::tileSize * state.zoomScale(state.getIntegerZoom() - tileID.canonical.z);
+            GLint pixelX = tileSizeAtNearestZoom * (tileID.canonical.x + tileID.wrap * state.zoomScale(tileID.canonical.z));
+            GLint pixelY = tileSizeAtNearestZoom * tileID.canonical.y;
+            patternShader->u_pixel_coord_upper = {{ float(pixelX >> 16), float(pixelY >> 16) }};
+            patternShader->u_pixel_coord_lower = {{ float(pixelX & 0xFFFF), float(pixelY & 0xFFFF) }};
 
             config.activeTexture = GL_TEXTURE0;
             spriteAtlas->bind(true, store);
@@ -139,18 +119,13 @@ void Painter::renderFill(FillBucket& bucket,
                 outlinePatternShader->u_opacity = properties.fillOpacity;
                 outlinePatternShader->u_image = 0;
                 outlinePatternShader->u_mix = properties.fillPattern.value.t;
-
-                outlinePatternShader->u_patternscale_a = {{
-                    1.0f / tileID.pixelsToTileUnits(imageSizeScaledA[0], state.getIntegerZoom()),
-                    1.0f / tileID.pixelsToTileUnits(imageSizeScaledB[1], state.getIntegerZoom())
-                }};
-                outlinePatternShader->u_patternscale_b = {{
-                    1.0f / tileID.pixelsToTileUnits(imageSizeScaledB[0], state.getIntegerZoom()),
-                    1.0f / tileID.pixelsToTileUnits(imageSizeScaledB[1], state.getIntegerZoom())
-                }};
-
-                outlinePatternShader->u_offset_a = std::array<float, 2>{{offsetAx, offsetAy}};
-                outlinePatternShader->u_offset_b = std::array<float, 2>{{offsetBx, offsetBy}};
+                outlinePatternShader->u_pattern_size_a = imagePosA->size;
+                outlinePatternShader->u_pattern_size_b = imagePosB->size;
+                outlinePatternShader->u_scale_a = properties.fillPattern.value.fromScale;
+                outlinePatternShader->u_scale_b = properties.fillPattern.value.toScale;
+                outlinePatternShader->u_tile_units_to_pixels = 1.0f / tileID.pixelsToTileUnits(1.0f, state.getIntegerZoom());
+                outlinePatternShader->u_pixel_coord_upper = {{ float(pixelX >> 16), float(pixelY >> 16) }};
+                outlinePatternShader->u_pixel_coord_lower = {{ float(pixelX & 0xFFFF), float(pixelY & 0xFFFF) }};
 
                 config.activeTexture = GL_TEXTURE0;
                 spriteAtlas->bind(true, store);
diff --git a/src/mbgl/shader/outlinepattern_shader.hpp b/src/mbgl/shader/outlinepattern_shader.hpp
index e124923b6f..1eb805ffae 100644
--- a/src/mbgl/shader/outlinepattern_shader.hpp
+++ b/src/mbgl/shader/outlinepattern_shader.hpp
@@ -11,19 +11,22 @@ public:
 
     void bind(GLbyte *offset) final;
 
-    UniformMatrix<4>                u_matrix          = {"u_matrix",          *this};
-    Uniform<std::array<GLfloat, 2>> u_pattern_tl_a    = {"u_pattern_tl_a",    *this};
-    Uniform<std::array<GLfloat, 2>> u_pattern_br_a    = {"u_pattern_br_a",    *this};
-    Uniform<std::array<GLfloat, 2>> u_pattern_tl_b    = {"u_pattern_tl_b",    *this};
-    Uniform<std::array<GLfloat, 2>> u_pattern_br_b    = {"u_pattern_br_b",    *this};
-    Uniform<GLfloat>                u_opacity         = {"u_opacity",         *this};
-    Uniform<GLfloat>                u_mix             = {"u_mix",             *this};
-    Uniform<GLint>                  u_image           = {"u_image",           *this};
-    Uniform<std::array<GLfloat, 2>> u_patternscale_a  = {"u_patternscale_a",  *this};
-    Uniform<std::array<GLfloat, 2>> u_patternscale_b  = {"u_patternscale_b",  *this};
-    Uniform<std::array<GLfloat, 2>> u_offset_a        = {"u_offset_a",        *this};
-    Uniform<std::array<GLfloat, 2>> u_offset_b        = {"u_offset_b",        *this};
-    Uniform<std::array<GLfloat, 2>> u_world           = {"u_world",           *this};
+    UniformMatrix<4>                u_matrix               = {"u_matrix",               *this};
+    Uniform<std::array<GLfloat, 2>> u_pattern_tl_a         = {"u_pattern_tl_a",         *this};
+    Uniform<std::array<GLfloat, 2>> u_pattern_br_a         = {"u_pattern_br_a",         *this};
+    Uniform<std::array<GLfloat, 2>> u_pattern_tl_b         = {"u_pattern_tl_b",         *this};
+    Uniform<std::array<GLfloat, 2>> u_pattern_br_b         = {"u_pattern_br_b",         *this};
+    Uniform<GLfloat>                u_opacity              = {"u_opacity",              *this};
+    Uniform<GLfloat>                u_mix                  = {"u_mix",                  *this};
+    Uniform<GLfloat>                u_scale_a              = {"u_scale_a",              *this};
+    Uniform<GLfloat>                u_scale_b              = {"u_scale_b",              *this};
+    Uniform<GLfloat>                u_tile_units_to_pixels = {"u_tile_units_to_pixels", *this};
+    Uniform<GLint>                  u_image                = {"u_image",                *this};
+    Uniform<std::array<GLfloat, 2>> u_pattern_size_a       = {"u_pattern_size_a",       *this};
+    Uniform<std::array<GLfloat, 2>> u_pattern_size_b       = {"u_pattern_size_b",       *this};
+    Uniform<std::array<GLfloat, 2>> u_pixel_coord_upper    = {"u_pixel_coord_upper",    *this};
+    Uniform<std::array<GLfloat, 2>> u_pixel_coord_lower    = {"u_pixel_coord_lower",    *this};
+    Uniform<std::array<GLfloat, 2>> u_world                = {"u_world",                *this};
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/shader/pattern_shader.hpp b/src/mbgl/shader/pattern_shader.hpp
index ae515c1948..2a6eb45ddb 100644
--- a/src/mbgl/shader/pattern_shader.hpp
+++ b/src/mbgl/shader/pattern_shader.hpp
@@ -11,18 +11,21 @@ public:
 
     void bind(GLbyte *offset) final;
 
-    UniformMatrix<4>                u_matrix          = {"u_matrix",          *this};
-    Uniform<std::array<GLfloat, 2>> u_pattern_tl_a    = {"u_pattern_tl_a",    *this};
-    Uniform<std::array<GLfloat, 2>> u_pattern_br_a    = {"u_pattern_br_a",    *this};
-    Uniform<std::array<GLfloat, 2>> u_pattern_tl_b    = {"u_pattern_tl_b",    *this};
-    Uniform<std::array<GLfloat, 2>> u_pattern_br_b    = {"u_pattern_br_b",    *this};
-    Uniform<GLfloat>                u_opacity         = {"u_opacity",         *this};
-    Uniform<GLfloat>                u_mix             = {"u_mix",             *this};
-    Uniform<GLint>                  u_image           = {"u_image",           *this};
-    Uniform<std::array<GLfloat, 2>> u_patternscale_a  = {"u_patternscale_a",  *this};
-    Uniform<std::array<GLfloat, 2>> u_patternscale_b  = {"u_patternscale_b",  *this};
-    Uniform<std::array<GLfloat, 2>> u_offset_a        = {"u_offset_a",        *this};
-    Uniform<std::array<GLfloat, 2>> u_offset_b        = {"u_offset_b",        *this};
+    UniformMatrix<4>                u_matrix               = {"u_matrix",               *this};
+    Uniform<std::array<GLfloat, 2>> u_pattern_tl_a         = {"u_pattern_tl_a",         *this};
+    Uniform<std::array<GLfloat, 2>> u_pattern_br_a         = {"u_pattern_br_a",         *this};
+    Uniform<std::array<GLfloat, 2>> u_pattern_tl_b         = {"u_pattern_tl_b",         *this};
+    Uniform<std::array<GLfloat, 2>> u_pattern_br_b         = {"u_pattern_br_b",         *this};
+    Uniform<GLfloat>                u_opacity              = {"u_opacity",              *this};
+    Uniform<GLfloat>                u_mix                  = {"u_mix",                  *this};
+    Uniform<GLfloat>                u_scale_a              = {"u_scale_a",              *this};
+    Uniform<GLfloat>                u_scale_b              = {"u_scale_b",              *this};
+    Uniform<GLfloat>                u_tile_units_to_pixels = {"u_tile_units_to_pixels", *this};
+    Uniform<GLint>                  u_image                = {"u_image",                *this};
+    Uniform<std::array<GLfloat, 2>> u_pattern_size_a       = {"u_pattern_size_a",       *this};
+    Uniform<std::array<GLfloat, 2>> u_pattern_size_b       = {"u_pattern_size_b",       *this};
+    Uniform<std::array<GLfloat, 2>> u_pixel_coord_upper    = {"u_pixel_coord_upper",    *this};
+    Uniform<std::array<GLfloat, 2>> u_pixel_coord_lower    = {"u_pixel_coord_lower",    *this};
 };
 
 } // namespace mbgl