From f24055a9f0c72ef7400d80146f4fb19d77b1ae0d Mon Sep 17 00:00:00 2001 From: Alex Cristici Date: Wed, 15 Nov 2023 08:14:54 +0200 Subject: [PATCH] Fixed metal background render tests (#1864) Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com> --- include/mbgl/shaders/background_layer_ubo.hpp | 9 ++- include/mbgl/shaders/mtl/background.hpp | 20 ++--- .../mbgl/shaders/mtl/background_pattern.hpp | 80 ++++++++++++++++++- .../layers/background_layer_tweaker.cpp | 10 ++- .../layers/render_background_layer.cpp | 4 +- src/mbgl/shaders/mtl/background.cpp | 4 +- src/mbgl/shaders/mtl/background_pattern.cpp | 16 ++-- 7 files changed, 119 insertions(+), 24 deletions(-) diff --git a/include/mbgl/shaders/background_layer_ubo.hpp b/include/mbgl/shaders/background_layer_ubo.hpp index 4e136acdf..3004e769a 100644 --- a/include/mbgl/shaders/background_layer_ubo.hpp +++ b/include/mbgl/shaders/background_layer_ubo.hpp @@ -15,7 +15,10 @@ static_assert(sizeof(BackgroundDrawableUBO) % 16 == 0); struct alignas(16) BackgroundLayerUBO { /* 0 */ Color color; /* 16 */ float opacity; - /* 20 */ float pad1, pad2, pad3; + // overdrawInspector is used only in Metal, while in GL this is a 16 bytes empty padding. + /* 20 */ bool overdrawInspector; + /* 21 */ uint8_t pad1, pad2, pad3; + /* 24 */ float pad4, pad5; /* 32 */ }; static_assert(sizeof(BackgroundLayerUBO) == 32); @@ -35,7 +38,9 @@ struct alignas(16) BackgroundPatternLayerUBO { /* 80 */ float scale_b; /* 84 */ float mix; /* 88 */ float opacity; - /* 92 */ float pad; + // overdrawInspector is used only in Metal, while in GL this is a 4 bytes empty padding. + /* 92 */ bool overdrawInspector; + /* 93 */ uint8_t pad1, pad2, pad3; /* 96 */ }; static_assert(sizeof(BackgroundPatternLayerUBO) == 96); diff --git a/include/mbgl/shaders/mtl/background.hpp b/include/mbgl/shaders/mtl/background.hpp index 5dc954ebe..e324b3c50 100644 --- a/include/mbgl/shaders/mtl/background.hpp +++ b/include/mbgl/shaders/mtl/background.hpp @@ -35,24 +35,26 @@ struct alignas(16) BackgroundDrawableUBO { }; struct alignas(16) BackgroundLayerUBO { float4 color; - float opacity, pad1, pad2, pad3; + float opacity; + bool overdrawInspector; + uint8_t pad1, pad2, pad3; + float pad4, pad5; }; FragmentStage vertex vertexMain(VertexStage in [[stage_in]], - device const BackgroundLayerUBO& layerUBO [[buffer(1)]], - device const BackgroundDrawableUBO& drawableUBO [[buffer(2)]]) { + device const BackgroundDrawableUBO& drawableUBO [[buffer(1)]]) { return { .position = drawableUBO.matrix * float4(float2(in.position.xy), 0, 1) }; } half4 fragment fragmentMain(FragmentStage in [[stage_in]], - device const BackgroundLayerUBO& layerUBO [[buffer(1)]]) { -#ifdef OVERDRAW_INSPECTOR - return half4(1.0); -#else - return half4(float4(layerUBO.color.rgb, layerUBO.color.a * layerUBO.opacity)); -#endif + device const BackgroundLayerUBO& layerUBO [[buffer(2)]]) { + if (layerUBO.overdrawInspector) { + return half4(0.0); + } + + return half4(layerUBO.color * layerUBO.opacity); } )"; }; diff --git a/include/mbgl/shaders/mtl/background_pattern.hpp b/include/mbgl/shaders/mtl/background_pattern.hpp index 8cbd69f68..9161f3886 100644 --- a/include/mbgl/shaders/mtl/background_pattern.hpp +++ b/include/mbgl/shaders/mtl/background_pattern.hpp @@ -6,10 +6,84 @@ namespace mbgl { namespace shaders { template <> -struct ShaderSource - : public ShaderSource { +struct ShaderSource { static constexpr auto name = "BackgroundPatternShader"; - static const std::array uniforms; + static constexpr auto vertexMainFunction = "vertexMain"; + static constexpr auto fragmentMainFunction = "fragmentMain"; + + static const std::array attributes; + static const std::array uniforms; + static const std::array textures; + + static constexpr auto source = R"( +#include +using namespace metal; + +struct VertexStage { + short2 position [[attribute(0)]]; +}; + +struct FragmentStage { + float4 position [[position, invariant]]; + float2 pos_a; + float2 pos_b; +}; + +struct alignas(16) BackgroundDrawableUBO { + float4x4 matrix; +}; +struct alignas(16) BackgroundLayerUBO { + float2 pattern_tl_a; + float2 pattern_br_a; + float2 pattern_tl_b; + float2 pattern_br_b; + float2 texsize; + float2 pattern_size_a; + float2 pattern_size_b; + float2 pixel_coord_upper; + float2 pixel_coord_lower; + float tile_units_to_pixels; + float scale_a; + float scale_b; + float mix; + float opacity; + bool overdrawInspector; + uint8_t pad1, pad2, pad3; +}; + +FragmentStage vertex vertexMain(VertexStage in [[stage_in]], + device const BackgroundDrawableUBO& drawableUBO [[buffer(1)]], + device const BackgroundLayerUBO& layerUBO [[buffer(2)]]) { + const float2 pos = float2(in.position); + float2 pos_a = get_pattern_pos(layerUBO.pixel_coord_upper, layerUBO.pixel_coord_lower, layerUBO.scale_a * layerUBO.pattern_size_a, layerUBO.tile_units_to_pixels, pos); + float2 pos_b = get_pattern_pos(layerUBO.pixel_coord_upper, layerUBO.pixel_coord_lower, layerUBO.scale_b * layerUBO.pattern_size_b, layerUBO.tile_units_to_pixels, pos); + + return { + .position = drawableUBO.matrix * float4(float2(in.position.xy), 0, 1), + .pos_a = pos_a, + .pos_b = pos_b + }; +} + +half4 fragment fragmentMain(FragmentStage in [[stage_in]], + device const BackgroundLayerUBO& layerUBO [[buffer(2)]], + texture2d image [[texture(0)]], + sampler image_sampler [[sampler(0)]]) { + if (layerUBO.overdrawInspector) { + return half4(0.0); + } + + float2 imagecoord = glMod(in.pos_a, 1.0); + float2 pos = mix(layerUBO.pattern_tl_a / layerUBO.texsize, layerUBO.pattern_br_a / layerUBO.texsize, imagecoord); + float4 color1 = image.sample(image_sampler, pos); + + float2 imagecoord_b = glMod(in.pos_b, 1.0); + float2 pos2 = mix(layerUBO.pattern_tl_b / layerUBO.texsize, layerUBO.pattern_br_b / layerUBO.texsize, imagecoord_b); + float4 color2 = image.sample(image_sampler, pos2); + + return half4(mix(color1, color2, layerUBO.mix) * layerUBO.opacity); +} +)"; }; } // namespace shaders diff --git a/src/mbgl/renderer/layers/background_layer_tweaker.cpp b/src/mbgl/renderer/layers/background_layer_tweaker.cpp index 8675161a0..74c577e58 100644 --- a/src/mbgl/renderer/layers/background_layer_tweaker.cpp +++ b/src/mbgl/renderer/layers/background_layer_tweaker.cpp @@ -109,7 +109,10 @@ void BackgroundLayerTweaker::execute(LayerGroupBase& layerGroup, const PaintPara /* .scale_b = */ crossfade.toScale, /* .mix = */ crossfade.t, /* .opacity = */ evaluated.get(), - /* .pad = */ 0, + /* .overdrawInspector = */ overdrawInspector, + /* .pad1/2/3 = */ 0, + 0, + 0, }; uniforms.createOrUpdate(idBackgroundLayerUBOName, &layerUBO, context); } else { @@ -117,8 +120,11 @@ void BackgroundLayerTweaker::execute(LayerGroupBase& layerGroup, const PaintPara if (!backgroundLayerBuffer) { const BackgroundLayerUBO layerUBO = {/* .color = */ evaluated.get(), /* .opacity = */ evaluated.get(), - /* .pad = */ 0, + /* .overdrawInspector = */ overdrawInspector, + /* .pad1/2/3 = */ 0, 0, + 0, + /* .pad4/5 = */ 0, 0}; backgroundLayerBuffer = context.createUniformBuffer(&layerUBO, sizeof(layerUBO)); } diff --git a/src/mbgl/renderer/layers/render_background_layer.cpp b/src/mbgl/renderer/layers/render_background_layer.cpp index 6f50db3d4..42e41432f 100644 --- a/src/mbgl/renderer/layers/render_background_layer.cpp +++ b/src/mbgl/renderer/layers/render_background_layer.cpp @@ -20,6 +20,7 @@ #include #include #include +#include #include #endif @@ -216,7 +217,7 @@ static constexpr std::string_view BackgroundPatternShaderName = "BackgroundPatte void RenderBackgroundLayer::update(gfx::ShaderRegistry& shaders, gfx::Context& context, const TransformState& state, - const std::shared_ptr&, + const std::shared_ptr& updateParameters, [[maybe_unused]] const RenderTree& renderTree, [[maybe_unused]] UniqueChangeRequestVec& changes) { std::unique_lock guard(mutex); @@ -261,6 +262,7 @@ void RenderBackgroundLayer::update(gfx::ShaderRegistry& shaders, layerTweaker = std::make_shared(getID(), evaluatedProperties); layerGroup->addLayerTweaker(layerTweaker); } + layerTweaker->enableOverdrawInspector(!!(updateParameters->debugOptions & MapDebugOptions::Overdraw)); if (!hasPattern && !plainShader) { plainShader = context.getGenericShader(shaders, std::string(BackgroundPlainShaderName)); diff --git a/src/mbgl/shaders/mtl/background.cpp b/src/mbgl/shaders/mtl/background.cpp index 9eec3d3c1..53f79a122 100644 --- a/src/mbgl/shaders/mtl/background.cpp +++ b/src/mbgl/shaders/mtl/background.cpp @@ -8,8 +8,8 @@ const std::array ShaderSource ShaderSource::uniforms = { - UniformBlockInfo{1, true, true, sizeof(BackgroundLayerUBO), "BackgroundLayerUBO"}, - UniformBlockInfo{2, true, false, sizeof(BackgroundDrawableUBO), "BackgroundDrawableUBO"}, + UniformBlockInfo{1, true, false, sizeof(BackgroundDrawableUBO), "BackgroundDrawableUBO"}, + UniformBlockInfo{2, false, true, sizeof(BackgroundLayerUBO), "BackgroundLayerUBO"}, }; const std::array ShaderSource::textures = {}; diff --git a/src/mbgl/shaders/mtl/background_pattern.cpp b/src/mbgl/shaders/mtl/background_pattern.cpp index 88aff4809..f7429e528 100644 --- a/src/mbgl/shaders/mtl/background_pattern.cpp +++ b/src/mbgl/shaders/mtl/background_pattern.cpp @@ -1,14 +1,20 @@ #include +#include namespace mbgl { namespace shaders { -const std::array - ShaderSource::uniforms = { - UniformBlockInfo{1, sizeof(BackgroundLayerUBO), true, false, "BackgroundLayerUBO"}, - UniformBlockInfo{2, sizeof(BackgroundDrawableUBO), true, false, "BackgroundDrawableUBO"}, - UniformBlockInfo{3, sizeof(BackgroundPatternLayerUBO), true, false, "BackgroundLayerUBO"}, +const std::array + ShaderSource::attributes = { + AttributeInfo{0, gfx::AttributeDataType::Float3, 1, "a_pos"}, }; +const std::array + ShaderSource::uniforms = { + UniformBlockInfo{1, true, false, sizeof(BackgroundDrawableUBO), "BackgroundDrawableUBO"}, + UniformBlockInfo{2, true, true, sizeof(BackgroundPatternLayerUBO), "BackgroundLayerUBO"}, +}; +const std::array ShaderSource::textures = { + TextureInfo{0, "u_image"}}; } // namespace shaders } // namespace mbgl