tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add extra observer hooks for interesting internal processes (#2694)

Browse Source 
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
This commit is contained in:
mwilsnd
2024-09-03 17:48:03 -04:00
committed by GitHub
parent b90b2df920
commit bb34568af2
93 changed files with 1951 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
platform/android/MapLibreAndroid/src/cpp/CMakeLists.txt
View File

@@ -189,7 +189,8 @@ add_library(maplibre SHARED
${PROJECT_SOURCE_DIR}/style/transition_options.hpp
${PROJECT_SOURCE_DIR}/style/value.cpp
${PROJECT_SOURCE_DIR}/style/value.hpp
${PROJECT_SOURCE_DIR}/util/default_style.cpp
${PROJECT_SOURCE_DIR}/tile/tile_operation.cpp
${PROJECT_SOURCE_DIR}/util/default_style.cpp
${PROJECT_SOURCE_DIR}/util/tile_server_options.cpp
${PROJECT_SOURCE_DIR}/util/default_style.hpp
${PROJECT_SOURCE_DIR}/util/tile_server_options.hpp)

35
platform/android/MapLibreAndroid/src/cpp/android_renderer_frontend.cpp
View File

@@ -1,5 +1,6 @@
#include "android_renderer_frontend.hpp"
#include <mbgl/tile/tile_operation.hpp>
#include <mbgl/actor/scheduler.hpp>
#include <mbgl/renderer/renderer.hpp>
#include <mbgl/renderer/renderer_observer.hpp>
@@ -52,6 +53,40 @@ public:
delegate.invoke(&RendererObserver::onRemoveUnusedStyleImages, ids);
}
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,
const std::string& additionalDefines) override {
delegate.invoke(&RendererObserver::onPostCompileShader, id, type, additionalDefines);
}
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 {
delegate.invoke(&RendererObserver::onGlyphsLoaded, stack, range);
}
void onGlyphsError(const mbgl::FontStack& stack, const mbgl::GlyphRange& range, std::exception_ptr ex) override {
delegate.invoke(&RendererObserver::onGlyphsError, stack, range, ex);
}
void onGlyphsRequested(const mbgl::FontStack& stack, const mbgl::GlyphRange& range) override {
delegate.invoke(&RendererObserver::onGlyphsRequested, stack, range);
}
void onTileAction(TileOperation op, const OverscaledTileID& id, const std::string& sourceID) override {
delegate.invoke(&RendererObserver::onTileAction, op, id, sourceID);
}
private:
std::shared_ptr<Mailbox> mailbox;
ActorRef<RendererObserver> delegate;

4
platform/android/MapLibreAndroid/src/cpp/jni_native.cpp
View File

@@ -56,6 +56,7 @@
#include "i18n/number_format_jni.hpp"
#include "logger.hpp"
#include "text/local_glyph_rasterizer_jni.hpp"
#include "tile/tile_operation.hpp"
namespace mbgl {
namespace android {
@@ -158,6 +159,9 @@ void registerNatives(JavaVM* vm) {
StringUtils::registerNative(env);
NumberFormat::registerNative(env);
// Tile
TileOperation::registerNative(env);
// Logger
Logger::registerNative(env);

195
platform/android/MapLibreAndroid/src/cpp/native_map_view.cpp
View File

@@ -53,6 +53,7 @@
#include "map_renderer.hpp"
#include "run_loop_impl.hpp"
#include "style/light.hpp"
#include "tile/tile_operation.hpp"
namespace mbgl {
namespace android {
@@ -1341,5 +1342,199 @@ void NativeMapView::registerNative(jni::JNIEnv& env) {
METHOD(&NativeMapView::triggerRepaint, "nativeTriggerRepaint"));
}
void NativeMapView::onRegisterShaders(gfx::ShaderRegistry&) {};
// Shader compilation
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<NativeMapView>::Singleton(*_env);
static auto onPreCompileShader = javaClass.GetMethod<void(jni::jint, jni::jint, jni::String)>(*_env,
"onPreCompileShader");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env,
onPreCompileShader,
static_cast<jni::jint>(id),
static_cast<jni::jint>(type),
jni::Make<jni::String>(*_env, additionalDefines));
}
}
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<NativeMapView>::Singleton(*_env);
static auto onPostCompileShader = javaClass.GetMethod<void(jni::jint, jni::jint, jni::String)>(
*_env, "onPostCompileShader");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env,
onPostCompileShader,
static_cast<jni::jint>(id),
static_cast<jni::jint>(type),
jni::Make<jni::String>(*_env, additionalDefines));
}
}
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<NativeMapView>::Singleton(*_env);
static auto onShaderCompileFailed = javaClass.GetMethod<void(jni::jint, jni::jint, jni::String)>(
*_env, "onShaderCompileFailed");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env,
onShaderCompileFailed,
static_cast<jni::jint>(id),
static_cast<jni::jint>(type),
jni::Make<jni::String>(*_env, additionalDefines));
}
}
// Glyph requests
void NativeMapView::onGlyphsLoaded(const FontStack& stack, const GlyphRange& range) {
assert(vm != nullptr);
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onGlyphsLoaded = javaClass.GetMethod<void(jni::Array<jni::String>, jni::jint, jni::jint)>(
*_env, "onGlyphsLoaded");
auto fontStack = jni::Array<jni::String>::New(*_env, stack.size());
for (std::size_t i = 0; i < stack.size(); i++) {
fontStack.Set(*_env, i, jni::Make<jni::String>(*_env, stack.at(i)));
}
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env, onGlyphsLoaded, fontStack, range.first, range.second);
}
}
void NativeMapView::onGlyphsError(const FontStack& stack, const GlyphRange& range, std::exception_ptr) {
assert(vm != nullptr);
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onGlyphsError = javaClass.GetMethod<void(jni::Array<jni::String>, jni::jint, jni::jint)>(
*_env, "onGlyphsError");
auto fontStack = jni::Array<jni::String>::New(*_env, stack.size());
for (std::size_t i = 0; i < stack.size(); i++) {
fontStack.Set(*_env, i, jni::Make<jni::String>(*_env, stack.at(i)));
}
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env, onGlyphsError, fontStack, range.first, range.second);
}
}
void NativeMapView::onGlyphsRequested(const FontStack& stack, const GlyphRange& range) {
assert(vm != nullptr);
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onGlyphsRequested = javaClass.GetMethod<void(jni::Array<jni::String>, jni::jint, jni::jint)>(
*_env, "onGlyphsRequested");
auto fontStack = jni::Array<jni::String>::New(*_env, stack.size());
for (std::size_t i = 0; i < stack.size(); i++) {
fontStack.Set(*_env, i, jni::Make<jni::String>(*_env, stack.at(i)));
}
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env, onGlyphsRequested, fontStack, range.first, range.second);
}
}
// Tile requests
void NativeMapView::onTileAction(mbgl::TileOperation op, const OverscaledTileID& id, const std::string& sourceID) {
assert(vm != nullptr);
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onTileAction = javaClass.GetMethod<void(
jni::Object<mbgl::android::TileOperation>, jni::jint, jni::jint, jni::jint, jni::jint, jni::jint, jni::String)>(
*_env, "onTileAction");
auto weakReference = javaPeer.get(*_env);
if (weakReference) {
weakReference.Call(*_env,
onTileAction,
mbgl::android::TileOperation::Create(*_env, op),
static_cast<jni::jint>(id.canonical.x),
static_cast<jni::jint>(id.canonical.y),
static_cast<jni::jint>(id.canonical.z),
static_cast<jni::jint>(id.wrap),
static_cast<jni::jint>(id.overscaledZ),
jni::Make<jni::String>(*_env, sourceID));
}
}
// Sprite requests
void NativeMapView::onSpriteLoaded(const std::optional<style::Sprite>& sprite) {
assert(vm != nullptr);
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onSpriteLoaded = javaClass.GetMethod<void(jni::String, jni::String)>(*_env, "onSpriteLoaded");
auto weakReference = javaPeer.get(*_env);
if (weakReference && sprite) {
weakReference.Call(*_env,
onSpriteLoaded,
jni::Make<jni::String>(*_env, sprite->id),
jni::Make<jni::String>(*_env, sprite->spriteURL));
} else {
weakReference.Call(*_env, onSpriteLoaded, jni::Make<jni::String>(*_env, ""), jni::Make<jni::String>(*_env, ""));
}
}
void NativeMapView::onSpriteError(const std::optional<style::Sprite>& sprite, std::exception_ptr ex) {
assert(vm != nullptr);
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onSpriteError = javaClass.GetMethod<void(jni::String, jni::String)>(*_env, "onSpriteError");
auto weakReference = javaPeer.get(*_env);
if (weakReference && sprite) {
weakReference.Call(*_env,
onSpriteError,
jni::Make<jni::String>(*_env, sprite->id),
jni::Make<jni::String>(*_env, sprite->spriteURL));
} else {
weakReference.Call(*_env, onSpriteError, jni::Make<jni::String>(*_env, ""), jni::Make<jni::String>(*_env, ""));
}
}
void NativeMapView::onSpriteRequested(const std::optional<style::Sprite>& sprite) {
assert(vm != nullptr);
android::UniqueEnv _env = android::AttachEnv();
static auto& javaClass = jni::Class<NativeMapView>::Singleton(*_env);
static auto onSpriteRequested = javaClass.GetMethod<void(jni::String, jni::String)>(*_env, "onSpriteRequested");
auto weakReference = javaPeer.get(*_env);
if (weakReference && sprite) {
weakReference.Call(*_env,
onSpriteRequested,
jni::Make<jni::String>(*_env, sprite->id),
jni::Make<jni::String>(*_env, sprite->spriteURL));
} else {
weakReference.Call(
*_env, onSpriteRequested, jni::Make<jni::String>(*_env, ""), jni::Make<jni::String>(*_env, ""));
}
}
} // namespace android
} // namespace mbgl

20
platform/android/MapLibreAndroid/src/cpp/native_map_view.hpp
View File

@@ -5,6 +5,7 @@
#include <mbgl/map/map.hpp>
#include <mbgl/util/noncopyable.hpp>
#include <mbgl/util/run_loop.hpp>
#include <mbgl/tile/tile_operation.hpp>
#include <mbgl/storage/network_status.hpp>
#include "annotation/marker.hpp"
@@ -298,6 +299,25 @@ public:
void triggerRepaint(JNIEnv&);
// Shader compilation
void onRegisterShaders(mbgl::gfx::ShaderRegistry&) 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;
void onGlyphsError(const mbgl::FontStack&, const mbgl::GlyphRange&, std::exception_ptr) override;
void onGlyphsRequested(const mbgl::FontStack&, const mbgl::GlyphRange&) override;
// Tile requests
void onTileAction(mbgl::TileOperation, const mbgl::OverscaledTileID&, const std::string&) override;
// Sprite requests
void onSpriteLoaded(const std::optional<mbgl::style::Sprite>&) override;
void onSpriteError(const std::optional<mbgl::style::Sprite>&, std::exception_ptr) override;
void onSpriteRequested(const std::optional<mbgl::style::Sprite>&) override;
private:
std::unique_ptr<AndroidRendererFrontend> rendererFrontend;

35
platform/android/MapLibreAndroid/src/cpp/tile/tile_operation.cpp Normal file
View File

@@ -0,0 +1,35 @@
#include "tile_operation.hpp"
namespace mbgl {
namespace android {
jni::Local<jni::Object<TileOperation>> TileOperation::Create(jni::JNIEnv& env, mbgl::TileOperation op) {
static auto& _class = jni::Class<mbgl::android::TileOperation>::Singleton(env);
switch (op) {
case mbgl::TileOperation::RequestedFromNetwork:
return _class.Get(env, _class.GetStaticField<jni::Object<TileOperation>>(env, "RequestedFromNetwork"));
case mbgl::TileOperation::RequestedFromCache:
return _class.Get(env, _class.GetStaticField<jni::Object<TileOperation>>(env, "RequestedFromCache"));
case mbgl::TileOperation::LoadFromCache:
return _class.Get(env, _class.GetStaticField<jni::Object<TileOperation>>(env, "LoadFromCache"));
case mbgl::TileOperation::LoadFromNetwork:
return _class.Get(env, _class.GetStaticField<jni::Object<TileOperation>>(env, "LoadFromNetwork"));
case mbgl::TileOperation::StartParse:
return _class.Get(env, _class.GetStaticField<jni::Object<TileOperation>>(env, "StartParse"));
case mbgl::TileOperation::EndParse:
return _class.Get(env, _class.GetStaticField<jni::Object<TileOperation>>(env, "EndParse"));
case mbgl::TileOperation::Error:
return _class.Get(env, _class.GetStaticField<jni::Object<TileOperation>>(env, "Error"));
case mbgl::TileOperation::Cancelled:
return _class.Get(env, _class.GetStaticField<jni::Object<TileOperation>>(env, "Cancelled"));
case mbgl::TileOperation::NullOp:
return _class.Get(env, _class.GetStaticField<jni::Object<TileOperation>>(env, "NullOp"));
}
}
void TileOperation::registerNative(jni::JNIEnv& env) {
jni::Class<TileOperation>::Singleton(env);
}
} // namespace android
} // namespace mbgl

20
platform/android/MapLibreAndroid/src/cpp/tile/tile_operation.hpp Normal file
View File

@@ -0,0 +1,20 @@
#pragma once
#include <mbgl/tile/tile_operation.hpp>
#include <jni/jni.hpp>
namespace mbgl {
namespace android {
class TileOperation {
public:
static constexpr auto Name() { return "org/maplibre/android/tile/TileOperation"; };
static jni::Local<jni::Object<TileOperation>> Create(jni::JNIEnv&, mbgl::TileOperation);
static void registerNative(jni::JNIEnv& env);
};
} // namespace android
} // namespace mbgl