[core] Fix overdraw mode on Linux

- Use glBindAttribLocation for GLSL attributes.
- Create a separate shader for each shader that supports overdraw.
  Needed because each uniform location must be known for every program.
- Create a separate VAO for each shader inside buckets.
  Needed because we can only bind a VAO to a specific shader.

Fixes #5435.

1 files changed, 25 insertions, 22 deletions

diff --git a/src/mbgl/renderer/painter_background.cpp b/src/mbgl/renderer/painter_background.cpp
index 7ced6a5c4f..507d5f0f22 100644
--- a/src/mbgl/renderer/painter_background.cpp
+++ b/src/mbgl/renderer/painter_background.cpp
@@ -21,6 +21,9 @@ void Painter::renderBackground(const BackgroundLayer& layer) {
     optional<SpriteAtlasPosition> imagePosA;
     optional<SpriteAtlasPosition> imagePosB;
 
+    const auto& shaderPattern = isOverdraw() ? patternOverdrawShader : patternShader;
+    const auto& shaderPlain = isOverdraw() ? plainOverdrawShader : plainShader;
+
     if (isPatterned) {
         imagePosA = spriteAtlas->getPosition(properties.backgroundPattern.value.from, true);
         imagePosB = spriteAtlas->getPosition(properties.backgroundPattern.value.to, true);
@@ -28,24 +31,24 @@ void Painter::renderBackground(const BackgroundLayer& layer) {
         if (!imagePosA || !imagePosB)
             return;
 
-        config.program = isOverdraw() ? patternShader->getOverdrawID() : patternShader->getID();
-        patternShader->u_matrix = identityMatrix;
-        patternShader->u_pattern_tl_a = imagePosA->tl;
-        patternShader->u_pattern_br_a = imagePosA->br;
-        patternShader->u_pattern_tl_b = imagePosB->tl;
-        patternShader->u_pattern_br_b = imagePosB->br;
-        patternShader->u_mix = properties.backgroundPattern.value.t;
-        patternShader->u_opacity = properties.backgroundOpacity;
+        config.program = shaderPattern->getID();
+        shaderPattern->u_matrix = identityMatrix;
+        shaderPattern->u_pattern_tl_a = imagePosA->tl;
+        shaderPattern->u_pattern_br_a = imagePosA->br;
+        shaderPattern->u_pattern_tl_b = imagePosB->tl;
+        shaderPattern->u_pattern_br_b = imagePosB->br;
+        shaderPattern->u_mix = properties.backgroundPattern.value.t;
+        shaderPattern->u_opacity = properties.backgroundOpacity;
 
         spriteAtlas->bind(true, store);
-        backgroundPatternArray.bind(*patternShader, tileStencilBuffer, BUFFER_OFFSET(0), store);
+        backgroundPatternArray.bind(*shaderPattern, tileStencilBuffer, BUFFER_OFFSET(0), store);
 
     } else {
-        plainShader->u_color = properties.backgroundColor;
-        plainShader->u_opacity = properties.backgroundOpacity;
+        config.program = shaderPlain->getID();
+        shaderPlain->u_color = properties.backgroundColor;
+        shaderPlain->u_opacity = properties.backgroundOpacity;
 
-        config.program = isOverdraw() ? plainShader->getOverdrawID() : plainShader->getID();
-        backgroundArray.bind(*plainShader, tileStencilBuffer, BUFFER_OFFSET(0), store);
+        backgroundArray.bind(*shaderPlain, tileStencilBuffer, BUFFER_OFFSET(0), store);
     }
 
     config.stencilTest = GL_FALSE;
@@ -60,20 +63,20 @@ void Painter::renderBackground(const BackgroundLayer& layer) {
         matrix::multiply(vertexMatrix, projMatrix, vertexMatrix);
 
         if (isPatterned) {
-            patternShader->u_matrix = vertexMatrix;
-            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 / tileID.pixelsToTileUnits(1.0f, state.getIntegerZoom());
+            shaderPattern->u_matrix = vertexMatrix;
+            shaderPattern->u_pattern_size_a = imagePosA->size;
+            shaderPattern->u_pattern_size_b = imagePosB->size;
+            shaderPattern->u_scale_a = properties.backgroundPattern.value.fromScale;
+            shaderPattern->u_scale_b = properties.backgroundPattern.value.toScale;
+            shaderPattern->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) }};
+            shaderPattern->u_pixel_coord_upper = {{ float(pixelX >> 16), float(pixelY >> 16) }};
+            shaderPattern->u_pixel_coord_lower = {{ float(pixelX & 0xFFFF), float(pixelY & 0xFFFF) }};
         } else {
-            plainShader->u_matrix = vertexMatrix;
+            shaderPlain->u_matrix = vertexMatrix;
         }
 
         MBGL_CHECK_ERROR(glDrawArrays(GL_TRIANGLE_STRIP, 0, (GLsizei)tileStencilBuffer.index()));