From 93e54d6566eda9ca0b261b52432b6d0e7b16d9e6 Mon Sep 17 00:00:00 2001 From: mwilsnd Date: Tue, 27 Aug 2024 16:06:33 -0400 Subject: [PATCH] more tests --- include/mbgl/gfx/context_observer.hpp | 17 +-- include/mbgl/map/map_observer.hpp | 6 +- include/mbgl/renderer/renderer_observer.hpp | 6 +- include/mbgl/tile/tile_operation.hpp | 4 +- .../src/cpp/android_renderer_frontend.cpp | 12 +- .../src/cpp/native_map_view.cpp | 21 ++-- .../src/cpp/native_map_view.hpp | 6 +- .../src/cpp/tile/tile_operation.cpp | 6 +- .../android/maps/MapChangeReceiver.java | 12 +- .../org/maplibre/android/maps/MapView.java | 9 +- .../maplibre/android/maps/NativeMapView.java | 18 +-- .../maplibre/android/tile/TileOperation.java | 3 +- src/mbgl/map/map_impl.cpp | 12 +- src/mbgl/map/map_impl.hpp | 6 +- src/mbgl/mtl/context.cpp | 14 ++- src/mbgl/renderer/renderer_impl.cpp | 12 +- src/mbgl/renderer/renderer_impl.hpp | 6 +- src/mbgl/shaders/gl/shader_program_gl.cpp | 6 +- src/mbgl/shaders/vulkan/shader_program.cpp | 17 +-- src/mbgl/tile/geometry_tile.cpp | 10 +- src/mbgl/tile/geometry_tile.hpp | 6 - src/mbgl/tile/raster_dem_tile.cpp | 11 +- src/mbgl/tile/raster_dem_tile.hpp | 2 - src/mbgl/tile/raster_tile.cpp | 11 +- src/mbgl/tile/raster_tile.hpp | 2 - src/mbgl/tile/tile_loader.hpp | 1 - src/mbgl/tile/tile_loader_impl.hpp | 11 +- src/mbgl/vulkan/context.cpp | 2 - test/map/map.test.cpp | 108 ++++++++++++++---- test/src/mbgl/test/stub_map_observer.hpp | 18 +-- 30 files changed, 208 insertions(+), 167 deletions(-) diff --git a/include/mbgl/gfx/context_observer.hpp b/include/mbgl/gfx/context_observer.hpp index 3ba3a74269c..5e0ca2eb985 100644 --- a/include/mbgl/gfx/context_observer.hpp +++ b/include/mbgl/gfx/context_observer.hpp @@ -3,25 +3,16 @@ #include #include -#include +#include namespace mbgl { namespace gfx { class ContextObserver { public: - virtual void onPreCompileShader(shaders::BuiltIn, gfx::Backend::Type){}; - virtual void onPostCompileShader(shaders::BuiltIn, gfx::Backend::Type){}; - virtual void onShaderCompileFailed(shaders::BuiltIn, gfx::Backend::Type){}; - - virtual void onPreUploadTexture(gfx::Backend::Type){}; - virtual void onPostUploadTexture(gfx::Backend::Type){}; - - virtual void onPreUploadUBO(gfx::Backend::Type){}; - virtual void onPostUploadUBO(gfx::Backend::Type){}; - - virtual void onPreCreateRenderPipelineState(gfx::Backend::Type){}; - virtual void onPostCreateRenderPipelineState(gfx::Backend::Type){}; + virtual void onPreCompileShader(shaders::BuiltIn, gfx::Backend::Type, const std::string&) {} + virtual void onPostCompileShader(shaders::BuiltIn, gfx::Backend::Type, const std::string&) {} + virtual void onShaderCompileFailed(shaders::BuiltIn, gfx::Backend::Type, const std::string&) {} }; } // namespace gfx diff --git a/include/mbgl/map/map_observer.hpp b/include/mbgl/map/map_observer.hpp index 667356f71a6..49b5ffcf3df 100644 --- a/include/mbgl/map/map_observer.hpp +++ b/include/mbgl/map/map_observer.hpp @@ -73,9 +73,9 @@ class MapObserver { virtual void onRegisterShaders(gfx::ShaderRegistry&) {}; // Shaders compilation - virtual void onPreCompileShader(shaders::BuiltIn, gfx::Backend::Type) {} - virtual void onPostCompileShader(shaders::BuiltIn, gfx::Backend::Type) {} - virtual void onShaderCompileFailed(shaders::BuiltIn, gfx::Backend::Type) {} + virtual void onPreCompileShader(shaders::BuiltIn, gfx::Backend::Type, const std::string&) {} + virtual void onPostCompileShader(shaders::BuiltIn, gfx::Backend::Type, const std::string&) {} + virtual void onShaderCompileFailed(shaders::BuiltIn, gfx::Backend::Type, const std::string&) {} // Glyph requests virtual void onGlyphsLoaded(const FontStack&, const GlyphRange&) {} diff --git a/include/mbgl/renderer/renderer_observer.hpp b/include/mbgl/renderer/renderer_observer.hpp index 0bcd9ae5b27..5cb107356f9 100644 --- a/include/mbgl/renderer/renderer_observer.hpp +++ b/include/mbgl/renderer/renderer_observer.hpp @@ -61,9 +61,9 @@ class RendererObserver { // Entry point for custom shader registration virtual void onRegisterShaders(gfx::ShaderRegistry&) {}; - virtual void onPreCompileShader(shaders::BuiltIn, gfx::Backend::Type){}; - virtual void onPostCompileShader(shaders::BuiltIn, gfx::Backend::Type){}; - virtual void onShaderCompileFailed(shaders::BuiltIn, gfx::Backend::Type){}; + virtual void onPreCompileShader(shaders::BuiltIn, gfx::Backend::Type, const std::string&){}; + virtual void onPostCompileShader(shaders::BuiltIn, gfx::Backend::Type, const std::string&){}; + virtual void onShaderCompileFailed(shaders::BuiltIn, gfx::Backend::Type, const std::string&){}; // Glyph loading virtual void onGlyphsLoaded(const FontStack&, const GlyphRange&) {} diff --git a/include/mbgl/tile/tile_operation.hpp b/include/mbgl/tile/tile_operation.hpp index 46a7afb64cc..766b493e82a 100644 --- a/include/mbgl/tile/tile_operation.hpp +++ b/include/mbgl/tile/tile_operation.hpp @@ -3,12 +3,14 @@ namespace mbgl { enum class TileOperation : uint8_t { - Requested, + RequestedFromCache, + RequestedFromNetwork, LoadFromNetwork, LoadFromCache, StartParse, EndParse, Error, Cancelled, + NullOp, }; } // namespace mbgl diff --git a/platform/android/MapLibreAndroid/src/cpp/android_renderer_frontend.cpp b/platform/android/MapLibreAndroid/src/cpp/android_renderer_frontend.cpp index 2e666d91104..224debc4251 100644 --- a/platform/android/MapLibreAndroid/src/cpp/android_renderer_frontend.cpp +++ b/platform/android/MapLibreAndroid/src/cpp/android_renderer_frontend.cpp @@ -53,16 +53,16 @@ class ForwardingRendererObserver : public RendererObserver { delegate.invoke(&RendererObserver::onRemoveUnusedStyleImages, ids); } - void onPreCompileShader(mbgl::shaders::BuiltIn id, mbgl::gfx::Backend::Type type) override { - delegate.invoke(&RendererObserver::onPreCompileShader, id, type); + void onPreCompileShader(mbgl::shaders::BuiltIn id, mbgl::gfx::Backend::Type type, const std::string& additionalDefines) override { + delegate.invoke(&RendererObserver::onPreCompileShader, id, type, additionalDefines); } - void onPostCompileShader(mbgl::shaders::BuiltIn id, mbgl::gfx::Backend::Type type) override { - delegate.invoke(&RendererObserver::onPostCompileShader, id, type); + void onPostCompileShader(mbgl::shaders::BuiltIn id, mbgl::gfx::Backend::Type type, const std::string& additionalDefines) override { + delegate.invoke(&RendererObserver::onPostCompileShader, id, type, additionalDefines); } - void onShaderCompileFailed(mbgl::shaders::BuiltIn id, mbgl::gfx::Backend::Type type) override { - delegate.invoke(&RendererObserver::onShaderCompileFailed, id, type); + void onShaderCompileFailed(mbgl::shaders::BuiltIn id, mbgl::gfx::Backend::Type type, const std::string& additionalDefines) override { + delegate.invoke(&RendererObserver::onShaderCompileFailed, id, type, additionalDefines); } void onGlyphsLoaded(const mbgl::FontStack& stack, const mbgl::GlyphRange& range) override { diff --git a/platform/android/MapLibreAndroid/src/cpp/native_map_view.cpp b/platform/android/MapLibreAndroid/src/cpp/native_map_view.cpp index 0019ce2ee19..e74bd1d43ef 100644 --- a/platform/android/MapLibreAndroid/src/cpp/native_map_view.cpp +++ b/platform/android/MapLibreAndroid/src/cpp/native_map_view.cpp @@ -1345,39 +1345,42 @@ void NativeMapView::registerNative(jni::JNIEnv& env) { void NativeMapView::onRegisterShaders(gfx::ShaderRegistry&) {}; // Shader compilation -void NativeMapView::onPreCompileShader(shaders::BuiltIn id, gfx::Backend::Type type) { +void NativeMapView::onPreCompileShader(shaders::BuiltIn id, gfx::Backend::Type type, const std::string& additionalDefines) { assert(vm != nullptr); android::UniqueEnv _env = android::AttachEnv(); static auto& javaClass = jni::Class::Singleton(*_env); - static auto onPreCompileShader = javaClass.GetMethod(*_env, "onPreCompileShader"); + static auto onPreCompileShader = javaClass.GetMethod(*_env, "onPreCompileShader"); auto weakReference = javaPeer.get(*_env); if (weakReference) { - weakReference.Call(*_env, onPreCompileShader, static_cast(id), static_cast(type)); + weakReference.Call(*_env, onPreCompileShader, static_cast(id), static_cast(type), + jni::Make(additionalDefines)); } } -void NativeMapView::onPostCompileShader(shaders::BuiltIn id, gfx::Backend::Type type) { +void NativeMapView::onPostCompileShader(shaders::BuiltIn id, gfx::Backend::Type type, const std::string& additionalDefines) { assert(vm != nullptr); android::UniqueEnv _env = android::AttachEnv(); static auto& javaClass = jni::Class::Singleton(*_env); - static auto onPostCompileShader = javaClass.GetMethod(*_env, "onPostCompileShader"); + static auto onPostCompileShader = javaClass.GetMethod(*_env, "onPostCompileShader"); auto weakReference = javaPeer.get(*_env); if (weakReference) { - weakReference.Call(*_env, onPostCompileShader, static_cast(id), static_cast(type)); + weakReference.Call(*_env, onPostCompileShader, static_cast(id), static_cast(type), + jni::Make(additionalDefines)); } } -void NativeMapView::onShaderCompileFailed(shaders::BuiltIn id, gfx::Backend::Type type) { +void NativeMapView::onShaderCompileFailed(shaders::BuiltIn id, gfx::Backend::Type type, const std::string& additionalDefines) { assert(vm != nullptr); android::UniqueEnv _env = android::AttachEnv(); static auto& javaClass = jni::Class::Singleton(*_env); - static auto onShaderCompileFailed = javaClass.GetMethod(*_env, "onShaderCompileFailed"); + static auto onShaderCompileFailed = javaClass.GetMethod(*_env, "onShaderCompileFailed"); auto weakReference = javaPeer.get(*_env); if (weakReference) { - weakReference.Call(*_env, onShaderCompileFailed, static_cast(id), static_cast(type)); + weakReference.Call(*_env, onShaderCompileFailed, static_cast(id), static_cast(type), + jni::Make(additionalDefines)); } } diff --git a/platform/android/MapLibreAndroid/src/cpp/native_map_view.hpp b/platform/android/MapLibreAndroid/src/cpp/native_map_view.hpp index ddb8187fc5a..7ec2a4dd359 100644 --- a/platform/android/MapLibreAndroid/src/cpp/native_map_view.hpp +++ b/platform/android/MapLibreAndroid/src/cpp/native_map_view.hpp @@ -301,9 +301,9 @@ class NativeMapView : public MapObserver { // Shader compilation void onRegisterShaders(mbgl::gfx::ShaderRegistry&) override; - void onPreCompileShader(mbgl::shaders::BuiltIn, mbgl::gfx::Backend::Type) override; - void onPostCompileShader(mbgl::shaders::BuiltIn, mbgl::gfx::Backend::Type) override; - void onShaderCompileFailed(mbgl::shaders::BuiltIn, mbgl::gfx::Backend::Type) override; + void onPreCompileShader(mbgl::shaders::BuiltIn, mbgl::gfx::Backend::Type, const std::string&) override; + void onPostCompileShader(mbgl::shaders::BuiltIn, mbgl::gfx::Backend::Type, const std::string&) override; + void onShaderCompileFailed(mbgl::shaders::BuiltIn, mbgl::gfx::Backend::Type, const std::string&) override; // Glyph requests void onGlyphsLoaded(const mbgl::FontStack&, const mbgl::GlyphRange&) override; diff --git a/platform/android/MapLibreAndroid/src/cpp/tile/tile_operation.cpp b/platform/android/MapLibreAndroid/src/cpp/tile/tile_operation.cpp index a8e4f300853..a0c05d8f6b9 100644 --- a/platform/android/MapLibreAndroid/src/cpp/tile/tile_operation.cpp +++ b/platform/android/MapLibreAndroid/src/cpp/tile/tile_operation.cpp @@ -6,8 +6,10 @@ namespace android { jni::Local> TileOperation::Create(jni::JNIEnv& env, mbgl::TileOperation op) { static auto& _class = jni::Class::Singleton(env); switch (op) { - case mbgl::TileOperation::Requested: - return _class.Get(env, _class.GetStaticField>(env, "Requested")); + case mbgl::TileOperation::RequestedFromNetwork: + return _class.Get(env, _class.GetStaticField>(env, "RequestedFromNetwork")); + case mbgl::TileOperation::RequestedFromCache: + return _class.Get(env, _class.GetStaticField>(env, "RequestedFromCache")); case mbgl::TileOperation::LoadFromCache: return _class.Get(env, _class.GetStaticField>(env, "LoadFromCache")); case mbgl::TileOperation::LoadFromNetwork: diff --git a/platform/android/MapLibreAndroid/src/main/java/org/maplibre/android/maps/MapChangeReceiver.java b/platform/android/MapLibreAndroid/src/main/java/org/maplibre/android/maps/MapChangeReceiver.java index 4041be37c73..68091dadb3c 100644 --- a/platform/android/MapLibreAndroid/src/main/java/org/maplibre/android/maps/MapChangeReceiver.java +++ b/platform/android/MapLibreAndroid/src/main/java/org/maplibre/android/maps/MapChangeReceiver.java @@ -277,11 +277,11 @@ public boolean onCanRemoveUnusedStyleImage(String imageId) { } @Override - public void onPreCompileShader(int id, int type) { + public void onPreCompileShader(int id, int type, String additionalDefines) { try { if (!onPreCompileShaderList.isEmpty()) { for (MapView.OnPreCompileShaderListener listener : onPreCompileShaderList) { - listener.onPreCompileShader(id, type); + listener.onPreCompileShader(id, type, additionalDefines); } } } catch (Throwable err) { @@ -291,11 +291,11 @@ public void onPreCompileShader(int id, int type) { } @Override - public void onPostCompileShader(int id, int type) { + public void onPostCompileShader(int id, int type, String additionalDefines) { try { if (!onPostCompileShaderList.isEmpty()) { for (MapView.OnPostCompileShaderListener listener : onPostCompileShaderList) { - listener.onPostCompileShader(id, type); + listener.onPostCompileShader(id, type, additionalDefines); } } } catch (Throwable err) { @@ -305,11 +305,11 @@ public void onPostCompileShader(int id, int type) { } @Override - public void onShaderCompileFailed(int id, int type) { + public void onShaderCompileFailed(int id, int type, String additionalDefines) { try { if (!onShaderCompileFailedList.isEmpty()) { for (MapView.OnShaderCompileFailedListener listener : onShaderCompileFailedList) { - listener.onShaderCompileFailed(id, type); + listener.onShaderCompileFailed(id, type, additionalDefines); } } } catch (Throwable err) { diff --git a/platform/android/MapLibreAndroid/src/main/java/org/maplibre/android/maps/MapView.java b/platform/android/MapLibreAndroid/src/main/java/org/maplibre/android/maps/MapView.java index 21efdd6f624..bedfb0577ff 100644 --- a/platform/android/MapLibreAndroid/src/main/java/org/maplibre/android/maps/MapView.java +++ b/platform/android/MapLibreAndroid/src/main/java/org/maplibre/android/maps/MapView.java @@ -1318,8 +1318,9 @@ public interface OnPreCompileShaderListener { * of possible values. * @param type of graphics backend the shader is being compiled for. See * `mbgl::gfx::Backend::Type` for a list of possible values. + * @param additionalDefines that specify the permutaion of the shader. */ - void onPreCompileShader(int id, int type); + void onPreCompileShader(int id, int type, String additionalDefines); } /** @@ -1336,8 +1337,9 @@ public interface OnPostCompileShaderListener { * of possible values. * @param type of graphics backend the shader is being compiled for. See * `mbgl::gfx::Backend::Type` for a list of possible values. + * @param additionalDefines that specify the permutation of the shader. */ - void onPostCompileShader(int id, int type); + void onPostCompileShader(int id, int type, String additionalDefines); } /** @@ -1354,8 +1356,9 @@ public interface OnShaderCompileFailedListener { * of possible values. * @param type of graphics backend the shader is being compiled for. See * `mbgl::gfx::Backend::Type` for a list of possible values. + * @param additionalDefines that specify the permutation of the shader. */ - void onShaderCompileFailed(int id, int type); + void onShaderCompileFailed(int id, int type, String additionalDefines); } /** diff --git a/platform/android/MapLibreAndroid/src/main/java/org/maplibre/android/maps/NativeMapView.java b/platform/android/MapLibreAndroid/src/main/java/org/maplibre/android/maps/NativeMapView.java index 968e81c4f81..09797905eb4 100755 --- a/platform/android/MapLibreAndroid/src/main/java/org/maplibre/android/maps/NativeMapView.java +++ b/platform/android/MapLibreAndroid/src/main/java/org/maplibre/android/maps/NativeMapView.java @@ -1196,23 +1196,23 @@ protected void onSnapshotReady(@Nullable Bitmap mapContent) { } @Keep - private void onPreCompileShader(int id, int type) { + private void onPreCompileShader(int id, int type, String additionalDefines) { if (stateCallback != null) { - stateCallback.onPreCompileShader(id, type); + stateCallback.onPreCompileShader(id, type, additionalDefines); } } @Keep - private void onPostCompileShader(int id, int type) { + private void onPostCompileShader(int id, int type, String additionalDefines) { if (stateCallback != null) { - stateCallback.onPostCompileShader(id, type); + stateCallback.onPostCompileShader(id, type, additionalDefines); } } @Keep - private void onShaderCompileFailed(int id, int type) { + private void onShaderCompileFailed(int id, int type, String additionalDefines) { if (stateCallback != null) { - stateCallback.onShaderCompileFailed(id, type); + stateCallback.onShaderCompileFailed(id, type, additionalDefines); } } @@ -1693,11 +1693,11 @@ interface StateCallback extends StyleCallback { boolean onCanRemoveUnusedStyleImage(String imageId); - void onPreCompileShader(int id, int type); + void onPreCompileShader(int id, int type, String additionalDefines); - void onPostCompileShader(int id, int type); + void onPostCompileShader(int id, int type, String additionalDefines); - void onShaderCompileFailed(int id, int type); + void onShaderCompileFailed(int id, int type, String additionalDefines); void onGlyphsLoaded(String[] stack, int rangeStart, int rangeEnd); diff --git a/platform/android/MapLibreAndroid/src/main/java/org/maplibre/android/tile/TileOperation.java b/platform/android/MapLibreAndroid/src/main/java/org/maplibre/android/tile/TileOperation.java index 0265a87d64d..b7493222f70 100644 --- a/platform/android/MapLibreAndroid/src/main/java/org/maplibre/android/tile/TileOperation.java +++ b/platform/android/MapLibreAndroid/src/main/java/org/maplibre/android/tile/TileOperation.java @@ -1,7 +1,8 @@ package org.maplibre.android.tile; public enum TileOperation { - Requested, + RequestedFromCache, + RequestedFromNetwork., LoadFromNetwork, LoadFromCache, StartParse, diff --git a/src/mbgl/map/map_impl.cpp b/src/mbgl/map/map_impl.cpp index 9fd76521c51..df782a9d9ee 100644 --- a/src/mbgl/map/map_impl.cpp +++ b/src/mbgl/map/map_impl.cpp @@ -244,16 +244,16 @@ void Map::Impl::onRegisterShaders(gfx::ShaderRegistry& registry) { observer.onRegisterShaders(registry); } -void Map::Impl::onPreCompileShader(shaders::BuiltIn shaderID, gfx::Backend::Type type) { - observer.onPreCompileShader(shaderID, type); +void Map::Impl::onPreCompileShader(shaders::BuiltIn shaderID, gfx::Backend::Type type, const std::string& additionalDefines) { + observer.onPreCompileShader(shaderID, type, additionalDefines); } -void Map::Impl::onPostCompileShader(shaders::BuiltIn shaderID, gfx::Backend::Type type) { - observer.onPostCompileShader(shaderID, type); +void Map::Impl::onPostCompileShader(shaders::BuiltIn shaderID, gfx::Backend::Type type, const std::string& additionalDefines) { + observer.onPostCompileShader(shaderID, type, additionalDefines); } -void Map::Impl::onShaderCompileFailed(shaders::BuiltIn shaderID, gfx::Backend::Type type) { - observer.onShaderCompileFailed(shaderID, type); +void Map::Impl::onShaderCompileFailed(shaders::BuiltIn shaderID, gfx::Backend::Type type, const std::string& additionalDefines) { + observer.onShaderCompileFailed(shaderID, type, additionalDefines); } void Map::Impl::onGlyphsLoaded(const FontStack& fontStack, const GlyphRange& ranges) { diff --git a/src/mbgl/map/map_impl.hpp b/src/mbgl/map/map_impl.hpp index 076980f6e6d..d093b30f227 100644 --- a/src/mbgl/map/map_impl.hpp +++ b/src/mbgl/map/map_impl.hpp @@ -56,9 +56,9 @@ class Map::Impl final : public style::Observer, public RendererObserver { void onRemoveUnusedStyleImages(const std::vector&) final; void onRegisterShaders(gfx::ShaderRegistry&) final; - void onPreCompileShader(shaders::BuiltIn, gfx::Backend::Type) final; - void onPostCompileShader(shaders::BuiltIn, gfx::Backend::Type) final; - void onShaderCompileFailed(shaders::BuiltIn, gfx::Backend::Type) final; + void onPreCompileShader(shaders::BuiltIn, gfx::Backend::Type, const std::string&) final; + void onPostCompileShader(shaders::BuiltIn, gfx::Backend::Type, const std::string&) final; + void onShaderCompileFailed(shaders::BuiltIn, gfx::Backend::Type, const std::string&) final; void onGlyphsLoaded(const FontStack&, const GlyphRange&) final; void onGlyphsError(const FontStack&, const GlyphRange&, std::exception_ptr) final; void onGlyphsRequested(const FontStack&, const GlyphRange&) final; diff --git a/src/mbgl/mtl/context.cpp b/src/mbgl/mtl/context.cpp index cba9bcbab14..d56f13e3a36 100644 --- a/src/mbgl/mtl/context.cpp +++ b/src/mbgl/mtl/context.cpp @@ -94,14 +94,13 @@ UniqueShaderProgram Context::createProgram(shaders::BuiltIn shaderID, const std::string_view fragmentName, const ProgramParameters& programParameters, const mbgl::unordered_map& additionalDefines) { - observer->onPreCompileShader(shaderID, gfx::Backend::Type::Metal); - const auto pool = NS::TransferPtr(NS::AutoreleasePool::alloc()->init()); // No NSMutableDictionary? const auto& programDefines = programParameters.getDefines(); const auto numDefines = programDefines.size() + additionalDefines.size(); + std::string defineStr; std::vector rawDefines; rawDefines.reserve(2 * numDefines); const auto addDefine = [&rawDefines](const auto& pair) { @@ -109,10 +108,13 @@ UniqueShaderProgram Context::createProgram(shaders::BuiltIn shaderID, const auto* nsVal = NS::String::string(pair.second.data(), NS::UTF8StringEncoding); rawDefines.insert(std::next(rawDefines.begin(), rawDefines.size() / 2), nsKey); rawDefines.insert(rawDefines.end(), nsVal); + defineStr += "#define " + pair.first + " " + pair.second + "\n"; }; std::for_each(programDefines.begin(), programDefines.end(), addDefine); std::for_each(additionalDefines.begin(), additionalDefines.end(), addDefine); + observer->onPreCompileShader(shaderID, gfx::Backend::Type::Metal, defineStr); + const auto nsDefines = NS::Dictionary::dictionary( &rawDefines[numDefines], rawDefines.data(), static_cast(numDefines)); rawDefines.clear(); @@ -145,7 +147,7 @@ UniqueShaderProgram Context::createProgram(shaders::BuiltIn shaderID, const auto errPtr = error ? error->localizedDescription()->utf8String() : nullptr; const auto errStr = (errPtr && errPtr[0]) ? ": " + std::string(errPtr) : std::string(); Log::Error(Event::Shader, name + " compile failed" + errStr); - observer->onShaderCompileFailed(shaderID, gfx::Backend::Type::Metal); + observer->onShaderCompileFailed(shaderID, gfx::Backend::Type::Metal, defineStr); assert(false); return nullptr; } @@ -154,7 +156,7 @@ UniqueShaderProgram Context::createProgram(shaders::BuiltIn shaderID, MTLFunctionPtr vertexFunction = NS::TransferPtr(library->newFunction(nsVertName)); if (!vertexFunction) { Log::Error(Event::Shader, name + " missing vertex function " + vertexName.data()); - observer->onShaderCompileFailed(shaderID, gfx::Backend::Type::Metal); + observer->onShaderCompileFailed(shaderID, gfx::Backend::Type::Metal, defineStr); assert(false); return nullptr; } @@ -166,7 +168,7 @@ UniqueShaderProgram Context::createProgram(shaders::BuiltIn shaderID, fragmentFunction = NS::TransferPtr(library->newFunction(nsFragName)); if (!fragmentFunction) { Log::Error(Event::Shader, name + " missing fragment function " + fragmentName.data()); - observer->onShaderCompileFailed(shaderID, gfx::Backend::Type::Metal); + observer->onShaderCompileFailed(shaderID, gfx::Backend::Type::Metal, additionalDefines); assert(false); return nullptr; } @@ -174,7 +176,7 @@ UniqueShaderProgram Context::createProgram(shaders::BuiltIn shaderID, auto shader = std::make_unique( std::move(name), backend, std::move(vertexFunction), std::move(fragmentFunction)); - observer->onPostCompileShader(shaderID, gfx::Backend::Type::Metal); + observer->onPostCompileShader(shaderID, gfx::Backend::Type::Metal, defineStr); return shader; } diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp index 3028dc2bfd9..2e2acbaf740 100644 --- a/src/mbgl/renderer/renderer_impl.cpp +++ b/src/mbgl/renderer/renderer_impl.cpp @@ -68,16 +68,16 @@ Renderer::Impl::~Impl() { assert(gfx::BackendScope::exists()); }; -void Renderer::Impl::onPreCompileShader(shaders::BuiltIn shaderID, gfx::Backend::Type type) { - observer->onPreCompileShader(shaderID, type); +void Renderer::Impl::onPreCompileShader(shaders::BuiltIn shaderID, gfx::Backend::Type type, const std::string& additionalDefines) { + observer->onPreCompileShader(shaderID, type, additionalDefines); } -void Renderer::Impl::onPostCompileShader(shaders::BuiltIn shaderID, gfx::Backend::Type type) { - observer->onPostCompileShader(shaderID, type); +void Renderer::Impl::onPostCompileShader(shaders::BuiltIn shaderID, gfx::Backend::Type type, const std::string& additionalDefines) { + observer->onPostCompileShader(shaderID, type, additionalDefines); } -void Renderer::Impl::onShaderCompileFailed(shaders::BuiltIn shaderID, gfx::Backend::Type type) { - observer->onShaderCompileFailed(shaderID, type); +void Renderer::Impl::onShaderCompileFailed(shaders::BuiltIn shaderID, gfx::Backend::Type type, const std::string& additionalDefines) { + observer->onShaderCompileFailed(shaderID, type, additionalDefines); } void Renderer::Impl::setObserver(RendererObserver* observer_) { diff --git a/src/mbgl/renderer/renderer_impl.hpp b/src/mbgl/renderer/renderer_impl.hpp index c753e19db89..c34de65c3af 100644 --- a/src/mbgl/renderer/renderer_impl.hpp +++ b/src/mbgl/renderer/renderer_impl.hpp @@ -28,9 +28,9 @@ class Renderer::Impl : public gfx::ContextObserver { virtual ~Impl(); // ContextObserver - void onPreCompileShader(shaders::BuiltIn, gfx::Backend::Type) override; - void onPostCompileShader(shaders::BuiltIn, gfx::Backend::Type) override; - void onShaderCompileFailed(shaders::BuiltIn, gfx::Backend::Type) override; + void onPreCompileShader(shaders::BuiltIn, gfx::Backend::Type, const std::string&) override; + void onPostCompileShader(shaders::BuiltIn, gfx::Backend::Type, const std::string&) override; + void onShaderCompileFailed(shaders::BuiltIn, gfx::Backend::Type, const std::string&) override; private: friend class Renderer; diff --git a/src/mbgl/shaders/gl/shader_program_gl.cpp b/src/mbgl/shaders/gl/shader_program_gl.cpp index 545c53153fe..b90375a0e66 100644 --- a/src/mbgl/shaders/gl/shader_program_gl.cpp +++ b/src/mbgl/shaders/gl/shader_program_gl.cpp @@ -119,7 +119,7 @@ std::shared_ptr ShaderProgramGL::create( const std::string& fragmentSource, const std::string& additionalDefines) noexcept(false) { try { - context.getObserver().onPreCompileShader(programParameters.getProgramType(), gfx::Backend::Type::OpenGL); + context.getObserver().onPreCompileShader(programParameters.getProgramType(), gfx::Backend::Type::OpenGL, additionalDefines); // throws on compile error auto vertProg = context.createShader( @@ -139,7 +139,7 @@ std::shared_ptr ShaderProgramGL::create( fragmentSource.c_str()}); auto program = context.createProgram(vertProg, fragProg, firstAttribName.data()); - context.getObserver().onPostCompileShader(programParameters.getProgramType(), gfx::Backend::Type::OpenGL); + context.getObserver().onPostCompileShader(programParameters.getProgramType(), gfx::Backend::Type::OpenGL, additionalDefines); UniformBlockArrayGL uniformBlocks; for (const auto& blockInfo : uniformBlocksInfo) { @@ -183,7 +183,7 @@ std::shared_ptr ShaderProgramGL::create( return std::make_shared( std::move(program), std::move(uniformBlocks), std::move(attrs), std::move(samplerLocations)); } catch (const std::exception& e) { - context.getObserver().onShaderCompileFailed(programParameters.getProgramType(), gfx::Backend::Type::OpenGL); + context.getObserver().onShaderCompileFailed(programParameters.getProgramType(), gfx::Backend::Type::OpenGL, additionalDefines); std::rethrow_exception(std::current_exception()); } } diff --git a/src/mbgl/shaders/vulkan/shader_program.cpp b/src/mbgl/shaders/vulkan/shader_program.cpp index 4efc91828c5..af49438dcc5 100644 --- a/src/mbgl/shaders/vulkan/shader_program.cpp +++ b/src/mbgl/shaders/vulkan/shader_program.cpp @@ -37,17 +37,18 @@ ShaderProgram::ShaderProgram(shaders::BuiltIn shaderID, : ShaderProgramBase(), shaderName(name), backend(backend_) { + std::string defineStr = programParameters.getDefinesString() + "\n\n"; + for (const auto& define : additionalDefines) { + defineStr += "#define " + define.first + " " + define.second + "\n"; + } + observer->onPreCompileShader(shaderID, gfx::Backend::Type::Metal, defineStr); + constexpr auto targetClientVersion = glslang::EShTargetVulkan_1_0; constexpr auto targetLanguageVersion = glslang::EShTargetSpv_1_0; constexpr auto defaultVersion = 450; constexpr auto messages = EShMsgSpvRules | EShMsgVulkanRules; const auto defaultResources = GetDefaultResources(); - std::string defineStr = programParameters.getDefinesString() + "\n\n"; - for (const auto& define : additionalDefines) { - defineStr += "#define " + define.first + " " + define.second + "\n"; - } - const auto compileGlsl = [&](const EShLanguage& language, const std::string_view& data, const char* prelude) { glslang::TShader glslShader(language); @@ -63,7 +64,7 @@ ShaderProgram::ShaderProgram(shaders::BuiltIn shaderID, if (!glslShader.parse(defaultResources, defaultVersion, ENoProfile, false, true, messages)) { mbgl::Log::Error(mbgl::Event::Shader, shaderName + " - " + glslShader.getInfoLog()); - observer.onShaderCompileFailed(shaderID, gfx::Backend::Type::Vulkan); + observer.onShaderCompileFailed(shaderID, gfx::Backend::Type::Vulkan, defineStr); return std::vector(); } @@ -72,7 +73,7 @@ ShaderProgram::ShaderProgram(shaders::BuiltIn shaderID, if (!glslProgram.link(messages)) { mbgl::Log::Error(mbgl::Event::Shader, shaderName + " - " + glslProgram.getInfoLog()); - observer.onShaderCompileFailed(shaderID, gfx::Backend::Type::Vulkan); + observer.onShaderCompileFailed(shaderID, gfx::Backend::Type::Vulkan, defineStr); return std::vector(); } @@ -104,6 +105,8 @@ ShaderProgram::ShaderProgram(shaders::BuiltIn shaderID, backend.setDebugName(vertexShader.get(), shaderName + ".vert"); backend.setDebugName(fragmentShader.get(), shaderName + ".frag"); + + observer->onPostCompileShader(shaderID, gfx::Backend::Type::Metal, defineStr); } ShaderProgram::~ShaderProgram() noexcept = default; diff --git a/src/mbgl/tile/geometry_tile.cpp b/src/mbgl/tile/geometry_tile.cpp index 76ad11d54cb..a314379ac90 100644 --- a/src/mbgl/tile/geometry_tile.cpp +++ b/src/mbgl/tile/geometry_tile.cpp @@ -197,7 +197,7 @@ GeometryTile::~GeometryTile() { glyphManager->removeRequestor(*this); imageManager->removeRequestor(*this); - if (!notifiedInitiallyLoaded) { + if (pending) { // This tile never finished loading or was abandoned, emit a cancellation event observer->onTileAction(id, sourceID, TileOperation::Cancelled); } @@ -229,8 +229,7 @@ void GeometryTile::setData(std::unique_ptr data_) { return; } - if (!hasEverSetData) { - hasEverSetData = true; + if (data_) { observer->onTileAction(id, sourceID, TileOperation::StartParse); } @@ -250,6 +249,8 @@ void GeometryTile::reset() { // signaling a complete state despite pending parse operations. pending = true; + observer->onTileAction(id, sourceID, TileOperation::Cancelled); + ++correlationID; worker.self().invoke(&GeometryTileWorker::reset, correlationID); } @@ -316,8 +317,7 @@ void GeometryTile::onLayout(std::shared_ptr result, const uint64_t observer->onTileChanged(*this); - if (!pending && !notifiedInitiallyLoaded) { - notifiedInitiallyLoaded = true; + if (!pending) { observer->onTileAction(id, sourceID, TileOperation::EndParse); } } diff --git a/src/mbgl/tile/geometry_tile.hpp b/src/mbgl/tile/geometry_tile.hpp index f669aec37fe..393878fe1d6 100644 --- a/src/mbgl/tile/geometry_tile.hpp +++ b/src/mbgl/tile/geometry_tile.hpp @@ -104,12 +104,6 @@ class GeometryTile : public Tile, public GlyphRequestor, public ImageRequestor { // Used to signal the worker that it should abandon parsing this tile as soon as possible. std::atomic obsolete{false}; - // Flag to indicate the tile has received initial data - bool hasEverSetData{false}; - - // Flag to indicate the tile has completed inital loading - bool notifiedInitiallyLoaded{false}; - private: void markObsolete(); diff --git a/src/mbgl/tile/raster_dem_tile.cpp b/src/mbgl/tile/raster_dem_tile.cpp index 4aeee0b108c..ff5cf8b6088 100644 --- a/src/mbgl/tile/raster_dem_tile.cpp +++ b/src/mbgl/tile/raster_dem_tile.cpp @@ -39,7 +39,7 @@ RasterDEMTile::RasterDEMTile(const OverscaledTileID& id_, RasterDEMTile::~RasterDEMTile() { markObsolete(); - if (!notifiedInitiallyLoaded) { + if (pending) { // This tile never finished loading or was abandoned, emit a cancellation event observer->onTileAction(id, sourceID, TileOperation::Cancelled); } @@ -69,8 +69,7 @@ void RasterDEMTile::setData(const std::shared_ptr& data) { pending = true; ++correlationID; - if (!hasEverSetData) { - hasEverSetData = true; + if (data) { observer->onTileAction(id, sourceID, TileOperation::StartParse); } @@ -87,11 +86,7 @@ void RasterDEMTile::onParsed(std::unique_ptr result, const uint } renderable = static_cast(bucket); observer->onTileChanged(*this); - - if (!notifiedInitiallyLoaded) { - notifiedInitiallyLoaded = true; - observer->onTileAction(id, sourceID, TileOperation::EndParse); - } + observer->onTileAction(id, sourceID, TileOperation::EndParse); } } diff --git a/src/mbgl/tile/raster_dem_tile.hpp b/src/mbgl/tile/raster_dem_tile.hpp index 08993fb8b35..afcdef74a5a 100644 --- a/src/mbgl/tile/raster_dem_tile.hpp +++ b/src/mbgl/tile/raster_dem_tile.hpp @@ -106,8 +106,6 @@ class RasterDEMTile final : public Tile { std::shared_ptr bucket; bool obsolete = false; - bool notifiedInitiallyLoaded{false}; - bool hasEverSetData{false}; }; } // namespace mbgl diff --git a/src/mbgl/tile/raster_tile.cpp b/src/mbgl/tile/raster_tile.cpp index e5acf5e6d41..d89af17c355 100644 --- a/src/mbgl/tile/raster_tile.cpp +++ b/src/mbgl/tile/raster_tile.cpp @@ -28,7 +28,7 @@ RasterTile::RasterTile(const OverscaledTileID& id_, RasterTile::~RasterTile() { markObsolete(); - if (!notifiedInitiallyLoaded) { + if (pending) { // This tile never finished loading or was abandoned, emit a cancellation event observer->onTileAction(id, sourceID, TileOperation::Cancelled); } @@ -58,8 +58,7 @@ void RasterTile::setData(const std::shared_ptr& data) { pending = true; ++correlationID; - if (!hasEverSetData) { - hasEverSetData = true; + if (data) { observer->onTileAction(id, sourceID, TileOperation::StartParse); } @@ -76,11 +75,7 @@ void RasterTile::onParsed(std::unique_ptr result, const uint64_t r } renderable = static_cast(bucket); observer->onTileChanged(*this); - - if (!notifiedInitiallyLoaded) { - notifiedInitiallyLoaded = true; - observer->onTileAction(id, sourceID, TileOperation::EndParse); - } + observer->onTileAction(id, sourceID, TileOperation::EndParse); } } diff --git a/src/mbgl/tile/raster_tile.hpp b/src/mbgl/tile/raster_tile.hpp index a7654de0d93..bdb4c218540 100644 --- a/src/mbgl/tile/raster_tile.hpp +++ b/src/mbgl/tile/raster_tile.hpp @@ -54,8 +54,6 @@ class RasterTile final : public Tile { std::shared_ptr bucket; std::atomic obsolete{false}; - bool notifiedInitiallyLoaded{false}; - bool hasEverSetData{false}; }; } // namespace mbgl diff --git a/src/mbgl/tile/tile_loader.hpp b/src/mbgl/tile/tile_loader.hpp index 7a42a47befb..64657d1f7b6 100644 --- a/src/mbgl/tile/tile_loader.hpp +++ b/src/mbgl/tile/tile_loader.hpp @@ -52,7 +52,6 @@ class TileLoader { std::shared_ptr fileSource; std::unique_ptr request; TileUpdateParameters updateParameters{Duration::zero(), false}; - bool requested{false}; /// @brief It's possible for async requests in flight to mess with the request /// object at the same time as the loader's destructor. This construct is shared diff --git a/src/mbgl/tile/tile_loader_impl.hpp b/src/mbgl/tile/tile_loader_impl.hpp index fb593ff3c3a..d8deff623c7 100644 --- a/src/mbgl/tile/tile_loader_impl.hpp +++ b/src/mbgl/tile/tile_loader_impl.hpp @@ -106,10 +106,7 @@ void TileLoader::loadFromCache() { return; } - if (!requested) { - requested = true; - tile.onTileAction(TileOperation::Requested); - } + tile.onTileAction(TileOperation::RequestedFromCache); resource.loadingMethod = Resource::LoadingMethod::CacheOnly; request = fileSource->request(resource, [this, shared_{shared}](const Response& res) { @@ -168,6 +165,7 @@ void TileLoader::loadedData(const Response& res, Resource::LoadingMethod meth tile.onTileAction(TileOperation::Error); return; } + if (method == Resource::LoadingMethod::NetworkOnly) { tile.onTileAction(TileOperation::LoadFromNetwork); } else if (method == Resource::LoadingMethod::CacheOnly) { @@ -196,10 +194,7 @@ void TileLoader::loadFromNetwork() { return; } - if (!requested) { - requested = true; - tile.onTileAction(TileOperation::Requested); - } + tile.onTileAction(TileOperation::RequestedFromNetwork); // Instead of using Resource::LoadingMethod::All, we're first doing a // CacheOnly, and then a NetworkOnly request. diff --git a/src/mbgl/vulkan/context.cpp b/src/mbgl/vulkan/context.cpp index 48e3d68de0b..dd22f42236e 100644 --- a/src/mbgl/vulkan/context.cpp +++ b/src/mbgl/vulkan/context.cpp @@ -258,10 +258,8 @@ UniqueShaderProgram Context::createProgram(shaders::BuiltIn shaderID, const std::string_view fragment, const ProgramParameters& programParameters, const mbgl::unordered_map& additionalDefines) { - observer->onPreCompileShader(shaderID, gfx::Backend::Type::Metal); auto program = std::make_unique( shaderID, name, vertex, fragment, programParameters, additionalDefines, backend, *observer); - observer->onPostCompileShader(shaderID, gfx::Backend::Type::Metal); return program; } diff --git a/test/map/map.test.cpp b/test/map/map.test.cpp index cd61ab6b00d..be851fbffee 100644 --- a/test/map/map.test.cpp +++ b/test/map/map.test.cpp @@ -1700,11 +1700,13 @@ TEST(Map, ObserveTileLifecycle) { return id == other.id && sourceID == other.sourceID && op == other.op; } }; + std::mutex tileMutex; std::vector tileOps; struct ShaderEntry { shaders::BuiltIn id; gfx::Backend::Type type; + std::string defines; bool isPostCompile; }; std::vector shaderOps = {}; @@ -1712,9 +1714,16 @@ TEST(Map, ObserveTileLifecycle) { StubMapObserver observer; observer.onTileActionCallback = [&](TileOperation op, const OverscaledTileID& id, const std::string& sourceID) { if (sourceID != "mapbox") return; + std::lock_guard lock(tileMutex); tileOps.push_back(TileEntry{id, sourceID, op}); }; - + observer.onPreCompileShaderCallback = [&](shaders::BuiltIn id, gfx::Backend::Type type, const std::string& additionalDefines) { + shaderOps.push_back(ShaderEntry{id, type, additionalDefines, false}); + }; + observer.onPostCompileShaderCallback = [&](shaders::BuiltIn id, gfx::Backend::Type type, const std::string& additionalDefines) { + shaderOps.push_back(ShaderEntry{id, type, additionalDefines, true}); + }; + HeadlessFrontend frontend{{512, 512}, 1}; MapAdapter map( frontend, @@ -1734,62 +1743,115 @@ TEST(Map, ObserveTileLifecycle) { auto img = frontend.render(map).image; test::checkImage("test/fixtures/map/tile_lifecycle", img, 0.0002, 0.1); + + std::unordered_map seen; + for (auto& shader : shaderOps) { + auto shaderStr = std::to_string(static_cast(shader.id)) + shader.defines; + auto it = seen.find(shaderStr); + if (it != seen.end()) continue; + seen.insert({shaderStr, true}); + Log::Info(Event::General, std::to_string(static_cast(shader.id)) + " " + std::to_string(std::hash()(shader.defines))); + } + // We expect to see a valid shader lifecycle for every entry in this list. + const std::vector> expectedShaders = { + {shaders::BuiltIn::FillShader, 16114602744458825542ULL}, + {shaders::BuiltIn::FillOutlineShader, 16114602744458825542ULL}, + }; + + for (const auto& [id, defineHash] : expectedShaders) { + bool seenPreEvent = false; + + for (const auto& op : shaderOps) { + if (op.id != id || std::hash()(op.defines) != defineHash) { + continue; + } + + if (!seenPreEvent) { + EXPECT_EQ(op.isPostCompile, false); + seenPreEvent = true; + } else { + EXPECT_EQ(op.isPostCompile, true); + break; + } + } + } + + // We expect to see a valid lifecycle for every tile in this list. const std::vector expectedTiles = { - OverscaledTileID{0, 0, 0, 0, 0}, - OverscaledTileID{1, 0, 1, 0, 0}, - OverscaledTileID{1, 0, 1, 0, 1}, - OverscaledTileID{1, 0, 1, 1, 0}, - OverscaledTileID{1, 0, 1, 1, 1}, + {10, 0, 10, 163, 395 }, + {10, 0, 10, 163, 396 }, + {10, 0, 10, 164, 395 }, + {10, 0, 10, 164, 396 }, + {9, 0, 9, 81, 197 }, + {9, 0, 9, 81, 198 }, + {9, 0, 9, 82, 197 }, + {9, 0, 9, 82, 198 }, + {8, 0, 8, 40, 98 }, + {8, 0, 8, 40, 99 }, + {8, 0, 8, 41, 98 }, + {8, 0, 8, 41, 99 }, + {7, 0, 7, 20, 49 }, + {6, 0, 6, 10, 24 }, + {5, 0, 5, 5, 12 }, + // Lower zooms can also be seen, but not always, so we + // ignore them. }; - for (auto& tile : expectedTiles) { - TileOperation stage; - bool didAction = false; + for (const auto& tile : expectedTiles) { + TileOperation stage = TileOperation::NullOp; - for (auto& op : tileOps) { + for (const auto& op : tileOps) { if (op.id != tile) continue; switch (op.op) { - case TileOperation::Requested: { - EXPECT_EQ(didAction, false); - stage = TileOperation::Requested; - didAction = true; + case TileOperation::RequestedFromCache: { + EXPECT_EQ(stage, TileOperation::NullOp); + stage = TileOperation::RequestedFromCache; + break; + } + case TileOperation::RequestedFromNetwork: { + EXPECT_THAT(stage, testing::AnyOf( + TileOperation::StartParse, + TileOperation::EndParse, + TileOperation::RequestedFromCache + )); + stage = TileOperation::RequestedFromNetwork; break; } case TileOperation::LoadFromNetwork: { - EXPECT_EQ(stage, TileOperation::Requested); + EXPECT_THAT(stage, TileOperation::RequestedFromNetwork); stage = TileOperation::LoadFromNetwork; - didAction = true; break; } case TileOperation::LoadFromCache: { - EXPECT_EQ(stage, TileOperation::Requested); + EXPECT_EQ(stage, TileOperation::RequestedFromCache); stage = TileOperation::LoadFromCache; - didAction = true; break; } case TileOperation::StartParse: { EXPECT_THAT(stage, testing::AnyOf(TileOperation::LoadFromNetwork, TileOperation::LoadFromCache)); stage = TileOperation::StartParse; - didAction = true; break; } case TileOperation::Cancelled: { EXPECT_THAT(stage, - testing::AnyOf(TileOperation::Requested, + testing::AnyOf(TileOperation::RequestedFromCache, + TileOperation::RequestedFromNetwork, TileOperation::LoadFromNetwork, TileOperation::LoadFromCache, TileOperation::StartParse)); stage = TileOperation::Cancelled; - didAction = true; break; } case TileOperation::EndParse: { - EXPECT_EQ(stage, TileOperation::StartParse); + // The tile loader will try the cache first. If a cache hit is found, it starts parsing it while loading + // from the network. In the event data the cache is invalid, the network request will return newer data + // and update the geometry tile worker, which was already parsing the cached data. + EXPECT_THAT(stage, testing::AnyOf(TileOperation::StartParse, TileOperation::LoadFromNetwork)); stage = TileOperation::EndParse; - didAction = true; break; } + case TileOperation::NullOp: [[fallthrough]]; case TileOperation::Error: { ADD_FAILURE(); break; diff --git a/test/src/mbgl/test/stub_map_observer.hpp b/test/src/mbgl/test/stub_map_observer.hpp index e43942ffe0a..fc7d36dbaf4 100644 --- a/test/src/mbgl/test/stub_map_observer.hpp +++ b/test/src/mbgl/test/stub_map_observer.hpp @@ -50,21 +50,21 @@ class StubMapObserver : public MapObserver { } } - void onPreCompileShader(shaders::BuiltIn id, gfx::Backend::Type type) final { + void onPreCompileShader(shaders::BuiltIn id, gfx::Backend::Type type, const std::string& additionalDefines) final { if (onPreCompileShaderCallback) { - onPreCompileShaderCallback(id, type); + onPreCompileShaderCallback(id, type, additionalDefines); } } - void onPostCompileShader(shaders::BuiltIn id, gfx::Backend::Type type) final { + void onPostCompileShader(shaders::BuiltIn id, gfx::Backend::Type type, const std::string& additionalDefines) final { if (onPostCompileShaderCallback) { - onPostCompileShaderCallback(id, type); + onPostCompileShaderCallback(id, type, additionalDefines); } } - void onShaderCompileFailed(shaders::BuiltIn id, gfx::Backend::Type type) final { + void onShaderCompileFailed(shaders::BuiltIn id, gfx::Backend::Type type, const std::string& additionalDefines) final { if (onShaderCompileFailedCallback) { - onShaderCompileFailedCallback(id, type); + onShaderCompileFailedCallback(id, type, additionalDefines); } } @@ -99,9 +99,9 @@ class StubMapObserver : public MapObserver { std::function didFinishRenderingFrameCallback; std::function didBecomeIdleCallback; std::function onRegisterShadersCallback; - std::function onPreCompileShaderCallback; - std::function onPostCompileShaderCallback; - std::function onShaderCompileFailedCallback; + std::function onPreCompileShaderCallback; + std::function onPostCompileShaderCallback; + std::function onShaderCompileFailedCallback; std::function onGlyphsLoadedCallback; std::function onGlyphsErrorCallback; std::function onGlyphsRequestedCallback;