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

Rename Gradle targets Android (#2226)

Browse Source
This commit is contained in:
Bart Louwers
2024-04-02 23:15:50 +02:00
committed by GitHub
parent 37170ed61c
commit 9f8ae7a98b
1081 changed files with 132 additions and 370 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
platform/android/MapLibreAndroid/src/cpp/map/camera_position.cpp Normal file
View File

@@ -0,0 +1,74 @@
#include "camera_position.hpp"
#include "../geometry/lat_lng.hpp"
namespace mbgl {
namespace android {
jni::Local<jni::Object<CameraPosition>> CameraPosition::New(jni::JNIEnv& env,
mbgl::CameraOptions options,
float pixelRatio) {
static auto& javaClass = jni::Class<CameraPosition>::Singleton(env);
static auto constructor =
javaClass.GetConstructor<jni::Object<LatLng>, double, double, double, jni::Array<jni::jdouble>>(env);
// wrap LatLng values coming from core
auto center = options.center.value();
center.wrap();
// convert bearing, measured in radians counterclockwise from true north.
// Wrapped to [−π rad, π rad). Android binding from 0 to 360 degrees
double bearing_degrees = options.bearing.value_or(0);
while (bearing_degrees > 360) {
bearing_degrees -= 360;
}
while (bearing_degrees < 0) {
bearing_degrees += 360;
}
// convert tilt, core ranges from [0 rad, 1,0472 rad], android ranges from 0 to 60
double tilt_degrees = options.pitch.value_or(0);
std::vector<jdouble> paddingVect;
auto insets = options.padding.value_or(EdgeInsets{0, 0, 0, 0});
auto padding = jni::Array<jni::jdouble>::New(env, 4);
paddingVect.push_back(insets.left() * pixelRatio);
paddingVect.push_back(insets.top() * pixelRatio);
paddingVect.push_back(insets.right() * pixelRatio);
paddingVect.push_back(insets.bottom() * pixelRatio);
padding.SetRegion<std::vector<jni::jdouble>>(env, 0, paddingVect);
return javaClass.New(
env, constructor, LatLng::New(env, center), options.zoom.value_or(0), tilt_degrees, bearing_degrees, padding);
}
mbgl::CameraOptions CameraPosition::getCameraOptions(jni::JNIEnv& env,
const jni::Object<CameraPosition>& position,
float pixelRatio) {
static auto& javaClass = jni::Class<CameraPosition>::Singleton(env);
static auto bearing = javaClass.GetField<jni::jdouble>(env, "bearing");
static auto target = javaClass.GetField<jni::Object<LatLng>>(env, "target");
static auto tilt = javaClass.GetField<jni::jdouble>(env, "tilt");
static auto zoom = javaClass.GetField<jni::jdouble>(env, "zoom");
static auto paddingField = javaClass.GetField<jni::Array<jni::jdouble>>(env, "padding");
auto padding = position.Get(env, paddingField);
auto center = LatLng::getLatLng(env, position.Get(env, target));
return mbgl::CameraOptions{center,
padding && padding.Length(env) == 4 ? EdgeInsets{padding.Get(env, 1) * pixelRatio,
padding.Get(env, 0) * pixelRatio,
padding.Get(env, 3) * pixelRatio,
padding.Get(env, 2) * pixelRatio}
: (EdgeInsets){},
{},
position.Get(env, zoom),
position.Get(env, bearing),
position.Get(env, tilt)};
}
void CameraPosition::registerNative(jni::JNIEnv& env) {
jni::Class<CameraPosition>::Singleton(env);
}
} // namespace android
} // namespace mbgl

23
platform/android/MapLibreAndroid/src/cpp/map/camera_position.hpp Normal file
View File

@@ -0,0 +1,23 @@
#pragma once
#include <mbgl/util/noncopyable.hpp>
#include <mbgl/map/camera.hpp>
#include <jni/jni.hpp>
namespace mbgl {
namespace android {
class CameraPosition : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "org/maplibre/android/camera/CameraPosition"; };
static jni::Local<jni::Object<CameraPosition>> New(jni::JNIEnv&, mbgl::CameraOptions, float pixelRatio);
static mbgl::CameraOptions getCameraOptions(jni::JNIEnv&, const jni::Object<CameraPosition>&, float pixelRatio);
static void registerNative(jni::JNIEnv&);
};
} // namespace android
} // namespace mbgl

74
platform/android/MapLibreAndroid/src/cpp/map/image.cpp Normal file
View File

@@ -0,0 +1,74 @@
#include <mbgl/style/image.hpp>
#include <mbgl/util/exception.hpp>
#include "image.hpp"
namespace mbgl {
namespace android {
mbgl::style::Image Image::getImage(jni::JNIEnv& env, const jni::Object<Image>& image) {
static auto& javaClass = jni::Class<Image>::Singleton(env);
static auto widthField = javaClass.GetField<jni::jint>(env, "width");
static auto heightField = javaClass.GetField<jni::jint>(env, "height");
static auto pixelRatioField = javaClass.GetField<jni::jfloat>(env, "pixelRatio");
static auto bufferField = javaClass.GetField<jni::Array<jbyte>>(env, "buffer");
static auto nameField = javaClass.GetField<jni::String>(env, "name");
static auto sdfField = javaClass.GetField<jni::jboolean>(env, "sdf");
static auto contentField = javaClass.GetField<jni::Array<jfloat>>(env, "content");
static auto stretchXField = javaClass.GetField<jni::Array<jfloat>>(env, "stretchX");
static auto stretchYField = javaClass.GetField<jni::Array<jfloat>>(env, "stretchY");
auto height = image.Get(env, heightField);
auto width = image.Get(env, widthField);
auto pixelRatio = image.Get(env, pixelRatioField);
auto pixels = image.Get(env, bufferField);
auto name = jni::Make<std::string>(env, image.Get(env, nameField));
auto sdf = (bool)image.Get(env, sdfField);
auto content = image.Get(env, contentField);
auto stretchX = image.Get(env, stretchXField);
auto stretchY = image.Get(env, stretchYField);
jni::NullCheck(env, pixels.get());
std::size_t size = pixels.Length(env);
mbgl::PremultipliedImage premultipliedImage({static_cast<uint32_t>(width), static_cast<uint32_t>(height)});
if (premultipliedImage.bytes() != uint32_t(size)) {
throw mbgl::util::StyleImageException("Image pixel count mismatch");
}
jni::GetArrayRegion(env, *pixels, 0, size, reinterpret_cast<jbyte*>(premultipliedImage.data.get()));
style::ImageStretches imageStretchesX = {};
style::ImageStretches imageStretchesY = {};
if (stretchX.get()) {
std::size_t sizeX = stretchX.Length(env);
for (jni::jsize i = 0; i < sizeX - 1; i += 2) {
imageStretchesX.push_back({stretchX.Get(env, i), stretchX.Get(env, i + 1)});
}
}
if (stretchY.get()) {
std::size_t sizeY = stretchY.Length(env);
for (jni::jsize i = 0; i < sizeY - 1; i += 2) {
imageStretchesY.push_back({stretchY.Get(env, i), stretchY.Get(env, i + 1)});
}
}
if (content) {
const style::ImageContent imageContent = style::ImageContent{
content.Get(env, 0), content.Get(env, 1), content.Get(env, 2), content.Get(env, 3)};
return mbgl::style::Image{name,
std::move(premultipliedImage),
pixelRatio,
sdf,
imageStretchesX,
imageStretchesY,
std::move(imageContent)};
}
return mbgl::style::Image{name, std::move(premultipliedImage), pixelRatio, sdf, imageStretchesX, imageStretchesY};
}
void Image::registerNative(jni::JNIEnv& env) {
jni::Class<Image>::Singleton(env);
}
} // namespace android
} // namespace mbgl

21
platform/android/MapLibreAndroid/src/cpp/map/image.hpp Normal file
View File

@@ -0,0 +1,21 @@
#pragma once
#include <mbgl/util/noncopyable.hpp>
#include <jni/jni.hpp>
#include <mbgl/style/image.hpp>
namespace mbgl {
namespace android {
class Image : private mbgl::util::noncopyable {
public:
static constexpr auto Name() { return "org/maplibre/android/maps/Image"; };
static mbgl::style::Image getImage(jni::JNIEnv&, const jni::Object<Image>&);
static void registerNative(jni::JNIEnv&);
};
} // namespace android
} // namespace mbgl