core: Update Hillshade Algorithms and add Color-Relief Layer support (#3965)

platform/android/MapLibreAndroid/src/cpp/CMakeLists.txt

@@ -147,6 +147,8 @@ add_library(maplibre SHARED
             ${PROJECT_SOURCE_DIR}/style/layers/background_layer.hpp
             ${PROJECT_SOURCE_DIR}/style/layers/circle_layer.cpp
             ${PROJECT_SOURCE_DIR}/style/layers/circle_layer.hpp
+            ${PROJECT_SOURCE_DIR}/style/layers/color_relief_layer.cpp
+            ${PROJECT_SOURCE_DIR}/style/layers/color_relief_layer.hpp
             ${PROJECT_SOURCE_DIR}/style/layers/custom_layer.cpp
             ${PROJECT_SOURCE_DIR}/style/layers/custom_layer.hpp
             ${PROJECT_SOURCE_DIR}/style/layers/fill_extrusion_layer.cpp

platform/android/MapLibreAndroid/src/cpp/conversion/constant.cpp

@@ -101,6 +101,17 @@ Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::vect
     return result;
 }
 
+Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, std::vector<Color>>::operator()(
+    jni::JNIEnv& env, const std::vector<Color>& value) const {
+    auto result = jni::Array<jni::String>::New(env, value.size());
+
+    for (std::size_t i = 0; i < value.size(); i++) {
+        result.Set(env, i, jni::Make<jni::String>(env, value.at(i).stringify()));
+    }
+
+    return result;
+}
+
 Result<jni::Local<jni::Object<>>> Converter<jni::Local<jni::Object<>>, style::expression::Image>::operator()(
     jni::JNIEnv& env, const style::expression::Image& value) const {
     return jni::Make<jni::String>(env, value.id());

platform/android/MapLibreAndroid/src/cpp/conversion/constant.hpp

@@ -111,6 +111,11 @@ struct Converter<jni::Local<jni::Object<>>, std::vector<double>> {
     Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const std::vector<double>& value) const;
 };
 
+template <>
+struct Converter<jni::Local<jni::Object<>>, std::vector<Color>> {
+    Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const std::vector<Color>& value) const;
+};
+
 template <class T>
 struct Converter<jni::Local<jni::Object<>>, T, typename std::enable_if_t<std::is_enum<T>::value>> {
     Result<jni::Local<jni::Object<>>> operator()(jni::JNIEnv& env, const T& value) const {

platform/android/MapLibreAndroid/src/cpp/style/layers/color_relief_layer.cpp

@@ -0,0 +1,130 @@
+// This file is generated. Edit scripts/generate-style-code.js, then run `make style-code`.
+
+#include "color_relief_layer.hpp"
+
+#include <string>
+
+#include "../conversion/property_value.hpp"
+#include "../conversion/transition_options.hpp"
+
+#include <mbgl/style/layer_impl.hpp>
+
+namespace mbgl {
+namespace android {
+
+inline mbgl::style::ColorReliefLayer& toColorReliefLayer(mbgl::style::Layer& layer) {
+    return static_cast<mbgl::style::ColorReliefLayer&>(layer);
+}
+
+/**
+ * Creates an owning peer object (for layers not attached to the map) from the JVM side
+ */
+ColorReliefLayer::ColorReliefLayer(jni::JNIEnv& env, jni::String& layerId, jni::String& sourceId)
+    : Layer(std::make_unique<mbgl::style::ColorReliefLayer>(jni::Make<std::string>(env, layerId),
+                                                            jni::Make<std::string>(env, sourceId))) {}
+
+/**
+ * Creates a non-owning peer object (for layers currently attached to the map)
+ */
+ColorReliefLayer::ColorReliefLayer(mbgl::style::ColorReliefLayer& coreLayer)
+    : Layer(coreLayer) {}
+
+/**
+ * Creates an owning peer object (for layers not attached to the map)
+ */
+ColorReliefLayer::ColorReliefLayer(std::unique_ptr<mbgl::style::ColorReliefLayer> coreLayer)
+    : Layer(std::move(coreLayer)) {}
+
+ColorReliefLayer::~ColorReliefLayer() = default;
+
+// Property getters
+
+jni::Local<jni::Object<>> ColorReliefLayer::getColorReliefOpacity(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    auto layer = layerPtr.get();
+    if (!layer) {
+        return std::move(
+            *convert<jni::Local<jni::Object<>>>(env, style::ColorReliefLayer::getDefaultColorReliefOpacity()));
+    }
+    return std::move(*convert<jni::Local<jni::Object<>>>(env, toColorReliefLayer(*layer).getColorReliefOpacity()));
+}
+
+jni::Local<jni::Object<TransitionOptions>> ColorReliefLayer::getColorReliefOpacityTransition(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    auto layer = layerPtr.get();
+    if (!layer) {
+        return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, mbgl::style::TransitionOptions()));
+    }
+    mbgl::style::TransitionOptions options = toColorReliefLayer(*layer).getColorReliefOpacityTransition();
+    return std::move(*convert<jni::Local<jni::Object<TransitionOptions>>>(env, options));
+}
+
+void ColorReliefLayer::setColorReliefOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay) {
+    auto layer = layerPtr.get();
+    if (!layer) {
+        return;
+    }
+    mbgl::style::TransitionOptions options;
+    options.duration.emplace(mbgl::Milliseconds(duration));
+    options.delay.emplace(mbgl::Milliseconds(delay));
+    toColorReliefLayer(*layer).setColorReliefOpacityTransition(options);
+}
+
+jni::Local<jni::Object<>> ColorReliefLayer::getColorReliefColor(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    auto layer = layerPtr.get();
+    if (!layer) {
+        return std::move(
+            *convert<jni::Local<jni::Object<>>>(env, style::ColorReliefLayer::getDefaultColorReliefColor()));
+    }
+    return std::move(*convert<jni::Local<jni::Object<>>>(env, toColorReliefLayer(*layer).getColorReliefColor()));
+}
+
+// ColorReliefJavaLayerPeerFactory
+
+ColorReliefJavaLayerPeerFactory::~ColorReliefJavaLayerPeerFactory() = default;
+
+namespace {
+jni::Local<jni::Object<Layer>> createJavaPeer(jni::JNIEnv& env, Layer* layer) {
+    static auto& javaClass = jni::Class<ColorReliefLayer>::Singleton(env);
+    static auto constructor = javaClass.GetConstructor<jni::jlong>(env);
+    return javaClass.New(env, constructor, reinterpret_cast<jni::jlong>(layer));
+}
+} // namespace
+
+jni::Local<jni::Object<Layer>> ColorReliefJavaLayerPeerFactory::createJavaLayerPeer(jni::JNIEnv& env,
+                                                                                    mbgl::style::Layer& layer) {
+    assert(layer.baseImpl->getTypeInfo() == getTypeInfo());
+    return createJavaPeer(env, new ColorReliefLayer(toColorReliefLayer(layer)));
+}
+
+jni::Local<jni::Object<Layer>> ColorReliefJavaLayerPeerFactory::createJavaLayerPeer(
+    jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer> layer) {
+    assert(layer->baseImpl->getTypeInfo() == getTypeInfo());
+    return createJavaPeer(env,
+                          new ColorReliefLayer(std::unique_ptr<mbgl::style::ColorReliefLayer>(
+                              static_cast<mbgl::style::ColorReliefLayer*>(layer.release()))));
+}
+
+void ColorReliefJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
+    // Lookup the class
+    static auto& javaClass = jni::Class<ColorReliefLayer>::Singleton(env);
+
+#define METHOD(MethodPtr, name) jni::MakeNativePeerMethod<decltype(MethodPtr), (MethodPtr)>(name)
+
+    // Register the peer
+    jni::RegisterNativePeer<ColorReliefLayer>(
+        env,
+        javaClass,
+        "nativePtr",
+        jni::MakePeer<ColorReliefLayer, jni::String&, jni::String&>,
+        "initialize",
+        "finalize",
+        METHOD(&ColorReliefLayer::getColorReliefOpacityTransition, "nativeGetColorReliefOpacityTransition"),
+        METHOD(&ColorReliefLayer::setColorReliefOpacityTransition, "nativeSetColorReliefOpacityTransition"),
+        METHOD(&ColorReliefLayer::getColorReliefOpacity, "nativeGetColorReliefOpacity"),
+        METHOD(&ColorReliefLayer::getColorReliefColor, "nativeGetColorReliefColor"));
+}
+
+} // namespace android
+} // namespace mbgl

platform/android/MapLibreAndroid/src/cpp/style/layers/color_relief_layer.hpp

@@ -0,0 +1,52 @@
+// This file is generated. Edit scripts/generate-style-code.js, then run `make style-code`.
+
+#pragma once
+
+#include "layer.hpp"
+#include "../transition_options.hpp"
+#include <mbgl/layermanager/color_relief_layer_factory.hpp>
+#include <mbgl/style/layers/color_relief_layer.hpp>
+#include <jni/jni.hpp>
+
+namespace mbgl {
+namespace android {
+
+class ColorReliefLayer : public Layer {
+public:
+    using SuperTag = Layer;
+    static constexpr auto Name() { return "org/maplibre/android/style/layers/ColorReliefLayer"; };
+
+    ColorReliefLayer(jni::JNIEnv&, jni::String&, jni::String&);
+
+    ColorReliefLayer(mbgl::style::ColorReliefLayer&);
+
+    ColorReliefLayer(std::unique_ptr<mbgl::style::ColorReliefLayer>);
+
+    ~ColorReliefLayer();
+
+    // Properties
+
+    jni::Local<jni::Object<jni::ObjectTag>> getColorReliefOpacity(jni::JNIEnv&);
+    void setColorReliefOpacityTransition(jni::JNIEnv&, jlong duration, jlong delay);
+    jni::Local<jni::Object<TransitionOptions>> getColorReliefOpacityTransition(jni::JNIEnv&);
+
+    jni::Local<jni::Object<jni::ObjectTag>> getColorReliefColor(jni::JNIEnv&);
+
+}; // class ColorReliefLayer
+
+class ColorReliefJavaLayerPeerFactory final : public JavaLayerPeerFactory, public mbgl::ColorReliefLayerFactory {
+public:
+    ~ColorReliefJavaLayerPeerFactory() override;
+
+    // JavaLayerPeerFactory overrides.
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv&, mbgl::style::Layer&) final;
+    jni::Local<jni::Object<Layer>> createJavaLayerPeer(jni::JNIEnv& env, std::unique_ptr<mbgl::style::Layer>) final;
+
+    void registerNative(jni::JNIEnv&) final;
+
+    LayerFactory* getLayerFactory() final { return this; }
+
+}; // class ColorReliefJavaLayerPeerFactory
+
+} // namespace android
+} // namespace mbgl

platform/android/MapLibreAndroid/src/cpp/style/layers/hillshade_layer.cpp

@@ -50,6 +50,17 @@ jni::Local<jni::Object<>> HillshadeLayer::getHillshadeIlluminationDirection(jni:
         *convert<jni::Local<jni::Object<>>>(env, toHillshadeLayer(*layer).getHillshadeIlluminationDirection()));
 }
 
+jni::Local<jni::Object<>> HillshadeLayer::getHillshadeIlluminationAltitude(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    auto layer = layerPtr.get();
+    if (!layer) {
+        return std::move(
+            *convert<jni::Local<jni::Object<>>>(env, style::HillshadeLayer::getDefaultHillshadeIlluminationAltitude()));
+    }
+    return std::move(
+        *convert<jni::Local<jni::Object<>>>(env, toHillshadeLayer(*layer).getHillshadeIlluminationAltitude()));
+}
+
 jni::Local<jni::Object<>> HillshadeLayer::getHillshadeIlluminationAnchor(jni::JNIEnv& env) {
     using namespace mbgl::android::conversion;
     auto layer = layerPtr.get();
@@ -185,6 +196,15 @@ void HillshadeLayer::setHillshadeAccentColorTransition(jni::JNIEnv&, jlong durat
     toHillshadeLayer(*layer).setHillshadeAccentColorTransition(options);
 }
 
+jni::Local<jni::Object<>> HillshadeLayer::getHillshadeMethod(jni::JNIEnv& env) {
+    using namespace mbgl::android::conversion;
+    auto layer = layerPtr.get();
+    if (!layer) {
+        return std::move(*convert<jni::Local<jni::Object<>>>(env, style::HillshadeLayer::getDefaultHillshadeMethod()));
+    }
+    return std::move(*convert<jni::Local<jni::Object<>>>(env, toHillshadeLayer(*layer).getHillshadeMethod()));
+}
+
 // HillshadeJavaLayerPeerFactory
 
 HillshadeJavaLayerPeerFactory::~HillshadeJavaLayerPeerFactory() = default;
@@ -226,6 +246,7 @@ void HillshadeJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
         "initialize",
         "finalize",
         METHOD(&HillshadeLayer::getHillshadeIlluminationDirection, "nativeGetHillshadeIlluminationDirection"),
+        METHOD(&HillshadeLayer::getHillshadeIlluminationAltitude, "nativeGetHillshadeIlluminationAltitude"),
         METHOD(&HillshadeLayer::getHillshadeIlluminationAnchor, "nativeGetHillshadeIlluminationAnchor"),
         METHOD(&HillshadeLayer::getHillshadeExaggerationTransition, "nativeGetHillshadeExaggerationTransition"),
         METHOD(&HillshadeLayer::setHillshadeExaggerationTransition, "nativeSetHillshadeExaggerationTransition"),
@@ -238,7 +259,8 @@ void HillshadeJavaLayerPeerFactory::registerNative(jni::JNIEnv& env) {
         METHOD(&HillshadeLayer::getHillshadeHighlightColor, "nativeGetHillshadeHighlightColor"),
         METHOD(&HillshadeLayer::getHillshadeAccentColorTransition, "nativeGetHillshadeAccentColorTransition"),
         METHOD(&HillshadeLayer::setHillshadeAccentColorTransition, "nativeSetHillshadeAccentColorTransition"),
-        METHOD(&HillshadeLayer::getHillshadeAccentColor, "nativeGetHillshadeAccentColor"));
+        METHOD(&HillshadeLayer::getHillshadeAccentColor, "nativeGetHillshadeAccentColor"),
+        METHOD(&HillshadeLayer::getHillshadeMethod, "nativeGetHillshadeMethod"));
 }
 
 } // namespace android

platform/android/MapLibreAndroid/src/cpp/style/layers/hillshade_layer.hpp

@@ -28,6 +28,8 @@ public:
 
     jni::Local<jni::Object<jni::ObjectTag>> getHillshadeIlluminationDirection(jni::JNIEnv&);
 
+    jni::Local<jni::Object<jni::ObjectTag>> getHillshadeIlluminationAltitude(jni::JNIEnv&);
+
     jni::Local<jni::Object<jni::ObjectTag>> getHillshadeIlluminationAnchor(jni::JNIEnv&);
 
     jni::Local<jni::Object<jni::ObjectTag>> getHillshadeExaggeration(jni::JNIEnv&);
@@ -46,6 +48,8 @@ public:
     void setHillshadeAccentColorTransition(jni::JNIEnv&, jlong duration, jlong delay);
     jni::Local<jni::Object<TransitionOptions>> getHillshadeAccentColorTransition(jni::JNIEnv&);
 
+    jni::Local<jni::Object<jni::ObjectTag>> getHillshadeMethod(jni::JNIEnv&);
+
 }; // class HillshadeLayer
 
 class HillshadeJavaLayerPeerFactory final : public JavaLayerPeerFactory, public mbgl::HillshadeLayerFactory {

platform/android/MapLibreAndroid/src/cpp/style/layers/layer_manager.cpp

@@ -8,6 +8,7 @@
 
 #include "background_layer.hpp"
 #include "circle_layer.hpp"
+#include "color_relief_layer.hpp"
 #include "custom_layer.hpp"
 #include "fill_extrusion_layer.hpp"
 #include "fill_layer.hpp"
@@ -59,6 +60,11 @@ LayerManagerAndroid::LayerManagerAndroid() {
 #elif !defined(MBGL_LAYER_HILLSHADE_DISABLE_ALL)
     addLayerType(std::make_unique<HillshadeJavaLayerPeerFactory>());
 #endif
+#if defined(MBGL_LAYER_COLOR_RELIEF_DISABLE_RUNTIME)
+    addLayerTypeCoreOnly(std::make_unique<ColorReliefLayerFactory>());
+#elif !defined(MBGL_LAYER_COLOR_RELIEF_DISABLE_ALL)
+    addLayerType(std::make_unique<ColorReliefJavaLayerPeerFactory>());
+#endif
 #if defined(MBGL_LAYER_FILL_EXTRUSION_DISABLE_RUNTIME)
     addLayerTypeCoreOnly(std::make_unique<FillExtrusionLayerFactory>());
 #elif !defined(MBGL_LAYER_FILL_EXTRUSION_DISABLE_ALL)