Global UBO

include/mbgl/gfx/context.hpp

@@ -155,6 +155,17 @@ class Context {
         return emplaceOrUpdateUniformBuffer(ptr, data, sizeof(T), persistent);
     }
 
+    /// Get the global uniform buffers
+    virtual const gfx::UniformBufferArray& getGlobalUniformBuffers() const = 0;
+
+    /// Get the mutable global uniform buffer array
+    virtual gfx::UniformBufferArray& mutableGlobalUniformBuffers() = 0;
+
+    /// Bind the global uniform buffers
+    virtual void bindGlobalUniformBuffers(gfx::RenderPass&) const noexcept = 0;
+
+    /// Unbind the global uniform buffers
+    virtual void unbindGlobalUniformBuffers(gfx::RenderPass&) const noexcept = 0;
 #endif
 
 protected:

include/mbgl/mtl/context.hpp

@@ -9,6 +9,7 @@
 #include <mbgl/gfx/context.hpp>
 #include <mbgl/mtl/buffer_resource.hpp>
 #include <mbgl/mtl/mtl_fwd.hpp>
+#include <mbgl/mtl/uniform_buffer.hpp>
 #include <mbgl/util/noncopyable.hpp>
 #include <mbgl/util/containers.hpp>
 
@@ -144,6 +145,18 @@ class Context final : public gfx::Context {
                                  RenderStaticData& staticData,
                                  const std::vector<shaders::ClipUBO>& tileUBOs);
 
+    /// Get the global uniform buffers
+    const gfx::UniformBufferArray& getGlobalUniformBuffers() const override { return globalUniformBuffers; };
+
+    /// Get the mutable global uniform buffer array
+    gfx::UniformBufferArray& mutableGlobalUniformBuffers() override { return globalUniformBuffers; };
+
+    /// Bind the global uniform buffers
+    void bindGlobalUniformBuffers(gfx::RenderPass&) const noexcept override;
+
+    /// Unbind the global uniform buffers
+    void unbindGlobalUniformBuffers(gfx::RenderPass&) const noexcept override {}
+
 private:
     RendererBackend& backend;
     bool cleanupOnDestruction = true;
@@ -160,6 +173,8 @@ class Context final : public gfx::Context {
     std::optional<BufferResource> clipMaskUniformsBuffer;
     bool clipMaskUniformsBufferUsed = false;
     const gfx::Renderable* stencilStateRenderable = nullptr;
+
+    UniformBufferArray globalUniformBuffers;
 };
 
 } // namespace mtl

include/mbgl/shaders/background_layer_ubo.hpp

@@ -40,20 +40,18 @@ struct alignas(16) BackgroundPatternLayerUBO {
     /*  8 */ std::array<float, 2> pattern_br_a;
     /* 16 */ std::array<float, 2> pattern_tl_b;
     /* 24 */ std::array<float, 2> pattern_br_b;
-    /* 32 */ std::array<float, 2> texsize;
-    /* 40 */ std::array<float, 2> pattern_size_a;
-    /* 48 */ std::array<float, 2> pattern_size_b;
-    /* 56 */ float scale_a;
-    /* 60 */ float scale_b;
-    /* 64 */ float mix;
-    /* 68 */ float opacity;
-    /* 72 */ float pad1, pad2;
-    /* 80 */
+    /* 32 */ std::array<float, 2> pattern_size_a;
+    /* 40 */ std::array<float, 2> pattern_size_b;
+    /* 48 */ float scale_a;
+    /* 52 */ float scale_b;
+    /* 56 */ float mix;
+    /* 60 */ float opacity;
+    /* 64 */
 };
-static_assert(sizeof(BackgroundPatternLayerUBO) == 80);
+static_assert(sizeof(BackgroundPatternLayerUBO) == 64);
 
 enum {
-    idBackgroundDrawableUBO,
+    idBackgroundDrawableUBO = globalUBOCount,
     idBackgroundLayerUBO,
     backgroundUBOCount
 };

include/mbgl/shaders/circle_layer_ubo.hpp

@@ -47,8 +47,7 @@ struct alignas(16) CircleInterpolateUBO {
 static_assert(sizeof(CircleInterpolateUBO) % 16 == 0);
 
 enum {
-    idCircleDrawableUBO,
-    idCirclePaintParamsUBO,
+    idCircleDrawableUBO = globalUBOCount,
     idCircleEvaluatedPropsUBO,
     idCircleInterpolateUBO,
     circleUBOCount

include/mbgl/shaders/collision_layer_ubo.hpp

@@ -8,14 +8,14 @@ namespace shaders {
 struct alignas(16) CollisionUBO {
     std::array<float, 4 * 4> matrix;
     std::array<float, 2> extrude_scale;
-    float camera_to_center_distance;
     float overscale_factor;
+    float pad;
 };
 static_assert(sizeof(CollisionUBO) % 16 == 0);
 static_assert(sizeof(CollisionUBO) == 80);
 
 enum {
-    idCollisionUBO,
+    idCollisionUBO = globalUBOCount,
     collisionUBOCount
 };
 

include/mbgl/shaders/custom_drawable_layer_ubo.hpp

@@ -27,7 +27,7 @@ struct alignas(16) CustomSymbolIconParametersUBO {
 static_assert(sizeof(CustomSymbolIconParametersUBO) == 3 * 16);
 
 enum {
-    idCustomSymbolDrawableUBO,
+    idCustomSymbolDrawableUBO = globalUBOCount,
     idCustomSymbolParametersUBO,
     customSymbolUBOCount
 };

include/mbgl/shaders/debug_layer_ubo.hpp

@@ -14,7 +14,7 @@ struct alignas(16) DebugUBO {
 static_assert(sizeof(DebugUBO) % 16 == 0);
 
 enum {
-    idDebugUBO,
+    idDebugUBO = globalUBOCount,
     debugUBOCount
 };
 

include/mbgl/shaders/fill_extrusion_layer_ubo.hpp

@@ -8,16 +8,15 @@ namespace mbgl {
 namespace shaders {
 
 struct alignas(16) FillExtrusionDrawableUBO {
-    /*   0 */ std::array<float, 4 * 4> matrix;
-    /*  64 */ std::array<float, 4> scale;
-    /*  80 */ std::array<float, 2> texsize;
-    /*  88 */ std::array<float, 2> pixel_coord_upper;
-    /*  96 */ std::array<float, 2> pixel_coord_lower;
-    /* 104 */ float height_factor;
-    /* 108 */ float pad;
-    /* 112 */
+    /*  0 */ std::array<float, 4 * 4> matrix;
+    /* 64 */ std::array<float, 2> texsize;
+    /* 72 */ std::array<float, 2> pixel_coord_upper;
+    /* 80 */ std::array<float, 2> pixel_coord_lower;
+    /* 88 */ float height_factor;
+    /* 92 */ float tile_ratio;
+    /* 96 */
 };
-static_assert(sizeof(FillExtrusionDrawableUBO) == 7 * 16);
+static_assert(sizeof(FillExtrusionDrawableUBO) == 6 * 16);
 
 /// Evaluated properties that do not depend on the tile
 struct alignas(16) FillExtrusionPropsUBO {
@@ -31,7 +30,9 @@ struct alignas(16) FillExtrusionPropsUBO {
     /* 56 */ float vertical_gradient;
     /* 60 */ float opacity;
     /* 64 */ float fade;
-    /* 68 */ float pad2, pad3, pad4;
+    /* 68 */ float from_scale;
+    /* 72 */ float to_scale;
+    /* 76 */ float pad2;
     /* 80 */
 };
 static_assert(sizeof(FillExtrusionPropsUBO) == 5 * 16);
@@ -57,7 +58,7 @@ struct alignas(16) FillExtrusionInterpolateUBO {
 static_assert(sizeof(FillExtrusionInterpolateUBO) == 2 * 16);
 
 enum {
-    idFillExtrusionDrawableUBO,
+    idFillExtrusionDrawableUBO = globalUBOCount,
     idFillExtrusionPropsUBO,
     idFillExtrusionTilePropsUBO,
     idFillExtrusionInterpolateUBO,

include/mbgl/shaders/fill_layer_ubo.hpp

@@ -10,6 +10,7 @@ namespace shaders {
 
 struct alignas(16) FillDrawableUBO {
     /*  0 */ std::array<float, 4 * 4> matrix; // composite model-view-projection matrix
+    /* 64 */
 };
 static_assert(sizeof(FillDrawableUBO) == 4 * 16);
 
@@ -25,11 +26,9 @@ static_assert(sizeof(FillInterpolateUBO) % 16 == 0);
 
 struct alignas(16) FillOutlineDrawableUBO {
     /*  0 */ std::array<float, 4 * 4> matrix; // composite model-view-projection matrix
-    /* 64 */ std::array<float, 2> world;
-    /* 72 */ float pad1, pad2;
-    /* 80 */
+    /* 64 */
 };
-static_assert(sizeof(FillOutlineDrawableUBO) == 5 * 16);
+static_assert(sizeof(FillOutlineDrawableUBO) == 4 * 16);
 
 struct alignas(16) FillOutlineInterpolateUBO {
     float outline_color_t;
@@ -43,14 +42,14 @@ static_assert(sizeof(FillOutlineInterpolateUBO) == 1 * 16);
 
 struct alignas(16) FillPatternDrawableUBO {
     /*  0  */ std::array<float, 4 * 4> matrix; // composite model-view-projection matrix
-    /*  64 */ std::array<float, 4> scale;
-    /*  80 */ std::array<float, 2> pixel_coord_upper;
-    /*  88 */ std::array<float, 2> pixel_coord_lower;
-    /*  96 */ std::array<float, 2> texsize;
-    /* 104 */ float pad1, pad2;
-    /* 112 */
+    /* 64 */ std::array<float, 2> pixel_coord_upper;
+    /* 72 */ std::array<float, 2> pixel_coord_lower;
+    /* 80 */ std::array<float, 2> texsize;
+    /* 88 */ float tile_ratio;
+    /* 92 */ float pad;
+    /* 96 */
 };
-static_assert(sizeof(FillPatternDrawableUBO) == 7 * 16);
+static_assert(sizeof(FillPatternDrawableUBO) == 6 * 16);
 
 struct alignas(16) FillPatternTilePropsUBO {
     std::array<float, 4> pattern_from;
@@ -71,13 +70,14 @@ static_assert(sizeof(FillPatternInterpolateUBO) == 1 * 16);
 
 struct alignas(16) FillOutlinePatternDrawableUBO {
     /*  0  */ std::array<float, 4 * 4> matrix; // composite model-view-projection matrix
-    /*  64 */ std::array<float, 4> scale;
-    /*  80 */ std::array<float, 2> world;
-    /*  88 */ std::array<float, 2> pixel_coord_upper;
-    /*  96 */ std::array<float, 2> pixel_coord_lower;
-    /* 104 */ std::array<float, 2> texsize;
+    /*  64 */ std::array<float, 2> pixel_coord_upper;
+    /*  72 */ std::array<float, 2> pixel_coord_lower;
+    /*  80 */ std::array<float, 2> texsize;
+    /*  88 */ float tile_ratio;
+    /*  92 */ float pad;
+    /*  96 */
 };
-static_assert(sizeof(FillOutlinePatternDrawableUBO) == 7 * 16);
+static_assert(sizeof(FillOutlinePatternDrawableUBO) == 6 * 16);
 
 struct alignas(16) FillOutlinePatternTilePropsUBO {
     std::array<float, 4> pattern_from;
@@ -98,9 +98,8 @@ static_assert(sizeof(FillOutlinePatternInterpolateUBO) == 1 * 16);
 
 struct alignas(16) FillOutlineTriangulatedDrawableUBO {
     std::array<float, 4 * 4> matrix;
-    std::array<float, 2> units_to_pixels;
     float ratio;
-    float pad;
+    float pad1, pad2, pad3;
 };
 static_assert(sizeof(FillOutlineTriangulatedDrawableUBO) % 16 == 0);
 
@@ -112,13 +111,13 @@ struct alignas(16) FillEvaluatedPropsUBO {
     Color outline_color;
     float opacity;
     float fade;
-    float width;
-    float pad1;
+    float from_scale;
+    float to_scale;
 };
 static_assert(sizeof(FillEvaluatedPropsUBO) == 3 * 16);
 
 enum {
-    idFillDrawableUBO,
+    idFillDrawableUBO = globalUBOCount,
     idFillTilePropsUBO,
     idFillInterpolateUBO,
     idFillEvaluatedPropsUBO,

include/mbgl/shaders/gl/drawable_background_pattern.hpp

@@ -20,14 +20,12 @@ layout (std140) uniform BackgroundPatternLayerUBO {
     highp vec2 u_pattern_br_a;
     highp vec2 u_pattern_tl_b;
     highp vec2 u_pattern_br_b;
-    highp vec2 u_texsize;
     highp vec2 u_pattern_size_a;
     highp vec2 u_pattern_size_b;
     highp float u_scale_a;
     highp float u_scale_b;
     highp float u_mix;
     highp float u_opacity;
-    highp float layer_pad1, layer_pad2;
 };
 
 layout (location = 0) in vec2 a_pos;
@@ -41,19 +39,28 @@ void main() {
     v_pos_b = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, u_scale_b * u_pattern_size_b, u_tile_units_to_pixels, a_pos);
 }
 )";
-    static constexpr const char* fragment = R"(layout (std140) uniform BackgroundPatternLayerUBO {
+    static constexpr const char* fragment = R"(layout (std140) uniform GlobalPaintParamsUBO {
+    highp vec2 u_pattern_atlas_texsize;
+    highp vec2 u_units_to_pixels;
+    highp vec2 u_world_size;
+    highp float u_camera_to_center_distance;
+    highp float u_symbol_fade_change;
+    highp float u_aspect_ratio;
+    highp float u_pixel_ratio;
+    highp float global_pad1, global_pad2;
+};
+
+layout (std140) uniform BackgroundPatternLayerUBO {
     highp vec2 u_pattern_tl_a;
     highp vec2 u_pattern_br_a;
     highp vec2 u_pattern_tl_b;
     highp vec2 u_pattern_br_b;
-    highp vec2 u_texsize;
     highp vec2 u_pattern_size_a;
     highp vec2 u_pattern_size_b;
     highp float u_scale_a;
     highp float u_scale_b;
     highp float u_mix;
     highp float u_opacity;
-    highp float layer_pad1, layer_pad2;
 };
 
 uniform sampler2D u_image;
@@ -63,11 +70,11 @@ in mediump vec2 v_pos_b;
 
 void main() {
     vec2 imagecoord = mod(v_pos_a, 1.0);
-    vec2 pos = mix(u_pattern_tl_a / u_texsize, u_pattern_br_a / u_texsize, imagecoord);
+    vec2 pos = mix(u_pattern_tl_a / u_pattern_atlas_texsize, u_pattern_br_a / u_pattern_atlas_texsize, imagecoord);
     vec4 color1 = texture(u_image, pos);
 
     vec2 imagecoord_b = mod(v_pos_b, 1.0);
-    vec2 pos2 = mix(u_pattern_tl_b / u_texsize, u_pattern_br_b / u_texsize, imagecoord_b);
+    vec2 pos2 = mix(u_pattern_tl_b / u_pattern_atlas_texsize, u_pattern_br_b / u_pattern_atlas_texsize, imagecoord_b);
     vec4 color2 = texture(u_image, pos2);
 
     fragColor = mix(color1, color2, u_mix) * u_opacity;

include/mbgl/shaders/gl/drawable_circle.hpp

@@ -11,18 +11,23 @@ struct ShaderSource<BuiltIn::CircleShader, gfx::Backend::Type::OpenGL> {
     static constexpr const char* vertex = R"(layout (location = 0) in vec2 a_pos;
 out vec3 v_data;
 
+layout (std140) uniform GlobalPaintParamsUBO {
+    highp vec2 u_pattern_atlas_texsize;
+    highp vec2 u_units_to_pixels;
+    highp vec2 u_world_size;
+    highp float u_camera_to_center_distance;
+    highp float u_symbol_fade_change;
+    highp float u_aspect_ratio;
+    highp float u_pixel_ratio;
+    highp float global_pad1, global_pad2;
+};
+
 layout (std140) uniform CircleDrawableUBO {
     highp mat4 u_matrix;
     highp vec2 u_extrude_scale;
     lowp vec2 drawable_pad1;
 };
 
-layout (std140) uniform CirclePaintParamsUBO {
-    highp float u_camera_to_center_distance;
-    lowp float params_pad1;
-    lowp vec2 params_pad2;
-};
-
 layout (std140) uniform CircleEvaluatedPropsUBO {
     highp vec4 u_color;
     highp vec4 u_stroke_color;

include/mbgl/shaders/gl/drawable_collision_box.hpp

@@ -14,10 +14,21 @@ layout (location = 2) in vec2 a_extrude;
 layout (location = 3) in vec2 a_placed;
 layout (location = 4) in vec2 a_shift;
 
-layout (std140) uniform CollisionBoxUBO {
+layout (std140) uniform GlobalPaintParamsUBO {
+    highp vec2 u_pattern_atlas_texsize;
+    highp vec2 u_units_to_pixels;
+    highp vec2 u_world_size;
+    highp float u_camera_to_center_distance;
+    highp float u_symbol_fade_change;
+    highp float u_aspect_ratio;
+    highp float u_pixel_ratio;
+    highp float global_pad1, global_pad2;
+};
+
+layout (std140) uniform CollisionUBO {
     highp mat4 u_matrix;
     highp vec2 u_extrude_scale;
-    highp float u_camera_to_center_distance;
+    highp float u_overscale_factor;
     highp float pad1;
 };
 
@@ -39,10 +50,10 @@ void main() {
     v_notUsed = a_placed.y;
 }
 )";
-    static constexpr const char* fragment = R"(layout (std140) uniform CollisionBoxUBO {
+    static constexpr const char* fragment = R"(layout (std140) uniform CollisionUBO {
     highp mat4 u_matrix;
     highp vec2 u_extrude_scale;
-    highp float u_camera_to_center_distance;
+    highp float u_overscale_factor;
     highp float pad1;
 };