¿Cómo desarrollar aplicaciones OpenGL ES (GLES) 2.0 en Linux?

Mesa lo apoya. Si desea restringirse a OpenGL ES solo luego deberá compilarlo en un directorio separado y luego agregar los directorios de biblioteca e inclusión apropiados.

Actualización:

Puede (todavía) usar PowerVR SDK y ahora también es compatible con Vulkan. Enlaces actualizados:

• Página SDK de PowerVR:https://www.imgtec.com/developers/powervr-sdk-tools/powervr-sdk/
• Página de descarga de instaladores:https://www.imgtec.com/developers/powervr-sdk-tools/installers/
• Repositorio de Github:https://github.com/powervr-graphics/Native_SDK

En el momento de mi respuesta original, PowerVR SDK era la solución más completa (Mesa obtuvo compatibilidad total con OpenGL ES 2.0 con su versión 3.1 según su página de Wikipedia).

Ahora, Mesa y Mali SDK también pueden ser una opción. Para obtener información detallada sobre ellos, consulte esta respuesta detallada de Ciro Santilli 冠状病毒审查六四事件法轮功

Respuesta original:

Puede usar POWERVR SDK para emular Opengles en su PC. Puede descargar el SDK aquí. El archivo proporciona los pasos necesarios para instalar las bibliotecas de emulación como un archivo de documentación e incluye tutoriales y aplicaciones de demostración con códigos fuente.

GLFW, Mesa, Ubuntu 16.04 AMD64

Esto no fue fácil de configurar en Ubuntu 14.04, pero ahora simplemente funciona.

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

Salida:

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;
}

Las líneas clave de código son:

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

GLFW_INCLUDE_ES2 está documentado en:http://www.glfw.org/docs/latest/build_guide.html#build_macros y un vistazo rápido a la fuente muestra que reenvía a GLES:

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

Esta fuente parece estar escrita en el subconjunto común de GLES y OpenGL (como gran parte de GLES), y también se compila con -lGL si quitamos el #define GLFW_INCLUDE_ES2 .

Si agregamos cosas que no están en GLES como renderizado inmediato glBegin , el enlace falla como se esperaba.

Ver también:https://askubuntu.com/questions/244133/how-do-i-get-egl-and-opengles-libraries-for-ubuntu-running-on-virtualbox

Créditos:genpfult hizo que el código fuera mucho más correcto.

SDK OpenGL ES de ARM Malí

• descarga desde:http://malideveloper.arm.com/resources/sdks/opengl-es-sdk-for-linux/
• abrir la documentación HTML en un navegador
• siga la "Guía de inicio rápido", es simple

Contiene varios ejemplos interesantes de código abierto + repetitivo del sistema de ventanas (X11 + EGL).

El sistema de compilación admite la compilación cruzada fácil para ARM/Mali SoC, pero aún no lo he probado.

El componente clave incluido parece ser el "Emulador OpenGL ES" http://malideveloper.arm.com/resources/tools/opengl-es-emulator/ que "asigna las llamadas API OpenGL ES 3.2 a la API OpenGL". Pero eso no viene con la fuente, solo precompilado.

Utiliza un EULA empresarial personalizado que parece ser permisivo, pero sí, pregúntele a su abogado.

Probado en SDK v2.4.4.