@acalcutt/maplibre-gl-native-test 5.0.1-pre.16 → 5.0.2-pre.1

package/platform/android/src/bitmap.cpp

@@ -1,124 +0,0 @@
-#include "bitmap.hpp"
-
-#include <android/bitmap.h>
-#include <mbgl/util/logging.hpp>
-
-namespace mbgl {
-namespace android {
-
-class PixelGuard {
-public:
-    PixelGuard(jni::JNIEnv& env_, const jni::Object<Bitmap>& bitmap_) : env(env_), bitmap(bitmap_) {
-        const int result = AndroidBitmap_lockPixels(&env, jni::Unwrap(*bitmap),
-                                                    reinterpret_cast<void**>(&address));
-        if (result != ANDROID_BITMAP_RESULT_SUCCESS) {
-            throw std::runtime_error("bitmap decoding: could not lock pixels");
-        }
-    }
-
-    ~PixelGuard() {
-        const int result = AndroidBitmap_unlockPixels(&env, jni::Unwrap(*bitmap));
-        if (result != ANDROID_BITMAP_RESULT_SUCCESS) {
-            Log::Warning(mbgl::Event::General, "Bitmap decoding: could not unlock pixels");
-        }
-    }
-
-    auto* get() {
-        return address;
-    }
-
-private:
-    jni::JNIEnv& env;
-    const jni::Object<Bitmap>& bitmap;
-    uint8_t* address;
-};
-
-jni::Local<jni::Object<Bitmap::Config>> Bitmap::Config::Create(jni::JNIEnv& env, Value value) {
-    static auto& _class = jni::Class<Config>::Singleton(env);
-    switch (value) {
-    case ALPHA_8:
-        return _class.Get(env, _class.GetStaticField<jni::Object<Config>>(env, "ALPHA_8"));
-    case ARGB_4444:
-        return _class.Get(env, _class.GetStaticField<jni::Object<Config>>(env, "ARGB_4444"));
-    case ARGB_8888:
-        return _class.Get(env, _class.GetStaticField<jni::Object<Config>>(env, "ARGB_8888"));
-    case RGB_565:
-        return _class.Get(env, _class.GetStaticField<jni::Object<Config>>(env, "RGB_565"));
-    default:
-        throw std::runtime_error("invalid enum value for Bitmap.Config");
-    }
-}
-
-void Bitmap::registerNative(jni::JNIEnv& env) {
-    jni::Class<Bitmap>::Singleton(env);
-    jni::Class<Bitmap::Config>::Singleton(env);
-}
-
-jni::Local<jni::Object<Bitmap>> Bitmap::CreateBitmap(jni::JNIEnv& env,
-                                                     jni::jint width,
-                                                     jni::jint height,
-                                                     const jni::Object<Config>& config) {
-    static auto& _class = jni::Class<Bitmap>::Singleton(env);
-    static auto method = _class.GetStaticMethod<jni::Object<Bitmap> (jni::jint, jni::jint, jni::Object<Config>)>(env, "createBitmap");
-
-    return _class.Call(env, method, width, height, config);
-}
-
-PremultipliedImage Bitmap::GetImage(jni::JNIEnv& env, const jni::Object<Bitmap>& bitmap) {
-    AndroidBitmapInfo info;
-    const int result = AndroidBitmap_getInfo(&env, jni::Unwrap(*bitmap), &info);
-    if (result != ANDROID_BITMAP_RESULT_SUCCESS) {
-        throw std::runtime_error("bitmap decoding: couldn't get bitmap info");
-    }
-    if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {
-        return Bitmap::GetImage(env, Bitmap::Copy(env, bitmap));
-    }
-
-    PixelGuard guard(env, bitmap);
-
-    // Copy the Android Bitmap into the PremultipliedImage.
-    auto pixels =
-        std::make_unique<uint8_t[]>(info.width * info.height * PremultipliedImage::channels);
-    for (uint32_t y = 0; y < info.height; y++) {
-        auto begin = guard.get() + y * info.stride;
-        std::copy(begin, begin + info.width * PremultipliedImage::channels,
-            pixels.get() + y * info.width * PremultipliedImage::channels);
-    }
-
-    return { Size{ info.width, info.height }, std::move(pixels) };
-}
-
-jni::Local<jni::Object<Bitmap>> Bitmap::CreateBitmap(jni::JNIEnv& env, const PremultipliedImage& image) {
-    auto bitmap = CreateBitmap(env, image.size.width, image.size.height, Config::ARGB_8888);
-
-    AndroidBitmapInfo info;
-    const int result = AndroidBitmap_getInfo(&env, jni::Unwrap(*bitmap), &info);
-    if (result != ANDROID_BITMAP_RESULT_SUCCESS) {
-        // TODO: more specific information
-        throw std::runtime_error("bitmap creation: couldn't get bitmap info");
-    }
-
-    assert(info.width == image.size.width);
-    assert(info.height == image.size.height);
-    assert(info.format == ANDROID_BITMAP_FORMAT_RGBA_8888);
-
-    PixelGuard guard(env, bitmap);
-
-    // Copy the PremultipliedImage into the Android Bitmap
-    for (uint32_t y = 0; y < image.size.height; y++) {
-        auto begin = image.data.get() + y * image.stride();
-        std::copy(begin, begin + image.stride(), guard.get() + y * info.stride);
-    }
-
-    return bitmap;
-}
-
-jni::Local<jni::Object<Bitmap>> Bitmap::Copy(jni::JNIEnv& env, const jni::Object<Bitmap>& bitmap) {
-    static auto& klass = jni::Class<Bitmap>::Singleton(env);
-    static auto copy = klass.GetMethod<jni::Object<Bitmap> (jni::Object<Config>, jni::jboolean)>(env, "copy");
-
-    return bitmap.Call(env, copy, Bitmap::Config::Create(env, Bitmap::Config::Value::ARGB_8888), jni::jni_false);
-}
-
-} // namespace android
-} // namespace mbgl

package/platform/android/src/bitmap.hpp

@@ -1,43 +0,0 @@
-#pragma once
-
-#include <mbgl/util/image.hpp>
-
-#include <jni/jni.hpp>
-
-namespace mbgl {
-namespace android {
-
-class Bitmap {
-public:
-    class Config {
-    public:
-        static constexpr auto Name() { return "android/graphics/Bitmap$Config"; };
-
-        enum Value {
-            ALPHA_8,
-            ARGB_4444,
-            ARGB_8888,
-            RGB_565,
-        };
-
-        static jni::Local<jni::Object<Config>> Create(jni::JNIEnv&, Value);
-    };
-
-    static constexpr auto Name() { return "android/graphics/Bitmap"; };
-    static void registerNative(jni::JNIEnv&);
-
-    static jni::Local<jni::Object<Bitmap>>
-    CreateBitmap(jni::JNIEnv&, jni::jint width, jni::jint height, const jni::Object<Config>&);
-
-    static jni::Local<jni::Object<Bitmap>>
-    CreateBitmap(jni::JNIEnv& env, jni::jint width, jni::jint height, Config::Value config) {
-        return CreateBitmap(env, width, height, Config::Create(env, config));
-    }
-
-    static PremultipliedImage GetImage(jni::JNIEnv&, const jni::Object<Bitmap>&);
-    static jni::Local<jni::Object<Bitmap>> CreateBitmap(jni::JNIEnv&, const PremultipliedImage&);
-    static jni::Local<jni::Object<Bitmap>> Copy(jni::JNIEnv&, const jni::Object<Bitmap>&);
-};
-
-} // namespace android
-} // namespace mbgl

package/platform/android/src/bitmap_factory.cpp

@@ -1,25 +0,0 @@
-#include "bitmap_factory.hpp"
-
-namespace mbgl {
-namespace android {
-
-void BitmapFactory::registerNative(jni::JNIEnv& env) {
-    jni::Class<BitmapFactory>::Singleton(env);
-}
-
-jni::Local<jni::Object<Bitmap>> BitmapFactory::DecodeByteArray(jni::JNIEnv& env,
-                                                               jni::Array<jni::jbyte>& data,
-                                                               jni::jint offset,
-                                                               jni::jint length) {
-    static auto& _class = jni::Class<BitmapFactory>::Singleton(env);
-
-    // Images are loaded with ARGB_8888 config, and premultiplied by default, which is exactly
-    // what we want, so we're not providing a BitmapFactory.Options object.
-    using Signature = jni::Object<Bitmap> (jni::Array<jni::jbyte>, jni::jint, jni::jint);
-    static auto method = _class.GetStaticMethod<Signature>(env, "decodeByteArray");
-
-    return _class.Call(env, method, data, offset, length);
-}
-
-} // namespace android
-} // namespace mbgl

package/platform/android/src/bitmap_factory.hpp

@@ -1,20 +0,0 @@
-#pragma once
-
-#include <jni/jni.hpp>
-
-#include "bitmap.hpp"
-
-namespace mbgl {
-namespace android {
-
-class BitmapFactory {
-public:
-    static constexpr auto Name() { return "android/graphics/BitmapFactory"; };
-    static void registerNative(jni::JNIEnv&);
-
-    static jni::Local<jni::Object<Bitmap>>
-    DecodeByteArray(jni::JNIEnv&, jni::Array<jni::jbyte>& data, jni::jint offset, jni::jint length);
-};
-
-} // namespace android
-} // namespace mbgl

package/platform/android/src/example_custom_layer.cpp

@@ -1,238 +0,0 @@
-#include <GLES2/gl2.h>
-#include <android/log.h>
-#include <jni.h>
-#include <mbgl/gl/custom_layer.hpp>
-#include <sstream>
-
-// DEBUGGING
-
-const char* LOG_TAG = "Custom Layer Example";
-
-const char* stringFromError(GLenum err) {
-    switch (err) {
-        case GL_INVALID_ENUM:
-            return "GL_INVALID_ENUM";
-
-        case GL_INVALID_VALUE:
-            return "GL_INVALID_VALUE";
-
-        case GL_INVALID_OPERATION:
-            return "GL_INVALID_OPERATION";
-
-        case GL_INVALID_FRAMEBUFFER_OPERATION:
-            return "GL_INVALID_FRAMEBUFFER_OPERATION";
-
-        case GL_OUT_OF_MEMORY:
-            return "GL_OUT_OF_MEMORY";
-
-#ifdef GL_TABLE_TOO_LARGE
-        case GL_TABLE_TOO_LARGE:
-        return "GL_TABLE_TOO_LARGE";
-#endif
-
-#ifdef GL_STACK_OVERFLOW
-        case GL_STACK_OVERFLOW:
-        return "GL_STACK_OVERFLOW";
-#endif
-
-#ifdef GL_STACK_UNDERFLOW
-        case GL_STACK_UNDERFLOW:
-        return "GL_STACK_UNDERFLOW";
-#endif
-
-#ifdef GL_CONTEXT_LOST
-        case GL_CONTEXT_LOST:
-        return "GL_CONTEXT_LOST";
-#endif
-
-        default:
-            return "GL_UNKNOWN";
-    }
-}
-
-struct Error : std::runtime_error {
-    using std::runtime_error::runtime_error;
-};
-
-void checkError(const char *cmd, const char *file, int line) {
-
-    GLenum err = GL_NO_ERROR;
-    if ((err = glGetError()) != GL_NO_ERROR) {
-        std::ostringstream message;
-        message << cmd  << ": Error " << stringFromError(err);
-
-        // Check for further errors
-        while ((err = glGetError()) != GL_NO_ERROR) {
-            message << ", " << stringFromError(err);
-        }
-
-        message << " at " << file << ":" << line;
-        __android_log_write(ANDROID_LOG_ERROR, LOG_TAG, message.str().c_str());
-        throw Error(message.str());
-    }
-}
-
-#ifndef NDEBUG
-#define GL_CHECK_ERROR(cmd) ([&]() { struct __MBGL_C_E { ~__MBGL_C_E() noexcept(false) { checkError(#cmd, __FILE__, __LINE__); } } __MBGL_C_E; return cmd; }())
-#else
-#define GL_CHECK_ERROR(cmd) (cmd)
-#endif
-
-void checkLinkStatus(GLuint program) {
-    GLint isLinked = 0;
-    glGetProgramiv(program, GL_LINK_STATUS, &isLinked);
-    if (isLinked == GL_FALSE) {
-        GLint maxLength = 0;
-        glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength);
-        GLchar infoLog[maxLength];
-        glGetProgramInfoLog(program, maxLength, &maxLength, &infoLog[0]);
-        __android_log_write(ANDROID_LOG_ERROR, LOG_TAG, &infoLog[0]);
-        throw Error(infoLog);
-    }
-
-}
-
-void checkCompileStatus(GLuint shader) {
-    GLint isCompiled = 0;
-    glGetShaderiv(shader, GL_COMPILE_STATUS, &isCompiled);
-    if (isCompiled == GL_FALSE) {
-        GLint maxLength = 0;
-        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
-
-        // The maxLength includes the NULL character
-        GLchar errorLog[maxLength];
-        glGetShaderInfoLog(shader, maxLength, &maxLength, &errorLog[0]);
-        __android_log_write(ANDROID_LOG_ERROR, LOG_TAG, &errorLog[0]);
-        throw Error(errorLog);
-    }
-}
-
-// /DEBUGGING
-
-static const GLchar * vertexShaderSource = "attribute vec2 a_pos; void main() { gl_Position = vec4(a_pos, 0, 1); }";
-static const GLchar * fragmentShaderSource = "uniform highp vec4 fill_color; void main() { gl_FragColor = fill_color; }";
-
-class ExampleCustomLayer: mbgl::style::CustomLayerHost {
-public:
-    ~ExampleCustomLayer() {
-    }
-
-    void initialize() {
-        __android_log_write(ANDROID_LOG_INFO, LOG_TAG, "Initialize");
-
-        // Debug info
-        int maxAttrib;
-        GL_CHECK_ERROR(glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxAttrib));
-        __android_log_print(ANDROID_LOG_INFO, LOG_TAG, "Max vertex attributes: %i", maxAttrib);
-
-        program = GL_CHECK_ERROR(glCreateProgram());
-        vertexShader = GL_CHECK_ERROR(glCreateShader(GL_VERTEX_SHADER));
-        fragmentShader = GL_CHECK_ERROR(glCreateShader(GL_FRAGMENT_SHADER));
-
-        GL_CHECK_ERROR(glShaderSource(vertexShader, 1, &vertexShaderSource, nullptr));
-        GL_CHECK_ERROR(glCompileShader(vertexShader));
-        checkCompileStatus(vertexShader);
-        GL_CHECK_ERROR(glAttachShader(program, vertexShader));
-        GL_CHECK_ERROR(glShaderSource(fragmentShader, 1, &fragmentShaderSource, nullptr));
-        GL_CHECK_ERROR(glCompileShader(fragmentShader));
-        checkCompileStatus(fragmentShader);
-        GL_CHECK_ERROR(glAttachShader(program, fragmentShader));
-        GL_CHECK_ERROR(glLinkProgram(program));
-        checkLinkStatus(program);
-
-        a_pos = GL_CHECK_ERROR(glGetAttribLocation(program, "a_pos"));
-        fill_color = GL_CHECK_ERROR(glGetUniformLocation(program, "fill_color"));
-
-        GLfloat background[] = { -1, -1, 1, -1, -1, 1, 1, 1 };
-        GL_CHECK_ERROR(glGenBuffers(1, &buffer));
-        GL_CHECK_ERROR(glBindBuffer(GL_ARRAY_BUFFER, buffer));
-        GL_CHECK_ERROR(glBufferData(GL_ARRAY_BUFFER, 8 * sizeof(GLfloat), background, GL_STATIC_DRAW));
-    }
-
-    void render(const mbgl::style::CustomLayerRenderParameters&) {
-        __android_log_write(ANDROID_LOG_INFO, LOG_TAG, "Render");
-        glUseProgram(program);
-        glBindBuffer(GL_ARRAY_BUFFER, buffer);
-        glEnableVertexAttribArray(a_pos);
-        glVertexAttribPointer(a_pos, 2, GL_FLOAT, GL_FALSE, 0, NULL);
-        glDisable(GL_STENCIL_TEST);
-        glDisable(GL_DEPTH_TEST);
-        glUniform4fv(fill_color, 1, color);
-
-        GL_CHECK_ERROR(glUseProgram(program));
-        GL_CHECK_ERROR(glBindBuffer(GL_ARRAY_BUFFER, buffer));
-        GL_CHECK_ERROR(glEnableVertexAttribArray(a_pos));
-        GL_CHECK_ERROR(glVertexAttribPointer(a_pos, 2, GL_FLOAT, GL_FALSE, 0, NULL));
-        GL_CHECK_ERROR(glDisable(GL_STENCIL_TEST));
-        GL_CHECK_ERROR(glDisable(GL_DEPTH_TEST));
-        GL_CHECK_ERROR(glUniform4fv(fill_color, 1, color));
-        GL_CHECK_ERROR(glDrawArrays(GL_TRIANGLE_STRIP, 0, 4));
-
-    }
-
-    void contextLost() {
-        __android_log_write(ANDROID_LOG_INFO, LOG_TAG, "ContextLost");
-        program = 0;
-    }
-
-    void deinitialize() {
-        __android_log_write(ANDROID_LOG_INFO, LOG_TAG, "DeInitialize");
-        if (program) {
-            glDeleteBuffers(1, &buffer);
-            glDetachShader(program, vertexShader);
-            glDetachShader(program, fragmentShader);
-            glDeleteShader(vertexShader);
-            glDeleteShader(fragmentShader);
-            glDeleteProgram(program);
-        }
-    }
-
-    GLuint program = 0;
-    GLuint vertexShader = 0;
-    GLuint fragmentShader = 0;
-    GLuint buffer = 0;
-    GLuint a_pos = 0;
-    GLuint fill_color = 0;
-
-    static GLfloat color[];
-};
-
-GLfloat ExampleCustomLayer::color[] = { 0.0f, 1.0f, 0.0f, 1.0f };
-
-jlong JNICALL nativeCreateContext(JNIEnv*, jobject) {
-    __android_log_write(ANDROID_LOG_INFO, LOG_TAG, "nativeCreateContext");
-    auto exampleCustomLayer = std::make_unique<ExampleCustomLayer>();
-    return reinterpret_cast<jlong>(exampleCustomLayer.release());
-}
-
-void JNICALL nativeSetColor(JNIEnv*, jobject, jfloat red, jfloat green, jfloat blue, jfloat alpha) {
-    __android_log_print(ANDROID_LOG_INFO, LOG_TAG, "nativeSetColor: %.2f, %.2f, %.2f, %.2f", red, green, blue, alpha);
-    ExampleCustomLayer::color[0] = red;
-    ExampleCustomLayer::color[1] = green;
-    ExampleCustomLayer::color[2] = blue;
-    ExampleCustomLayer::color[3] = alpha;
-}
-
-extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
-    __android_log_write(ANDROID_LOG_INFO, LOG_TAG, "OnLoad");
-
-    JNIEnv *env = nullptr;
-    vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6);
-
-    jclass customLayerClass = env->FindClass("com/mapbox/mapboxsdk/testapp/model/customlayer/ExampleCustomLayer");
-
-    JNINativeMethod methods[] = {
-        {"createContext", "()J", reinterpret_cast<void *>(&nativeCreateContext)},
-        {"setColor", "(FFFF)V", reinterpret_cast<void *>(&nativeSetColor)}
-    };
-
-    if (env->RegisterNatives(customLayerClass, methods, 2) < 0) {
-        env->ExceptionDescribe();
-        return JNI_ERR;
-    }
-
-    return JNI_VERSION_1_6;
-}
-
-extern "C" JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *, void *) {
-}

package/platform/android/src/gl_functions.cpp

@@ -1,156 +0,0 @@
-#include <mbgl/platform/gl_functions.hpp>
-
-#define GL_GLEXT_PROTOTYPES
-#include <GLES2/gl2.h>
-#include <GLES2/gl2ext.h>
-
-namespace mbgl {
-namespace platform {
-
-void (* const glActiveTexture)(GLenum) = ::glActiveTexture;
-void (* const glAttachShader)(GLuint, GLuint) = ::glAttachShader;
-void (* const glBindAttribLocation)(GLuint, GLuint, const GLchar *) = ::glBindAttribLocation;
-void (* const glBindBuffer)(GLenum, GLuint) = ::glBindBuffer;
-void (* const glBindFramebuffer)(GLenum, GLuint) = ::glBindFramebuffer;
-void (* const glBindRenderbuffer)(GLenum, GLuint) = ::glBindRenderbuffer;
-void (* const glBindTexture)(GLenum, GLuint) = ::glBindTexture;
-void (* const glBlendColor)(GLfloat, GLfloat, GLfloat, GLfloat) = ::glBlendColor;
-void (* const glBlendEquation)(GLenum) = ::glBlendEquation;
-void (* const glBlendEquationSeparate)(GLenum, GLenum) = ::glBlendEquationSeparate;
-void (* const glBlendFunc)(GLenum, GLenum) = ::glBlendFunc;
-void (* const glBlendFuncSeparate)(GLenum, GLenum, GLenum, GLenum) = ::glBlendFuncSeparate;
-void (* const glBufferData)(GLenum, GLsizeiptr, const void *, GLenum) = ::glBufferData;
-void (* const glBufferSubData)(GLenum, GLintptr, GLsizeiptr, const void *) = ::glBufferSubData;
-GLenum (* const glCheckFramebufferStatus)(GLenum) = ::glCheckFramebufferStatus;
-void (* const glClear)(GLbitfield) = ::glClear;
-void (* const glClearColor)(GLfloat, GLfloat, GLfloat, GLfloat) = ::glClearColor;
-void (* const glClearDepthf)(GLfloat) = ::glClearDepthf;
-void (* const glClearStencil)(GLint) = ::glClearStencil;
-void (* const glColorMask)(GLboolean, GLboolean, GLboolean, GLboolean) = ::glColorMask;
-void (* const glCompileShader)(GLuint) = ::glCompileShader;
-void (* const glCompressedTexImage2D)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const void *) = ::glCompressedTexImage2D;
-void (* const glCompressedTexSubImage2D)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const void *) = ::glCompressedTexSubImage2D;
-void (* const glCopyTexImage2D)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint) = ::glCopyTexImage2D;
-void (* const glCopyTexSubImage2D)(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei) = ::glCopyTexSubImage2D;
-GLuint (* const glCreateProgram)() = ::glCreateProgram;
-GLuint (* const glCreateShader)(GLenum) = ::glCreateShader;
-void (* const glCullFace)(GLenum) = ::glCullFace;
-void (* const glDeleteBuffers)(GLsizei, const GLuint *) = ::glDeleteBuffers;
-void (* const glDeleteFramebuffers)(GLsizei, const GLuint *) = ::glDeleteFramebuffers;
-void (* const glDeleteProgram)(GLuint) = ::glDeleteProgram;
-void (* const glDeleteRenderbuffers)(GLsizei, const GLuint *) = ::glDeleteRenderbuffers;
-void (* const glDeleteShader)(GLuint) = ::glDeleteShader;
-void (* const glDeleteTextures)(GLsizei, const GLuint *) = ::glDeleteTextures;
-void (* const glDepthFunc)(GLenum) = ::glDepthFunc;
-void (* const glDepthMask)(GLboolean) = ::glDepthMask;
-void (* const glDepthRangef)(GLfloat, GLfloat) = ::glDepthRangef;
-void (* const glDetachShader)(GLuint, GLuint) = ::glDetachShader;
-void (* const glDisable)(GLenum) = ::glDisable;
-void (* const glDisableVertexAttribArray)(GLuint) = ::glDisableVertexAttribArray;
-void (* const glDrawArrays)(GLenum, GLint, GLsizei) = ::glDrawArrays;
-void (* const glDrawElements)(GLenum, GLsizei, GLenum, const void *) = ::glDrawElements;
-void (* const glEnable)(GLenum) = ::glEnable;
-void (* const glEnableVertexAttribArray)(GLuint) = ::glEnableVertexAttribArray;
-void (* const glFinish)() = ::glFinish;
-void (* const glFlush)() = ::glFlush;
-void (* const glFramebufferRenderbuffer)(GLenum, GLenum, GLenum, GLuint) = ::glFramebufferRenderbuffer;
-void (* const glFramebufferTexture2D)(GLenum, GLenum, GLenum, GLuint, GLint) = ::glFramebufferTexture2D;
-void (* const glFrontFace)(GLenum) = ::glFrontFace;
-void (* const glGenBuffers)(GLsizei, GLuint *) = ::glGenBuffers;
-void (* const glGenerateMipmap)(GLenum) = ::glGenerateMipmap;
-void (* const glGenFramebuffers)(GLsizei, GLuint *) = ::glGenFramebuffers;
-void (* const glGenRenderbuffers)(GLsizei, GLuint *) = ::glGenRenderbuffers;
-void (* const glGenTextures)(GLsizei, GLuint *) = ::glGenTextures;
-void (* const glGetActiveAttrib)(GLuint, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLchar *) = ::glGetActiveAttrib;
-void (* const glGetActiveUniform)(GLuint, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLchar *) = ::glGetActiveUniform;
-void (* const glGetAttachedShaders)(GLuint, GLsizei, GLsizei *, GLuint *) = ::glGetAttachedShaders;
-GLint (* const glGetAttribLocation)(GLuint, const GLchar *) = ::glGetAttribLocation;
-void (* const glGetBooleanv)(GLenum, GLboolean *) = ::glGetBooleanv;
-void (* const glGetBufferParameteriv)(GLenum, GLenum, GLint *) = ::glGetBufferParameteriv;
-GLenum (* const glGetError)() = ::glGetError;
-void (* const glGetFloatv)(GLenum, GLfloat *) = ::glGetFloatv;
-void (* const glGetFramebufferAttachmentParameteriv)(GLenum, GLenum, GLenum, GLint *) = ::glGetFramebufferAttachmentParameteriv;
-void (* const glGetIntegerv)(GLenum, GLint *) = ::glGetIntegerv;
-void (* const glGetProgramInfoLog)(GLuint, GLsizei, GLsizei *, GLchar *) = ::glGetProgramInfoLog;
-void (* const glGetProgramiv)(GLuint, GLenum, GLint *) = ::glGetProgramiv;
-void (* const glGetRenderbufferParameteriv)(GLenum, GLenum, GLint *) = ::glGetRenderbufferParameteriv;
-void (* const glGetShaderInfoLog)(GLuint, GLsizei, GLsizei *, GLchar *) = ::glGetShaderInfoLog;
-void (* const glGetShaderiv)(GLuint, GLenum, GLint *) = ::glGetShaderiv;
-void (* const glGetShaderSource)(GLuint, GLsizei, GLsizei *, GLchar *) = ::glGetShaderSource;
-const GLubyte *(*glGetString)(GLenum) = ::glGetString;
-void (* const glGetTexParameterfv)(GLenum, GLenum, GLfloat *) = ::glGetTexParameterfv;
-void (* const glGetTexParameteriv)(GLenum, GLenum, GLint *) = ::glGetTexParameteriv;
-void (* const glGetUniformfv)(GLuint, GLint, GLfloat *) = ::glGetUniformfv;
-void (* const glGetUniformiv)(GLuint, GLint, GLint *) = ::glGetUniformiv;
-GLint (* const glGetUniformLocation)(GLuint, const GLchar *) = ::glGetUniformLocation;
-void (* const glGetVertexAttribfv)(GLuint, GLenum, GLfloat *) = ::glGetVertexAttribfv;
-void (* const glGetVertexAttribiv)(GLuint, GLenum, GLint *) = ::glGetVertexAttribiv;
-void (* const glGetVertexAttribPointerv)(GLuint, GLenum, void **) = ::glGetVertexAttribPointerv;
-void (* const glHint)(GLenum, GLenum) = ::glHint;
-GLboolean (* const glIsBuffer)(GLuint) = ::glIsBuffer;
-GLboolean (* const glIsEnabled)(GLenum) = ::glIsEnabled;
-GLboolean (* const glIsFramebuffer)(GLuint) = ::glIsFramebuffer;
-GLboolean (* const glIsProgram)(GLuint) = ::glIsProgram;
-GLboolean (* const glIsRenderbuffer)(GLuint) = ::glIsRenderbuffer;
-GLboolean (* const glIsShader)(GLuint) = ::glIsShader;
-GLboolean (* const glIsTexture)(GLuint) = ::glIsTexture;
-void (* const glLineWidth)(GLfloat) = ::glLineWidth;
-void (* const glLinkProgram)(GLuint) = ::glLinkProgram;
-void (* const glPixelStorei)(GLenum, GLint) = ::glPixelStorei;
-void (* const glPolygonOffset)(GLfloat, GLfloat) = ::glPolygonOffset;
-void (* const glReadPixels)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, void *) = ::glReadPixels;
-void (* const glRenderbufferStorage)(GLenum, GLenum, GLsizei, GLsizei) = ::glRenderbufferStorage;
-void (* const glSampleCoverage)(GLfloat, GLboolean) = ::glSampleCoverage;
-void (* const glScissor)(GLint, GLint, GLsizei, GLsizei) = ::glScissor;
-
-// Some implementations use `const GLchar* const*` and others `const GLchar**`.
-void (* const glShaderSource)(GLuint, GLsizei, const GLchar * const*, const GLint *) = [](GLuint shader, GLsizei count, const GLchar * const * string, const GLint *length) {
-    ::glShaderSource(shader, count, const_cast<const GLchar **>(string), length);
-};
-
-void (* const glStencilFunc)(GLenum, GLint, GLuint) = ::glStencilFunc;
-void (* const glStencilFuncSeparate)(GLenum, GLenum, GLint, GLuint) = ::glStencilFuncSeparate;
-void (* const glStencilMask)(GLuint) = ::glStencilMask;
-void (* const glStencilMaskSeparate)(GLenum, GLuint) = ::glStencilMaskSeparate;
-void (* const glStencilOp)(GLenum, GLenum, GLenum) = ::glStencilOp;
-void (* const glStencilOpSeparate)(GLenum, GLenum, GLenum, GLenum) = ::glStencilOpSeparate;
-void (* const glTexImage2D)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const void *) = ::glTexImage2D;
-void (* const glTexParameterf)(GLenum, GLenum, GLfloat) = ::glTexParameterf;
-void (* const glTexParameterfv)(GLenum, GLenum, const GLfloat *) = ::glTexParameterfv;
-void (* const glTexParameteri)(GLenum, GLenum, GLint) = ::glTexParameteri;
-void (* const glTexParameteriv)(GLenum, GLenum, const GLint *) = ::glTexParameteriv;
-void (* const glTexSubImage2D)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const void *) = ::glTexSubImage2D;
-void (* const glUniform1f)(GLint, GLfloat) = ::glUniform1f;
-void (* const glUniform1fv)(GLint, GLsizei, const GLfloat *) = ::glUniform1fv;
-void (* const glUniform1i)(GLint, GLint) = ::glUniform1i;
-void (* const glUniform1iv)(GLint, GLsizei, const GLint *) = ::glUniform1iv;
-void (* const glUniform2f)(GLint, GLfloat, GLfloat) = ::glUniform2f;
-void (* const glUniform2fv)(GLint, GLsizei, const GLfloat *) = ::glUniform2fv;
-void (* const glUniform2i)(GLint, GLint, GLint) = ::glUniform2i;
-void (* const glUniform2iv)(GLint, GLsizei, const GLint *) = ::glUniform2iv;
-void (* const glUniform3f)(GLint, GLfloat, GLfloat, GLfloat) = ::glUniform3f;
-void (* const glUniform3fv)(GLint, GLsizei, const GLfloat *) = ::glUniform3fv;
-void (* const glUniform3i)(GLint, GLint, GLint, GLint) = ::glUniform3i;
-void (* const glUniform3iv)(GLint, GLsizei, const GLint *) = ::glUniform3iv;
-void (* const glUniform4f)(GLint, GLfloat, GLfloat, GLfloat, GLfloat) = ::glUniform4f;
-void (* const glUniform4fv)(GLint, GLsizei, const GLfloat *) = ::glUniform4fv;
-void (* const glUniform4i)(GLint, GLint, GLint, GLint, GLint) = ::glUniform4i;
-void (* const glUniform4iv)(GLint, GLsizei, const GLint *) = ::glUniform4iv;
-void (* const glUniformMatrix2fv)(GLint, GLsizei, GLboolean, const GLfloat *) = ::glUniformMatrix2fv;
-void (* const glUniformMatrix3fv)(GLint, GLsizei, GLboolean, const GLfloat *) = ::glUniformMatrix3fv;
-void (* const glUniformMatrix4fv)(GLint, GLsizei, GLboolean, const GLfloat *) = ::glUniformMatrix4fv;
-void (* const glUseProgram)(GLuint) = ::glUseProgram;
-void (* const glValidateProgram)(GLuint) = ::glValidateProgram;
-void (* const glVertexAttrib1f)(GLuint, GLfloat) = ::glVertexAttrib1f;
-void (* const glVertexAttrib1fv)(GLuint, const GLfloat *) = ::glVertexAttrib1fv;
-void (* const glVertexAttrib2f)(GLuint, GLfloat, GLfloat) = ::glVertexAttrib2f;
-void (* const glVertexAttrib2fv)(GLuint, const GLfloat *) = ::glVertexAttrib2fv;
-void (* const glVertexAttrib3f)(GLuint, GLfloat, GLfloat, GLfloat) = ::glVertexAttrib3f;
-void (* const glVertexAttrib3fv)(GLuint, const GLfloat *) = ::glVertexAttrib3fv;
-void (* const glVertexAttrib4f)(GLuint, GLfloat, GLfloat, GLfloat, GLfloat) = ::glVertexAttrib4f;
-void (* const glVertexAttrib4fv)(GLuint, const GLfloat *) = ::glVertexAttrib4fv;
-void (* const glVertexAttribPointer)(GLuint, GLint, GLenum, GLboolean, GLsizei, const void *) = ::glVertexAttribPointer;
-void (* const glViewport)(GLint, GLint, GLsizei, GLsizei) = ::glViewport;
-
-}  // namespace platform
-}  // namespace mbgl

package/platform/android/src/image.cpp

@@ -1,21 +0,0 @@
-#include <mbgl/util/image.hpp>
-#include <mbgl/util/string.hpp>
-
-#include <string>
-
-#include "attach_env.hpp"
-#include "bitmap_factory.hpp"
-
-namespace mbgl {
-
-PremultipliedImage decodeImage(const std::string& string) {
-    auto env{ android::AttachEnv() };
-
-    auto array = jni::Array<jni::jbyte>::New(*env, string.size());
-    jni::SetArrayRegion(*env, *array, 0, string.size(),
-                        reinterpret_cast<const signed char*>(string.data()));
-
-    return android::Bitmap::GetImage(*env, android::BitmapFactory::DecodeByteArray(*env, array, 0, string.size()));
-}
-
-} // namespace mbgl