Shader not working in CustomLayerHost on some Samsung

[MichaelUvarov]

I integrated the example with JS (https://maplibre.org/maplibre-gl-js/docs/examples/custom-style-layer/). This works on many devices, even many Samsung devices. But on some Samsung, for some reason the logs don't show errors and nothing is displayed. Help me figure out why

Part of my code:

#include <GLES3/gl3.h>
#include <android/log.h>
#include <jni.h>
#include <mbgl/style/layers/custom_layer.hpp>
#include <mbgl/util/geo.hpp>
#include <cmath>
#include <vector>
#include <array>
#include <mutex>

#define LOG_TAG "CustomLayer"
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)

const GLchar *vertexShaderSource =
    "#version 300 es\n"
    "\n"
    "in int a_vertexIndex; // Input to identify the vertex\n"
    "\n"
    "uniform highp mat4 u_matrixHigh;\n"
    "uniform highp mat4 u_matrixLow;\n"
    "uniform highp float u_zoomHigh;\n"
    "uniform highp float u_zoomLow;\n"
    "\n"
    "out vec4 v_color;\n"
    "\n"
    "float radToDeg(float rad) {\n"
    "    return rad * 180.0 / 3.1415926535;\n"
    "}\n"
    "\n"
    "float customClamp(float value, float minVal, float maxVal) {\n"
    "    return max(minVal, min(value, maxVal));\n"
    "}\n"
    "\n"
    "vec2 projectToMap(float lat, float lon, float scale) {\n"
    "    float worldSize = scale * 512.0;\n"
    "    \n"
    "    float clampedLat = customClamp(lat, -85.0511287798, 85.0511287798);\n"
    "    float mapScaleFactor = worldSize / 360.0;\n"
    "    return vec2(\n"
    "        (180.0 + lon) * mapScaleFactor,\n"
    "        (180.0 - radToDeg(log(tan(3.1415926535 / 4.0 + clampedLat * 3.1415926535 / 360.0)))) * mapScaleFactor\n"
    "    );\n"
    "}\n"
    "\n"
    "void main() {\n"
    "    int sectorIndex = a_vertexIndex % 3;\n"
    "    \n"
    "    float u_lat = 0.0;\n"
    "    float u_lon = 0.0;\n"
    "    \n"
    "    if (sectorIndex == 0) {\n"
    "        u_lat = 60.239;\n"
    "        u_lon = 25.004;\n"
    "    } else if (sectorIndex == 1) {\n"
    "        u_lat = 52.562;\n"
    "        u_lon = 13.403;\n"
    "    } else if (sectorIndex == 2) {\n"
    "        u_lat = 50.541;\n"
    "        u_lon = 30.498;\n"
    "    }\n"
    "    \n"
    "    float u_zoom = u_zoomHigh + u_zoomLow;\n"
    "    float scale = pow(2.0, u_zoom);\n"
    "    vec2 mapPoint = projectToMap(u_lat, u_lon, scale);\n"
    "    \n"
    "    gl_Position = (u_matrixHigh * vec4(mapPoint, 0.0, 1.0)) + (u_matrixLow * vec4(mapPoint, 0.0, 1.0));\n"
    "    \n"
    "    vec4 colors[3];\n"
    "    colors[0] = vec4(1.0, 0.0, 0.0, 1.0); //red for index 0\n"
    "    colors[1] = vec4(0.0, 1.0, 0.0, 1.0); //green for index 1\n"
    "    colors[2] = vec4(0.0, 0.0, 1.0, 1.0); //blue for для index 2"
    "    \n"
    "    v_color = colors[sectorIndex];\n"
    "}\n";

const GLchar *fragmentShaderSource =
    "#version 300 es\n"
    "\n"
    "in highp vec4 v_color;\n"
    "\n"
    "out highp vec4 fragColor;\n"
    "\n"
    "void main() {\n"
    "    fragColor = v_color;\n"
    "}\n";

class CustomLayer : public mbgl::style::CustomLayerHost {
 public:
  CustomLayer() : data_mutex() {}

  ~CustomLayer() override {}

  void initialize() override {
    program = glCreateProgram();
    GLuint vertexShader = compileShader(GL_VERTEX_SHADER, vertexShaderSource);
    GLuint fragmentShader = compileShader(GL_FRAGMENT_SHADER, fragmentShaderSource);

    glAttachShader(program, vertexShader);
    glAttachShader(program, fragmentShader);
    glLinkProgram(program);
    checkLinkStatus();

    glDetachShader(program, vertexShader);
    glDetachShader(program, fragmentShader);
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    a_vertexIndex = glGetAttribLocation(program, "a_vertexIndex");
    if (a_vertexIndex == -1) {
      LOGE("Error: a_vertexIndex is not found in shader!");
    }

    u_matrixHigh = glGetUniformLocation(program, "u_matrixHigh");
    if (u_matrixHigh == -1) {
      LOGE("Error: u_matrixHigh is not found in shader!");
    }

    u_matrixLow = glGetUniformLocation(program, "u_matrixLow");
    if (u_matrixLow == -1) {
      LOGE("Error: u_matrixLow is not found in shader!");
    }

    u_zoomHigh = glGetUniformLocation(program, "u_zoomHigh");
    if (u_zoomHigh == -1) {
      LOGE("Error: u_zoomHigh is not found in shader!");
    }

    u_zoomLow = glGetUniformLocation(program, "u_zoomLow");
    if (u_zoomLow == -1) {
      LOGE("Error: u_zoomLow is not found in shader!");
    }

    GLenum erMatrix = glGetError();
    if (erMatrix != GL_NO_ERROR) {
      LOGE("Error OpenGL initialize: 0x%x", erMatrix);
    }
  }

  void render(const mbgl::style::CustomLayerRenderParameters &params) override {
    if (program == 0) {
      LOGE("Error: program is not initialized!");
      return;
    }

    std::lock_guard<std::mutex> lock(data_mutex);

    glUseProgram(program);

    // Convert matrix to float
    // Transmit high and low parts for latitude and longitude
    std::array<float, 16> projectionMatrixHigh;
    std::array<float, 16> projectionMatrixLow;
    for (int i = 0; i < 16; ++i) {
      double originalValue = params.projectionMatrix[i];
      float highPart = static_cast<float>(originalValue);
      float lowPart = static_cast<float>(originalValue - highPart);
      projectionMatrixHigh[i] = highPart;
      projectionMatrixLow[i] = lowPart;
    }
    glUniformMatrix4fv(u_matrixHigh, 1, GL_FALSE, projectionMatrixHigh.data());
    glUniformMatrix4fv(u_matrixLow, 1, GL_FALSE, projectionMatrixLow.data());

    GLenum erMatrix = glGetError();
    if (erMatrix != GL_NO_ERROR) {
      LOGE("Error OpenGL set matrix: 0x%x", erMatrix);
    }

    if (vertexIndexBuffer == 0) {
      createVerticesIndexes(6);
      updateBuffer(vertexIndexBuffer, vertexIndexBufferSize, verticesIndexes);
      GLenum erVertexBufferError = glGetError();
      if (erVertexBufferError != GL_NO_ERROR) {
        LOGE("Error OpenGL updateVertexBuffer: 0x%x", erVertexBufferError);
      }
    }

    // Pass zoom level to shader
    // Transmit high and low parts for latitude and longitude
    double originalZoom = params.zoom;
    float zoomHigh = static_cast<float>(originalZoom);
    float zoomLow = static_cast<float>(originalZoom - zoomHigh);
    glUniform1f(u_zoomHigh, zoomHigh);
    glUniform1f(u_zoomLow, zoomLow);

    glEnableVertexAttribArray(a_vertexIndex);
    glBindBuffer(GL_ARRAY_BUFFER, vertexIndexBuffer);
    glVertexAttribPointer(a_vertexIndex, 1, GL_INT, GL_FALSE, 0, nullptr);

    glDrawArrays(GL_TRIANGLES, 0, 3);

    glDisableVertexAttribArray(a_vertexIndex);
    glUseProgram(0);

    // Check OpenGL error after step draw
    GLenum err;
    while ((err = glGetError()) != GL_NO_ERROR) {
      LOGE("Error OpenGL render: 0x%x", err);
    }
  }

  void deinitialize() override {
    std::lock_guard<std::mutex> lock(data_mutex);

    cleanupResources();
  }

  void contextLost() override {
    std::lock_guard<std::mutex> lock(data_mutex);

    cleanupResources();
  }
 ...

[MichaelUvarov]

solution found: driver on some samsung does not accept int on vertex shader input, need use float