From b823f036fed6385080b3dd93dcb44b925cc6ccc8 Mon Sep 17 00:00:00 2001 From: Tim Sylvester Date: Thu, 25 May 2023 12:13:23 -0700 Subject: [PATCH] Setting up UBO for fill drawables (#1175) --- .../mbgl/shaders/gl/drawable_background.hpp | 8 +- include/mbgl/shaders/gl/drawable_fill.hpp | 64 +++++++++++----- .../mbgl/shaders/gl/drawable_fill_outline.hpp | 64 +++++++++++----- .../gl/drawable_fill_outline_pattern.hpp | 70 ++++++++++++------ .../mbgl/shaders/gl/drawable_fill_pattern.hpp | 67 +++++++++++------ shaders/drawable.background.fragment.glsl | 4 +- shaders/drawable.background.vertex.glsl | 2 +- shaders/drawable.fill.fragment.glsl | 23 ++++++ shaders/drawable.fill.vertex.glsl | 27 +++++-- shaders/drawable.fill_outline.fragment.glsl | 23 ++++++ shaders/drawable.fill_outline.vertex.glsl | 27 +++++-- ...rawable.fill_outline_pattern.fragment.glsl | 24 +++++- .../drawable.fill_outline_pattern.vertex.glsl | 27 +++++-- shaders/drawable.fill_pattern.fragment.glsl | 24 +++++- shaders/drawable.fill_pattern.vertex.glsl | 26 ++++++- shaders/manifest.json | 8 +- .../renderer/layers/fill_layer_tweaker.cpp | 73 +++++++++++++++++-- .../renderer/layers/render_fill_layer.cpp | 49 ++++--------- 18 files changed, 456 insertions(+), 154 deletions(-) diff --git a/include/mbgl/shaders/gl/drawable_background.hpp b/include/mbgl/shaders/gl/drawable_background.hpp index 647eab21e..4b770b4e9 100644 --- a/include/mbgl/shaders/gl/drawable_background.hpp +++ b/include/mbgl/shaders/gl/drawable_background.hpp @@ -1,5 +1,5 @@ // Generated code, do not modify this file! -// Generated on 2023-05-23T00:45:10.632Z by timsylvester using shaders/generate_shader_code.js +// Generated on 2023-05-24T21:16:59.579Z by timsylvester using shaders/generate_shader_code.js #pragma once #include @@ -12,7 +12,7 @@ struct ShaderSource { static constexpr const char* name = "BackgroundShader"; static constexpr const char* vertex = R"(layout (location = 0) in vec2 a_pos; layout (std140) uniform BackgroundDrawableUBO { - mat4 u_matrix; + highp mat4 u_matrix; }; void main() { @@ -20,8 +20,8 @@ void main() { } )"; static constexpr const char* fragment = R"(layout (std140) uniform BackgroundLayerUBO { - vec4 u_color; - vec4 u_opacity_pad3; + highp vec4 u_color; + highp vec4 u_opacity_pad3; }; void main() { diff --git a/include/mbgl/shaders/gl/drawable_fill.hpp b/include/mbgl/shaders/gl/drawable_fill.hpp index d40c8563c..1c12ae953 100644 --- a/include/mbgl/shaders/gl/drawable_fill.hpp +++ b/include/mbgl/shaders/gl/drawable_fill.hpp @@ -1,5 +1,5 @@ // Generated code, do not modify this file! -// Generated on 2023-05-23T00:45:10.632Z by timsylvester using shaders/generate_shader_code.js +// Generated on 2023-05-25T15:19:24.210Z by timsylvester using shaders/generate_shader_code.js #pragma once #include @@ -10,27 +10,38 @@ namespace shaders { template <> struct ShaderSource { static constexpr const char* name = "FillShader"; - static constexpr const char* vertex = R"(layout (location = 0) in vec2 a_pos; + static constexpr const char* vertex = R"(layout (std140) uniform FillDrawableUBO { + highp mat4 u_matrix; + highp vec4 u_scale; + highp vec2 u_world; + highp vec2 u_pixel_coord_upper; + highp vec2 u_pixel_coord_lower; + highp vec2 u_texsize; + highp float u_fade; -layout (std140) uniform FillDrawableUBO { - mat4 u_matrix; - vec2 u_world; - vec2 pad; + highp float u_color_t; + highp float u_opacity_t; + highp float u_outline_color_t; + highp float u_pattern_from_t; + highp float u_pattern_to_t; + + highp vec2 u_color; + highp vec2 u_opacity; + highp vec2 u_outline_color_pad; + highp vec4 u_outline_color; + highp vec4 u_pattern_from; + highp vec4 u_pattern_to; }; +layout (location = 0) in vec2 a_pos; + #ifndef HAS_UNIFORM_u_color -uniform lowp float u_color_t; layout (location = 1) in highp vec4 a_color; out highp vec4 color; -#else -uniform highp vec4 u_color; #endif #ifndef HAS_UNIFORM_u_opacity -uniform lowp float u_opacity_t; layout (location = 2) in lowp vec2 a_opacity; out lowp float opacity; -#else -uniform lowp float u_opacity; #endif void main() { @@ -48,15 +59,34 @@ lowp float opacity = u_opacity; gl_Position = u_matrix * vec4(a_pos, 0, 1); } )"; - static constexpr const char* fragment = R"(#ifndef HAS_UNIFORM_u_color + static constexpr const char* fragment = R"(layout (std140) uniform FillDrawableUBO { + highp mat4 u_matrix; + highp vec4 u_scale; + highp vec2 u_world; + highp vec2 u_pixel_coord_upper; + highp vec2 u_pixel_coord_lower; + highp vec2 u_texsize; + highp float u_fade; + + highp float u_color_t; + highp float u_opacity_t; + highp float u_outline_color_t; + highp float u_pattern_from_t; + highp float u_pattern_to_t; + + highp vec2 u_color; + highp vec2 u_opacity; + highp vec2 u_outline_color_pad; + highp vec4 u_outline_color; + highp vec4 u_pattern_from; + highp vec4 u_pattern_to; +}; + +#ifndef HAS_UNIFORM_u_color in highp vec4 color; -#else -uniform highp vec4 u_color; #endif #ifndef HAS_UNIFORM_u_opacity in lowp float opacity; -#else -uniform lowp float u_opacity; #endif void main() { diff --git a/include/mbgl/shaders/gl/drawable_fill_outline.hpp b/include/mbgl/shaders/gl/drawable_fill_outline.hpp index 01d9d2ef0..8a35b5dca 100644 --- a/include/mbgl/shaders/gl/drawable_fill_outline.hpp +++ b/include/mbgl/shaders/gl/drawable_fill_outline.hpp @@ -1,5 +1,5 @@ // Generated code, do not modify this file! -// Generated on 2023-05-23T00:45:10.632Z by timsylvester using shaders/generate_shader_code.js +// Generated on 2023-05-25T15:19:24.210Z by timsylvester using shaders/generate_shader_code.js #pragma once #include @@ -10,29 +10,40 @@ namespace shaders { template <> struct ShaderSource { static constexpr const char* name = "FillOutlineShader"; - static constexpr const char* vertex = R"(layout (location = 0) in vec2 a_pos; + static constexpr const char* vertex = R"(layout (std140) uniform FillDrawableUBO { + highp mat4 u_matrix; + highp vec4 u_scale; + highp vec2 u_world; + highp vec2 u_pixel_coord_upper; + highp vec2 u_pixel_coord_lower; + highp vec2 u_texsize; + highp float u_fade; -layout (std140) uniform FillDrawableUBO { - mat4 u_matrix; - vec2 u_world; - vec2 pad; + highp float u_color_t; + highp float u_opacity_t; + highp float u_outline_color_t; + highp float u_pattern_from_t; + highp float u_pattern_to_t; + + highp vec2 u_color; + highp vec2 u_opacity; + highp vec2 u_outline_color_pad; + highp vec4 u_outline_color; + highp vec4 u_pattern_from; + highp vec4 u_pattern_to; }; +layout (location = 0) in vec2 a_pos; + out vec2 v_pos; #ifndef HAS_UNIFORM_u_outline_color -uniform lowp float u_outline_color_t; layout (location = 1) in highp vec4 a_outline_color; out highp vec4 outline_color; -#else -uniform highp vec4 u_outline_color; #endif #ifndef HAS_UNIFORM_u_opacity -uniform lowp float u_opacity_t; layout (location = 2) in lowp vec2 a_opacity; out lowp float opacity; -#else -uniform lowp float u_opacity; #endif void main() { @@ -51,17 +62,36 @@ lowp float opacity = u_opacity; v_pos = (gl_Position.xy / gl_Position.w + 1.0) / 2.0 * u_world; } )"; - static constexpr const char* fragment = R"(in vec2 v_pos; + static constexpr const char* fragment = R"(layout (std140) uniform FillDrawableUBO { + highp mat4 u_matrix; + highp vec4 u_scale; + highp vec2 u_world; + highp vec2 u_pixel_coord_upper; + highp vec2 u_pixel_coord_lower; + highp vec2 u_texsize; + highp float u_fade; + + highp float u_color_t; + highp float u_opacity_t; + highp float u_outline_color_t; + highp float u_pattern_from_t; + highp float u_pattern_to_t; + + highp vec2 u_color; + highp vec2 u_opacity; + highp vec2 u_outline_color_pad; + highp vec4 u_outline_color; + highp vec4 u_pattern_from; + highp vec4 u_pattern_to; +}; + +in vec2 v_pos; #ifndef HAS_UNIFORM_u_outline_color in highp vec4 outline_color; -#else -uniform highp vec4 u_outline_color; #endif #ifndef HAS_UNIFORM_u_opacity in lowp float opacity; -#else -uniform lowp float u_opacity; #endif void main() { diff --git a/include/mbgl/shaders/gl/drawable_fill_outline_pattern.hpp b/include/mbgl/shaders/gl/drawable_fill_outline_pattern.hpp index 3baed28e3..74e42b338 100644 --- a/include/mbgl/shaders/gl/drawable_fill_outline_pattern.hpp +++ b/include/mbgl/shaders/gl/drawable_fill_outline_pattern.hpp @@ -1,5 +1,5 @@ // Generated code, do not modify this file! -// Generated on 2023-05-23T18:10:10.798Z by timsylvester using shaders/generate_shader_code.js +// Generated on 2023-05-25T14:44:39.644Z by timsylvester using shaders/generate_shader_code.js #pragma once #include @@ -10,11 +10,28 @@ namespace shaders { template <> struct ShaderSource { static constexpr const char* name = "FillOutlinePatternShader"; - static constexpr const char* vertex = R"(uniform mat4 u_matrix; -uniform vec2 u_world; -uniform vec2 u_pixel_coord_upper; -uniform vec2 u_pixel_coord_lower; -uniform vec4 u_scale; + static constexpr const char* vertex = R"(layout (std140) uniform FillDrawableUBO { + highp mat4 u_matrix; + highp vec4 u_scale; + highp vec2 u_world; + highp vec2 u_pixel_coord_upper; + highp vec2 u_pixel_coord_lower; + highp vec2 u_texsize; + highp float u_fade; + + highp float u_color_t; + highp float u_opacity_t; + highp float u_outline_color_t; + highp float u_pattern_from_t; + highp float u_pattern_to_t; + + highp vec2 u_color; + highp vec2 u_opacity; + highp vec2 u_outline_color_pad; + highp vec4 u_outline_color; + highp vec4 u_pattern_from; + highp vec4 u_pattern_to; +}; layout (location = 0) in vec2 a_pos; @@ -23,25 +40,16 @@ out vec2 v_pos_b; out vec2 v_pos; #ifndef HAS_UNIFORM_u_opacity -uniform lowp float u_opacity_t; layout (location = 1) in lowp vec2 a_opacity; out lowp float opacity; -#else -uniform lowp float u_opacity; #endif #ifndef HAS_UNIFORM_u_pattern_from -uniform lowp float u_pattern_from_t; layout (location = 2) in lowp vec4 a_pattern_from; out lowp vec4 pattern_from; -#else -uniform lowp vec4 u_pattern_from; #endif #ifndef HAS_UNIFORM_u_pattern_to -uniform lowp float u_pattern_to_t; layout (location = 3) in lowp vec4 a_pattern_to; out lowp vec4 pattern_to; -#else -uniform lowp vec4 u_pattern_to; #endif void main() { @@ -82,10 +90,30 @@ mediump vec4 pattern_to = u_pattern_to; v_pos = (gl_Position.xy / gl_Position.w + 1.0) / 2.0 * u_world; } )"; - static constexpr const char* fragment = R"( -uniform vec2 u_texsize; + static constexpr const char* fragment = R"(layout (std140) uniform FillDrawableUBO { + highp mat4 u_matrix; + highp vec4 u_scale; + highp vec2 u_world; + highp vec2 u_pixel_coord_upper; + highp vec2 u_pixel_coord_lower; + highp vec2 u_texsize; + highp float u_fade; + + highp float u_color_t; + highp float u_opacity_t; + highp float u_outline_color_t; + highp float u_pattern_from_t; + highp float u_pattern_to_t; + + highp vec2 u_color; + highp vec2 u_opacity; + highp vec2 u_outline_color_pad; + highp vec4 u_outline_color; + highp vec4 u_pattern_from; + highp vec4 u_pattern_to; +}; + uniform sampler2D u_image; -uniform float u_fade; in vec2 v_pos_a; in vec2 v_pos_b; @@ -93,18 +121,12 @@ in vec2 v_pos; #ifndef HAS_UNIFORM_u_opacity in lowp float opacity; -#else -uniform lowp float u_opacity; #endif #ifndef HAS_UNIFORM_u_pattern_from in lowp vec4 pattern_from; -#else -uniform lowp vec4 u_pattern_from; #endif #ifndef HAS_UNIFORM_u_pattern_to in lowp vec4 pattern_to; -#else -uniform lowp vec4 u_pattern_to; #endif void main() { diff --git a/include/mbgl/shaders/gl/drawable_fill_pattern.hpp b/include/mbgl/shaders/gl/drawable_fill_pattern.hpp index 735f08f7a..3b7afe08c 100644 --- a/include/mbgl/shaders/gl/drawable_fill_pattern.hpp +++ b/include/mbgl/shaders/gl/drawable_fill_pattern.hpp @@ -1,5 +1,5 @@ // Generated code, do not modify this file! -// Generated on 2023-05-23T18:10:10.798Z by timsylvester using shaders/generate_shader_code.js +// Generated on 2023-05-25T14:44:39.644Z by timsylvester using shaders/generate_shader_code.js #pragma once #include @@ -10,10 +10,28 @@ namespace shaders { template <> struct ShaderSource { static constexpr const char* name = "FillPatternShader"; - static constexpr const char* vertex = R"(uniform mat4 u_matrix; -uniform vec2 u_pixel_coord_upper; -uniform vec2 u_pixel_coord_lower; -uniform vec4 u_scale; + static constexpr const char* vertex = R"(layout (std140) uniform FillDrawableUBO { + highp mat4 u_matrix; + highp vec4 u_scale; + highp vec2 u_world; + highp vec2 u_pixel_coord_upper; + highp vec2 u_pixel_coord_lower; + highp vec2 u_texsize; + highp float u_fade; + + highp float u_color_t; + highp float u_opacity_t; + highp float u_outline_color_t; + highp float u_pattern_from_t; + highp float u_pattern_to_t; + + highp vec2 u_color; + highp vec2 u_opacity; + highp vec2 u_outline_color_pad; + highp vec4 u_outline_color; + highp vec4 u_pattern_from; + highp vec4 u_pattern_to; +}; layout (location = 0) in vec2 a_pos; @@ -21,25 +39,16 @@ out vec2 v_pos_a; out vec2 v_pos_b; #ifndef HAS_UNIFORM_u_opacity -uniform lowp float u_opacity_t; layout (location = 1) in lowp vec2 a_opacity; out lowp float opacity; -#else -uniform lowp float u_opacity; #endif #ifndef HAS_UNIFORM_u_pattern_from -uniform lowp float u_pattern_from_t; layout (location = 2) in lowp vec4 a_pattern_from; out lowp vec4 pattern_from; -#else -uniform lowp vec4 u_pattern_from; #endif #ifndef HAS_UNIFORM_u_pattern_to -uniform lowp float u_pattern_to_t; layout (location = 3) in lowp vec4 a_pattern_to; out lowp vec4 pattern_to; -#else -uniform lowp vec4 u_pattern_to; #endif void main() { @@ -77,8 +86,28 @@ mediump vec4 pattern_to = u_pattern_to; v_pos_b = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, toScale * display_size_b, tileZoomRatio, a_pos); } )"; - static constexpr const char* fragment = R"(uniform vec2 u_texsize; -uniform float u_fade; + static constexpr const char* fragment = R"(layout (std140) uniform FillDrawableUBO { + highp mat4 u_matrix; + highp vec4 u_scale; + highp vec2 u_world; + highp vec2 u_pixel_coord_upper; + highp vec2 u_pixel_coord_lower; + highp vec2 u_texsize; + highp float u_fade; + + highp float u_color_t; + highp float u_opacity_t; + highp float u_outline_color_t; + highp float u_pattern_from_t; + highp float u_pattern_to_t; + + highp vec2 u_color; + highp vec2 u_opacity; + highp vec2 u_outline_color_pad; + highp vec4 u_outline_color; + highp vec4 u_pattern_from; + highp vec4 u_pattern_to; +}; uniform sampler2D u_image; @@ -87,18 +116,12 @@ in vec2 v_pos_b; #ifndef HAS_UNIFORM_u_opacity in lowp float opacity; -#else -uniform lowp float u_opacity; #endif #ifndef HAS_UNIFORM_u_pattern_from in lowp vec4 pattern_from; -#else -uniform lowp vec4 u_pattern_from; #endif #ifndef HAS_UNIFORM_u_pattern_to in lowp vec4 pattern_to; -#else -uniform lowp vec4 u_pattern_to; #endif void main() { diff --git a/shaders/drawable.background.fragment.glsl b/shaders/drawable.background.fragment.glsl index d275aaee8..2993d8989 100644 --- a/shaders/drawable.background.fragment.glsl +++ b/shaders/drawable.background.fragment.glsl @@ -1,6 +1,6 @@ layout (std140) uniform BackgroundLayerUBO { - vec4 u_color; - vec4 u_opacity_pad3; + highp vec4 u_color; + highp vec4 u_opacity_pad3; }; void main() { diff --git a/shaders/drawable.background.vertex.glsl b/shaders/drawable.background.vertex.glsl index f07682657..5e4c0dd3d 100644 --- a/shaders/drawable.background.vertex.glsl +++ b/shaders/drawable.background.vertex.glsl @@ -1,6 +1,6 @@ layout (location = 0) in vec2 a_pos; layout (std140) uniform BackgroundDrawableUBO { - mat4 u_matrix; + highp mat4 u_matrix; }; void main() { diff --git a/shaders/drawable.fill.fragment.glsl b/shaders/drawable.fill.fragment.glsl index ffd33c16c..9928bcf69 100644 --- a/shaders/drawable.fill.fragment.glsl +++ b/shaders/drawable.fill.fragment.glsl @@ -1,3 +1,26 @@ +layout (std140) uniform FillDrawableUBO { + highp mat4 u_matrix; + highp vec4 u_scale; + highp vec2 u_world; + highp vec2 u_pixel_coord_upper; + highp vec2 u_pixel_coord_lower; + highp vec2 u_texsize; + highp float u_fade; + + highp float u_color_t; + highp float u_opacity_t; + highp float u_outline_color_t; + highp float u_pattern_from_t; + highp float u_pattern_to_t; + + highp vec2 u_color; + highp vec2 u_opacity; + highp vec2 u_outline_color_pad; + highp vec4 u_outline_color; + highp vec4 u_pattern_from; + highp vec4 u_pattern_to; +}; + #pragma mapbox: define highp vec4 color #pragma mapbox: define lowp float opacity diff --git a/shaders/drawable.fill.vertex.glsl b/shaders/drawable.fill.vertex.glsl index bc4ca388c..287fa98ad 100644 --- a/shaders/drawable.fill.vertex.glsl +++ b/shaders/drawable.fill.vertex.glsl @@ -1,11 +1,28 @@ -layout (location = 0) in vec2 a_pos; - layout (std140) uniform FillDrawableUBO { - mat4 u_matrix; - vec2 u_world; - vec2 pad; + highp mat4 u_matrix; + highp vec4 u_scale; + highp vec2 u_world; + highp vec2 u_pixel_coord_upper; + highp vec2 u_pixel_coord_lower; + highp vec2 u_texsize; + highp float u_fade; + + highp float u_color_t; + highp float u_opacity_t; + highp float u_outline_color_t; + highp float u_pattern_from_t; + highp float u_pattern_to_t; + + highp vec2 u_color; + highp vec2 u_opacity; + highp vec2 u_outline_color_pad; + highp vec4 u_outline_color; + highp vec4 u_pattern_from; + highp vec4 u_pattern_to; }; +layout (location = 0) in vec2 a_pos; + #pragma mapbox: define highp vec4 color #pragma mapbox: define lowp float opacity diff --git a/shaders/drawable.fill_outline.fragment.glsl b/shaders/drawable.fill_outline.fragment.glsl index f13b94eda..487135248 100644 --- a/shaders/drawable.fill_outline.fragment.glsl +++ b/shaders/drawable.fill_outline.fragment.glsl @@ -1,3 +1,26 @@ +layout (std140) uniform FillDrawableUBO { + highp mat4 u_matrix; + highp vec4 u_scale; + highp vec2 u_world; + highp vec2 u_pixel_coord_upper; + highp vec2 u_pixel_coord_lower; + highp vec2 u_texsize; + highp float u_fade; + + highp float u_color_t; + highp float u_opacity_t; + highp float u_outline_color_t; + highp float u_pattern_from_t; + highp float u_pattern_to_t; + + highp vec2 u_color; + highp vec2 u_opacity; + highp vec2 u_outline_color_pad; + highp vec4 u_outline_color; + highp vec4 u_pattern_from; + highp vec4 u_pattern_to; +}; + in vec2 v_pos; #pragma mapbox: define highp vec4 outline_color diff --git a/shaders/drawable.fill_outline.vertex.glsl b/shaders/drawable.fill_outline.vertex.glsl index 16e7de16e..ca9be397a 100644 --- a/shaders/drawable.fill_outline.vertex.glsl +++ b/shaders/drawable.fill_outline.vertex.glsl @@ -1,11 +1,28 @@ -layout (location = 0) in vec2 a_pos; - layout (std140) uniform FillDrawableUBO { - mat4 u_matrix; - vec2 u_world; - vec2 pad; + highp mat4 u_matrix; + highp vec4 u_scale; + highp vec2 u_world; + highp vec2 u_pixel_coord_upper; + highp vec2 u_pixel_coord_lower; + highp vec2 u_texsize; + highp float u_fade; + + highp float u_color_t; + highp float u_opacity_t; + highp float u_outline_color_t; + highp float u_pattern_from_t; + highp float u_pattern_to_t; + + highp vec2 u_color; + highp vec2 u_opacity; + highp vec2 u_outline_color_pad; + highp vec4 u_outline_color; + highp vec4 u_pattern_from; + highp vec4 u_pattern_to; }; +layout (location = 0) in vec2 a_pos; + out vec2 v_pos; #pragma mapbox: define highp vec4 outline_color diff --git a/shaders/drawable.fill_outline_pattern.fragment.glsl b/shaders/drawable.fill_outline_pattern.fragment.glsl index 07984c717..4fce1b650 100644 --- a/shaders/drawable.fill_outline_pattern.fragment.glsl +++ b/shaders/drawable.fill_outline_pattern.fragment.glsl @@ -1,7 +1,27 @@ +layout (std140) uniform FillDrawableUBO { + highp mat4 u_matrix; + highp vec4 u_scale; + highp vec2 u_world; + highp vec2 u_pixel_coord_upper; + highp vec2 u_pixel_coord_lower; + highp vec2 u_texsize; + highp float u_fade; + + highp float u_color_t; + highp float u_opacity_t; + highp float u_outline_color_t; + highp float u_pattern_from_t; + highp float u_pattern_to_t; + + highp vec2 u_color; + highp vec2 u_opacity; + highp vec2 u_outline_color_pad; + highp vec4 u_outline_color; + highp vec4 u_pattern_from; + highp vec4 u_pattern_to; +}; -uniform vec2 u_texsize; uniform sampler2D u_image; -uniform float u_fade; in vec2 v_pos_a; in vec2 v_pos_b; diff --git a/shaders/drawable.fill_outline_pattern.vertex.glsl b/shaders/drawable.fill_outline_pattern.vertex.glsl index c4c286b78..819bf6bea 100644 --- a/shaders/drawable.fill_outline_pattern.vertex.glsl +++ b/shaders/drawable.fill_outline_pattern.vertex.glsl @@ -1,8 +1,25 @@ -uniform mat4 u_matrix; -uniform vec2 u_world; -uniform vec2 u_pixel_coord_upper; -uniform vec2 u_pixel_coord_lower; -uniform vec4 u_scale; +layout (std140) uniform FillDrawableUBO { + highp mat4 u_matrix; + highp vec4 u_scale; + highp vec2 u_world; + highp vec2 u_pixel_coord_upper; + highp vec2 u_pixel_coord_lower; + highp vec2 u_texsize; + highp float u_fade; + + highp float u_color_t; + highp float u_opacity_t; + highp float u_outline_color_t; + highp float u_pattern_from_t; + highp float u_pattern_to_t; + + highp vec2 u_color; + highp vec2 u_opacity; + highp vec2 u_outline_color_pad; + highp vec4 u_outline_color; + highp vec4 u_pattern_from; + highp vec4 u_pattern_to; +}; layout (location = 0) in vec2 a_pos; diff --git a/shaders/drawable.fill_pattern.fragment.glsl b/shaders/drawable.fill_pattern.fragment.glsl index 59643ecc4..ff7a90c48 100644 --- a/shaders/drawable.fill_pattern.fragment.glsl +++ b/shaders/drawable.fill_pattern.fragment.glsl @@ -1,5 +1,25 @@ -uniform vec2 u_texsize; -uniform float u_fade; +layout (std140) uniform FillDrawableUBO { + highp mat4 u_matrix; + highp vec4 u_scale; + highp vec2 u_world; + highp vec2 u_pixel_coord_upper; + highp vec2 u_pixel_coord_lower; + highp vec2 u_texsize; + highp float u_fade; + + highp float u_color_t; + highp float u_opacity_t; + highp float u_outline_color_t; + highp float u_pattern_from_t; + highp float u_pattern_to_t; + + highp vec2 u_color; + highp vec2 u_opacity; + highp vec2 u_outline_color_pad; + highp vec4 u_outline_color; + highp vec4 u_pattern_from; + highp vec4 u_pattern_to; +}; uniform sampler2D u_image; diff --git a/shaders/drawable.fill_pattern.vertex.glsl b/shaders/drawable.fill_pattern.vertex.glsl index 8c2540c95..4e902b079 100644 --- a/shaders/drawable.fill_pattern.vertex.glsl +++ b/shaders/drawable.fill_pattern.vertex.glsl @@ -1,7 +1,25 @@ -uniform mat4 u_matrix; -uniform vec2 u_pixel_coord_upper; -uniform vec2 u_pixel_coord_lower; -uniform vec4 u_scale; +layout (std140) uniform FillDrawableUBO { + highp mat4 u_matrix; + highp vec4 u_scale; + highp vec2 u_world; + highp vec2 u_pixel_coord_upper; + highp vec2 u_pixel_coord_lower; + highp vec2 u_texsize; + highp float u_fade; + + highp float u_color_t; + highp float u_opacity_t; + highp float u_outline_color_t; + highp float u_pattern_from_t; + highp float u_pattern_to_t; + + highp vec2 u_color; + highp vec2 u_opacity; + highp vec2 u_outline_color_pad; + highp vec4 u_outline_color; + highp vec4 u_pattern_from; + highp vec4 u_pattern_to; +}; layout (location = 0) in vec2 a_pos; diff --git a/shaders/manifest.json b/shaders/manifest.json index 2503588c2..9b78bf2ef 100644 --- a/shaders/manifest.json +++ b/shaders/manifest.json @@ -18,28 +18,28 @@ "header": "drawable_fill", "glsl_vert": "drawable.fill.vertex.glsl", "glsl_frag": "drawable.fill.fragment.glsl", - "uses_ubos": false + "uses_ubos": true }, { "name": "FillOutlineShader", "header": "drawable_fill_outline", "glsl_vert": "drawable.fill_outline.vertex.glsl", "glsl_frag": "drawable.fill_outline.fragment.glsl", - "uses_ubos": false + "uses_ubos": true }, { "name": "FillPatternShader", "header": "drawable_fill_pattern", "glsl_vert": "drawable.fill_pattern.vertex.glsl", "glsl_frag": "drawable.fill_pattern.fragment.glsl", - "uses_ubos": false + "uses_ubos": true }, { "name": "FillOutlinePatternShader", "header": "drawable_fill_outline_pattern", "glsl_vert": "drawable.fill_outline_pattern.vertex.glsl", "glsl_frag": "drawable.fill_outline_pattern.fragment.glsl", - "uses_ubos": false + "uses_ubos": true }, { diff --git a/src/mbgl/renderer/layers/fill_layer_tweaker.cpp b/src/mbgl/renderer/layers/fill_layer_tweaker.cpp index 16763f8ce..3a98528ef 100644 --- a/src/mbgl/renderer/layers/fill_layer_tweaker.cpp +++ b/src/mbgl/renderer/layers/fill_layer_tweaker.cpp @@ -14,13 +14,40 @@ using namespace style; struct alignas(16) FillDrawableUBO { std::array matrix; + /* 64 */ std::array scale; std::array world; - std::array padding; + /* 88 */ std::array pixel_coord_upper; + /* 96 */ std::array pixel_coord_lower; + /* 104 */ std::array texsize; + /* 112 */ float fade; + + // Attribute interpolations (used without HAS_UNIFORM_u_*) + /* 116 */ float color_t; + /* 120 */ float opacity_t; + /* 124 */ float outline_color_t; + /* 128 */ float pattern_from_t; + /* 132 */ float pattern_to_t; + + // Uniform alternates for attributes (used with HAS_UNIFORM_u_*) + /* 136 */ std::array color; + /* 144 */ std::array opacity; + /* 152 */ std::array outline_color_pad; + /* 160 */ std::array outline_color; + /* 176 */ std::array pattern_from; + /* 208 */ std::array pattern_to; + + // Pattern texture + /* ? */ // Drawable::TextureAttachment? image; + + /* */ // std::array padding; + /* 208 */ }; -static_assert(sizeof(FillDrawableUBO) % 16 == 0); +static_assert(sizeof(FillDrawableUBO) == 208); void FillLayerTweaker::execute(LayerGroup& layerGroup, const PaintParameters& parameters) { - // const auto& evaluated = static_cast(*evaluatedProperties).evaluated; + const auto& props = static_cast(*evaluatedProperties); + // const auto& evaluated = props.evaluated; + const auto& crossfade = props.crossfade; layerGroup.observeDrawables([&](gfx::Drawable& drawable) { if (!drawable.getTileID()) { @@ -48,11 +75,43 @@ void FillLayerTweaker::execute(LayerGroup& layerGroup, const PaintParameters& pa matrix::multiply(matrix, drawable.getMatrix(), tileMat); matrix = tileMat; - const auto renderableSize = parameters.backend.getDefaultRenderable().getSize(); + // matrix = tile.translatedMatrix(evaluated.get(), evaluated.get(), + // parameters.state), + + // from FillPatternProgram::layoutUniformValues + const auto renderableSize = parameters.backend.getDefaultRenderable().getSize(); + const auto intZoom = parameters.state.getIntegerZoom(); + const auto tileRatio = 1 / tileID.pixelsToTileUnits(1, intZoom); + const int32_t tileSizeAtNearestZoom = static_cast( + util::tileSize_D * parameters.state.zoomScale(intZoom - tileID.canonical.z)); + const int32_t pixelX = static_cast( + tileSizeAtNearestZoom * + (tileID.canonical.x + tileID.wrap * parameters.state.zoomScale(tileID.canonical.z))); + const int32_t pixelY = tileSizeAtNearestZoom * tileID.canonical.y; + const auto pixelRatio = parameters.pixelRatio; + + const FillDrawableUBO drawableUBO = { + /*.matrix=*/util::cast(matrix), + /*.scale=*/{pixelRatio, tileRatio, crossfade.fromScale, crossfade.toScale}, + /*.world=*/{(float)renderableSize.width, (float)renderableSize.height}, + /*.pixel_coord_upper=*/{static_cast(pixelX >> 16), static_cast(pixelY >> 16)}, + /*.pixel_coord_lower=*/{static_cast(pixelX & 0xFFFF), static_cast(pixelY & 0xFFFF)}, + /*.texsize=*/{0.0f, 0.0f}, // tile.getIconAtlasTexture().size + /*.fade=*/crossfade.t, + /*.color_t=*/0.0f, + /*.opacity_t=*/0.0f, + /*.outline_color_t=*/0.0f, + /*.pattern_from_t=*/0.0f, + /*.pattern_to_t=*/0.0f, + /*.color=*/{0.0f}, + /*.opacity=*/{0.0f}, + /*.outline_color_pad=*/{0.0f}, + /*.outline_color=*/{0.0f}, + /*.pattern_from=*/{0.0f}, + /*.pattern_to=*/{0.0f}, + /*.image=*/ // TextureAttachment(tile.getIconAtlasTexture().getResource(), Linear) + }; - FillDrawableUBO drawableUBO; - drawableUBO.matrix = util::cast(matrix); - drawableUBO.world = {(float)renderableSize.width, (float)renderableSize.height}; auto drawableUniformBuffer = parameters.context.createUniformBuffer(&drawableUBO, sizeof(drawableUBO)); drawable.mutableUniformBuffers().addOrReplace("FillDrawableUBO", drawableUniformBuffer); }); diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp index 673246ff6..977674e70 100644 --- a/src/mbgl/renderer/layers/render_fill_layer.cpp +++ b/src/mbgl/renderer/layers/render_fill_layer.cpp @@ -340,6 +340,16 @@ void RenderFillLayer::update(const int32_t layerIndex, gfx::VertexAttributeArray fillVertexAttrs; gfx::VertexAttributeArray outlineVertexAttrs; + const auto finish = [&](gfx::DrawableBuilder& builder, RenderPass pass, const OverscaledTileID& tileID) { + builder.flush(); + + for (auto& drawable : builder.clearDrawables()) { + drawable->setTileID(tileID); + tileLayerGroup->addDrawable(pass, tileID, std::move(drawable)); + ++stats.tileDrawablesAdded; + } + }; + for (const auto renderPass : {RenderPass::Opaque, RenderPass::Translucent}) { if (!(mbgl::underlying_type(renderPass) & evaluatedProperties->renderPasses)) { continue; @@ -370,6 +380,7 @@ void RenderFillLayer::update(const int32_t layerIndex, auto& bucket = static_cast(*renderData->bucket); const auto& evaluated = getEvaluated(renderData->layerProperties); + const auto& crossfade = getCrossfade(renderData->layerProperties); std::vector> rawVerts; const auto buildVertices = [&]() { @@ -512,14 +523,7 @@ void RenderFillLayer::update(const int32_t layerIndex, fillBuilder->addTriangles(bucket.triangles.vector(), seg.indexOffset, seg.indexLength); } - fillBuilder->flush(); - - for (auto& drawable : fillBuilder->clearDrawables()) { - drawable->setTileID(tileID); - - tileLayerGroup->addDrawable(renderPass, tileID, std::move(drawable)); - ++stats.tileDrawablesAdded; - } + finish(*fillBuilder, renderPass, tileID); } if (outlineBuilder) { buildVertices(); @@ -529,21 +533,13 @@ void RenderFillLayer::update(const int32_t layerIndex, outlineBuilder->addLines(bucket.lines.vector(), seg.indexOffset, seg.indexLength); } - outlineBuilder->flush(); - - for (auto& drawable : outlineBuilder->clearDrawables()) { - drawable->setTileID(tileID); - - tileLayerGroup->addDrawable(renderPass, tileID, std::move(drawable)); - ++stats.tileDrawablesAdded; - } + finish(*outlineBuilder, renderPass, tileID); } } else { // FillPattern is defined if (renderPass != RenderPass::Translucent) { continue; } - const auto& crossfade = getCrossfade(renderData->layerProperties); const auto doOutline = evaluated.get() && unevaluated.get().isUndefined(); const auto& fillPatternValue = evaluated.get().constantOr( @@ -560,7 +556,7 @@ void RenderFillLayer::update(const int32_t layerIndex, patternBuilder->setDepthType(gfx::DepthMaskType::ReadWrite); patternBuilder->setCullFaceMode(gfx::CullFaceMode::disabled()); patternBuilder->setLayerIndex(layerIndex); - outlinePatternBuilder->setSubLayerIndex(1); + patternBuilder->setSubLayerIndex(1); } if (doOutline && !outlinePatternBuilder && outlinePatternShader) { outlinePatternBuilder = context.createDrawableBuilder("fill-outline-pattern"); @@ -595,14 +591,7 @@ void RenderFillLayer::update(const int32_t layerIndex, patternBuilder->addTriangles(bucket.triangles.vector(), seg.indexOffset, seg.indexLength); } - patternBuilder->flush(); - - for (auto& drawable : patternBuilder->clearDrawables()) { - drawable->setTileID(tileID); - - // tileLayerGroup->addDrawable(renderPass, tileID, std::move(drawable)); - ++stats.tileDrawablesAdded; - } + finish(*patternBuilder, renderPass, tileID); } if (outlinePatternBuilder) { buildVertices(); @@ -612,14 +601,8 @@ void RenderFillLayer::update(const int32_t layerIndex, outlinePatternBuilder->addLines(bucket.lines.vector(), seg.indexOffset, seg.indexLength); } + finish(*outlinePatternBuilder, renderPass, tileID); outlinePatternBuilder->flush(); - - for (auto& drawable : outlinePatternBuilder->clearDrawables()) { - drawable->setTileID(tileID); - - // tileLayerGroup->addDrawable(renderPass, tileID, std::move(drawable)); - ++stats.tileDrawablesAdded; - } } // auto draw = [&](auto& programInstance,