Come sviluppare applicazioni OpenGL ES (GLES) 2.0 su Linux?

Mesa lo sostiene. Se vuoi limitarti solo a OpenGL ES quindi dovrai compilarlo in una directory separata e quindi aggiungere le directory include e library appropriate.

Aggiornamento:

Puoi (ancora) utilizzare PowerVR SDK e ora supporta anche Vulkan. Collegamenti aggiornati:

• Pagina PowerVR SDK:https://www.imgtec.com/developers/powervr-sdk-tools/powervr-sdk/
• Pagina di download degli installatori:https://www.imgtec.com/developers/powervr-sdk-tools/installers/
• Repository Github:https://github.com/powervr-graphics/Native_SDK

Al momento della mia risposta originale, PowerVR SDK era la soluzione più completa (Mesa ha ottenuto il pieno supporto OpenGL ES 2.0 con la sua versione 3.1 secondo la sua pagina Wikipedia).

Ora, anche Mesa e Mali SDK possono essere una scelta. Per informazioni dettagliate su questi, fai riferimento a questa risposta dettagliata di Ciro Santilli 冠状病毒审查六四事件法轮功

Risposta originale:

Puoi utilizzare POWERVR SDK per emulare Opengl es sul tuo PC. Puoi scaricare l'SDK qui. L'archivio fornisce i passaggi necessari per installare le librerie di emulazione come file di documentazione e include tutorial e applicazioni demo con codici sorgente.

GLFW, Mesa, Ubuntu 16.04 AMD64

Non era facile da configurare su Ubuntu 14.04, ma ora funziona.

sudo apt-get install libglfw3-dev libgles2-mesa-dev
gcc glfw_triangle.c -lGLESv2 -lglfw

Uscita:

glfw_triangle.c

#include <stdio.h>
#include <stdlib.h>

#define GLFW_INCLUDE_ES2
#include <GLFW/glfw3.h>

static const GLuint WIDTH = 800;
static const GLuint HEIGHT = 600;
static const GLchar* vertex_shader_source =
    "#version 100\n"
    "attribute vec3 position;\n"
    "void main() {\n"
    "   gl_Position = vec4(position, 1.0);\n"
    "}\n";
static const GLchar* fragment_shader_source =
    "#version 100\n"
    "void main() {\n"
    "   gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
    "}\n";
static const GLfloat vertices[] = {
     0.0f,  0.5f, 0.0f,
     0.5f, -0.5f, 0.0f,
    -0.5f, -0.5f, 0.0f,
};

GLint common_get_shader_program(const char *vertex_shader_source, const char *fragment_shader_source) {
    enum Consts {INFOLOG_LEN = 512};
    GLchar infoLog[INFOLOG_LEN];
    GLint fragment_shader;
    GLint shader_program;
    GLint success;
    GLint vertex_shader;

    /* Vertex shader */
    vertex_shader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertex_shader, 1, &vertex_shader_source, NULL);
    glCompileShader(vertex_shader);
    glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &success);
    if (!success) {
        glGetShaderInfoLog(vertex_shader, INFOLOG_LEN, NULL, infoLog);
        printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n%s\n", infoLog);
    }

    /* Fragment shader */
    fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragment_shader, 1, &fragment_shader_source, NULL);
    glCompileShader(fragment_shader);
    glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &success);
    if (!success) {
        glGetShaderInfoLog(fragment_shader, INFOLOG_LEN, NULL, infoLog);
        printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n%s\n", infoLog);
    }

    /* Link shaders */
    shader_program = glCreateProgram();
    glAttachShader(shader_program, vertex_shader);
    glAttachShader(shader_program, fragment_shader);
    glLinkProgram(shader_program);
    glGetProgramiv(shader_program, GL_LINK_STATUS, &success);
    if (!success) {
        glGetProgramInfoLog(shader_program, INFOLOG_LEN, NULL, infoLog);
        printf("ERROR::SHADER::PROGRAM::LINKING_FAILED\n%s\n", infoLog);
    }

    glDeleteShader(vertex_shader);
    glDeleteShader(fragment_shader);
    return shader_program;
}

int main(void) {
    GLuint shader_program, vbo;
    GLint pos;
    GLFWwindow* window;

    glfwInit();
    glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
    window = glfwCreateWindow(WIDTH, HEIGHT, __FILE__, NULL, NULL);
    glfwMakeContextCurrent(window);

    printf("GL_VERSION  : %s\n", glGetString(GL_VERSION) );
    printf("GL_RENDERER : %s\n", glGetString(GL_RENDERER) );

    shader_program = common_get_shader_program(vertex_shader_source, fragment_shader_source);
    pos = glGetAttribLocation(shader_program, "position");

    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    glViewport(0, 0, WIDTH, HEIGHT);

    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    glVertexAttribPointer(pos, 3, GL_FLOAT, GL_FALSE, 0, (GLvoid*)0);
    glEnableVertexAttribArray(pos);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    while (!glfwWindowShouldClose(window)) {
        glfwPollEvents();
        glClear(GL_COLOR_BUFFER_BIT);
        glUseProgram(shader_program);
        glDrawArrays(GL_TRIANGLES, 0, 3);
        glfwSwapBuffers(window);
    }
    glDeleteBuffers(1, &vbo);
    glfwTerminate();
    return EXIT_SUCCESS;
}

Le linee chiave del codice sono:

#define GLFW_INCLUDE_ES2
#include <GLFW/glfw3.h>

GLFW_INCLUDE_ES2 è documentato su:http://www.glfw.org/docs/latest/build_guide.html#build_macros e una rapida occhiata alla fonte mostra che inoltra a GLES:

 #elif defined(GLFW_INCLUDE_ES2)
  #include <GLES2/gl2.h>
  #if defined(GLFW_INCLUDE_GLEXT)
   #include <GLES2/gl2ext.h>
  #endif

Questa fonte sembra essere scritta nel sottoinsieme comune di GLES e OpenGL (come gran parte di GLES), e compila anche con -lGL se rimuoviamo il #define GLFW_INCLUDE_ES2 .

Se aggiungiamo cose che non sono in GLES come il rendering immediato glBegin , il collegamento non riesce come previsto.

Vedi anche:https://askubuntu.com/questions/244133/how-do-i-get-egl-and-openngles-libraries-for-ubuntu-running-on-virtualbox

Riconoscimenti:genpfult ha reso il codice molto più corretto.

SDK ARM Mali OpenGL ES

• scarica da:http://malideveloper.arm.com/resources/sdks/opengl-es-sdk-for-linux/
• apri la documentazione HTML su un browser
• segui la "Quick Start Guide", è semplice

Contiene diversi interessanti esempi open source + boilerplate del sistema a finestre (X11 + EGL).

Il sistema di compilazione supporta una facile compilazione incrociata per SoC ARM/Mali, ma non l'ho ancora testato.

Il componente chiave incluso sembra essere "OpenGL ES Emulator" http://malideveloper.arm.com/resources/tools/opengl-es-emulator/ che "mappa le chiamate API OpenGL ES 3.2 all'API OpenGL". Ma questo non viene fornito con i sorgenti, solo precompilato.

Utilizza un EULA aziendale personalizzato che sembra essere permissivo, ma sì, chiedi al tuo avvocato.

Testato su SDK v2.4.4.