Comment obtenir les bibliothèques EGL et OpenGLES pour Ubuntu fonctionnant sur VirtualBox?

J'ai Ubuntu en cours d'exécution sur VirtualBox. Des ajouts d'invités sont installés et maintenant le système d'exploitation est capable d'accélération matérielle. J'ai une bibliothèque OpenGL en place.

Maintenant, je veux exécuter des applications en utilisant egl + opengles1.1 & 2.0. Comment les obtenir sur Ubuntu?

Existe-t-il des bibliothèques open source?

Les bibliothèques doivent utiliser les capacités d'accélération matérielle fournies par VirtualBox.

GLFW, Mesa, Ubuntu 16.04 AMD64

Je ne l'ai pas essayé dans Virtual Box, mais cela devrait fonctionner, car Mesa a une implémentation logicielle.

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

Production:

La source:

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

Les principales lignes de code sont les suivantes:

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

GLFW_INCLUDE_ES2est documenté à: http://www.glfw.org/docs/latest/build_guide.html#build_macros et un rapide coup d'œil à la source montre qu'elle transmet à GLES:

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

Cette source semble être dans le sous-ensemble commun de GLES et OpenGL (comme la plupart de GLES), et se compile également avec -lGLsi nous supprimons le #define GLFW_INCLUDE_ES2.

Si nous ajoutons des choses qui ne sont pas dans GLES comme le rendu immédiat glBegin, le lien échoue comme prévu.

Voir également: /programming/3809236/how-to-develop-opengl-es-gles-2-0-applications-on-linux/39356268#39356268

Crédits: genpfult a rendu le code beaucoup plus correct.

SDK ARM Mali OpenGL ES

• téléchargement depuis: http://malideveloper.arm.com/resources/sdks/opengl-es-sdk-for-linux/
• ouvrir la documentation HTML sur un navigateur
• suivez le "Guide de démarrage rapide", c'est simple

Contient plusieurs exemples open source intéressants + passe-partout du système de fenêtrage (X11 + EGL).

Le système de construction prend en charge la compilation croisée facile pour les SoC ARM / Mali, mais je ne l'ai pas encore testé.

Le composant clé inclus semble être "l'émulateur OpenGL ES" http://malideveloper.arm.com/resources/tools/opengl-es-emulator/ qui "mappe les appels d'API OpenGL ES 3.2 vers l'API OpenGL". Mais cela n'est pas livré avec la source, seulement précompilé.

Utilise un CLUF d'entreprise personnalisé qui semble permissif, mais oui, demandez à votre avocat.

Testé sur SDK v2.4.4.

Depuis que la question a été posée, un package est apparu et pourrait aider:

sudo apt-get install libgles2-mesa-dev

Vous pouvez rechercher des packages et leur contenu avec apt-cache:

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

La sortie indique qu'OpenGLES est probablement dans le paquet mesa-utils-extra . Mesa 3D a une page de projet pour OpenGLES et y écrit:

Mesa implémente OpenGL ES 1.1 et OpenGL ES 2.0. Plus d'informations sur OpenGL ES peuvent être trouvées sur http://www.khronos.org/opengles/ .

EGL est également intégré à 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

Vous devez donc installer mesa-utils-extraet probablement aussi libegl1-mesa.

Essayez l'émulateur ARM OpenGL ES 2.0 , je n'ai pas réussi à faire fonctionner OpenGL ES 2.0, mais la version 1.1 semble fonctionner correctement (démo simpleApp). Si je comprends bien, il est censé être accéléré par le matériel, car l'émulateur utilise les GLbibliothèques de plate-forme et mesa3d est (pas sûr cependant) accéléré.

Il y a aussi libgles2-mesa- mais malheureusement je n'ai pas pu le faire fonctionner. Les échantillons es2gears / es2tri plantent ainsi que simpleApp lié aux librairies mesa.