web-dev-qa-db-fra.com

Comment obtenir les bibliothèques EGL et OpenGLES pour Ubuntu s'exécutant sur VirtualBox?

Ubuntu tourne sur VirtualBox. Des ajouts d'invités sont installés et le système d'exploitation est désormais compatible avec l'accélération matérielle. J'ai la bibliothèque OpenGL en place.

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

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

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

graphicsvirtualboxlibrariesopengl
12
vboxuser

GLFW, Mesa, Ubuntu 16.04 AMD64

Je ne l'ai pas essayé dans Virtual Box, mais cela devrait fonctionner quand même puisque Mesa a une implémentation logicielle.

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

Sortie:

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_ES2 est documenté à l'adresse suivante: http://www.glfw.org/docs/latest/build_guide.html#build_macros et un rapide coup d'œil à la source indique qu'elle est transmise à GLES:

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

Cette source semble se trouver dans le sous-ensemble commun de GLES et OpenGL (comme beaucoup de GLES), et se compile également avec -lGL si nous supprimons le #define GLFW_INCLUDE_ES2.

Si nous ajoutons des éléments qui ne figurent pas dans GLES, tels que le rendu immédiat, glBeginname__, la liaison échoue comme prévu.

Voir aussi: https://stackoverflow.com/questions/3809236/how-to-develop-opengl-es-gles-2-0-applications-on-linux/39356268#39356268

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

Kit de développement logiciel (SDK) pour OpenGL ES d'ARM Mali

Contient plusieurs exemples open source intéressants + passe-partout (X11 + EGL).

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

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 à la API OpenGL ". Mais cela n’est pas livré avec la source, mais seulement précompilé.

Utilise un CLUF personnalisé qui semble être permissif, mais oui, demandez à votre avocat.

Testé sur le SDK v2.4.4.

8
Ciro Santilli 新疆改造中心996ICU六四事件

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 package 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 sont disponibles sur le site 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-extra et probablement aussi libegl1-mesa.

5
qbi

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

Sudo apt-get install libgles2-mesa-dev
4
tbruyelle

Essayez émulateur ARM OpenGL ES 2. , je n’ai moi-même pas réussi à faire fonctionner OpenGL ES 2.0, mais la version 1.1 semble fonctionner correctement (démo de simpleApp). Si j'ai bien compris, l'accélération matérielle est supposée s'accélérer, car l'émulateur utilise la bibliothèque GLde la plate-forme et mesa3d est (pas encore sûr) accéléré.

Il existe également libgles2-mesa - mais malheureusement, je ne pouvais pas le faire fonctionner. Les échantillons es2gears/es2tri plantent aussi bien que simpleApp lié à mesa libs.

1
kerim