¿Cómo obtengo las bibliotecas EGL y OpenGLES para Ubuntu ejecutándose en VirtualBox?

Tengo Ubuntu ejecutándose en VirtualBox. Las adiciones de invitados están instaladas y ahora el sistema operativo es capaz de acelerar el hardware. Tengo la biblioteca OpenGL en su lugar.

Ahora quiero ejecutar aplicaciones usando egl + opengles1.1 y 2.0. ¿Cómo los consigo en Ubuntu?

¿Hay alguna biblioteca de código abierto disponible?

Las bibliotecas deben usar las capacidades de aceleración de hardware proporcionadas por VirtualBox.

GLFW, Mesa, Ubuntu 16.04 AMD64

No lo he probado dentro de Virtual Box, pero esto debería funcionar independientemente de que Mesa tiene una implementación de software.

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

Salida:

Fuente:

#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 de código clave son:

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

GLFW_INCLUDE_ES2está documentado en: http://www.glfw.org/docs/latest/build_guide.html#build_macros y un vistazo rápido a la fuente muestra que se 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 en el subconjunto común de GLES y OpenGL (como gran parte de GLES), y también se compila con -lGLsi eliminamos el #define GLFW_INCLUDE_ES2.

Si agregamos cosas que no están en GLES, como la representación inmediata glBegin, el enlace falla como se esperaba.

Ver también: /programming/3809236/how-to-develop-opengl-es-gles-2-0-applications-on-linux/39356268#39356268

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

BRAZO Mali OpenGL ES SDK

• descargar 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 + sistema de ventanas (X11 + EGL).

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

El componente clave incluido parece ser el "OpenGL ES Emulator" http://malideveloper.arm.com/resources/tools/opengl-es-emulator/ que "asigna las llamadas de la API de OpenGL ES 3.2 a la API de OpenGL". Pero eso no se envía 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.

Como se hizo la pregunta, apareció un paquete que podría ayudar:

sudo apt-get install libgles2-mesa-dev

Puede buscar paquetes y contenidos de paquetes con apt-cache:

> apt-cache search opengles 
mesa-utils-extra - Miscellaneous Mesa utilies (opengles, egl)

El resultado dice que OpenGLES probablemente está en el paquete mesa-utils-extra . Mesa 3D tiene una página de proyecto para OpenGLES y escribe allí:

Mesa implementa OpenGL ES 1.1 y OpenGL ES 2.0. Puede encontrar más información sobre OpenGL ES en http://www.khronos.org/opengles/ .

EGL también está integrado en Mesa:

> apt-cache search mesa | grep -i egl
mesa-utils-extra - Miscellaneous Mesa utilies (opengles, egl)
libegl1-mesa - free implementation of the EGL API -- runtime
libegl1-mesa-dbg - free implementation of the EGL API -- debugging symbols
libegl1-mesa-dev - free implementation of the EGL API -- development files
libegl1-mesa-drivers - free implementation of the EGL API -- hardware drivers
libegl1-mesa-drivers-dbg - free implementation of the EGL API -- driver debugging symbols

Entonces necesita instalar mesa-utils-extray probablemente también libegl1-mesa.

Pruebe el emulador ARM OpenGL ES 2.0 , yo mismo no he logrado hacer que OpenGL ES 2.0 funcione, pero 1.1 parece funcionar bien (demostración simple de App). Según tengo entendido, se supone que es acelerado por hardware ya que el emulador usa GLbibliotecas de plataforma y mesa3d es (aunque no estoy seguro) acelerado.

También hay libgles2-mesa, pero desafortunadamente no pude hacerlo funcionar. Las muestras de es2gears / es2tri se bloquean, así como la aplicación simple vinculada a las librerías de mesa.