Come posso ottenere le librerie EGL e OpenGLES per Ubuntu in esecuzione su VirtualBox?


15

Ho Ubuntu in esecuzione su VirtualBox. Le aggiunte degli ospiti sono installate e ora il sistema operativo è in grado di accelerare l'hardware. Ho installato la libreria OpenGL.

Ora voglio eseguire app usando egl + opengles1.1 e 2.0. Come li ottengo su Ubuntu?

Sono disponibili librerie open source?

Le librerie devono utilizzare le funzionalità di accelerazione hardware fornite da VirtualBox.


È molto difficile dire esattamente cosa stai chiedendo, puoi essere un po 'più dettagliato?
RolandiXor

Risposte:


9

GLFW, Mesa, Ubuntu 16.04 AMD64

Non l'ho provato all'interno di Virtual Box, ma dovrebbe funzionare indipendentemente dal fatto che Mesa ha un'implementazione software.

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

Produzione:

Fonte:

#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 righe 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 nel sottoinsieme comune di GLES e OpenGL (come gran parte di GLES), e si compila anche -lGLse rimuoviamo il file #define GLFW_INCLUDE_ES2.

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

Vedi anche: /programming/3809236/how-to-develop-opengl-es-gles-2-0-applications-on-linux/39356268#39356268

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

SDK ARM OpenGL ES ARM

Contiene diversi interessanti esempi open source + boilerplate del sistema di 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 l '"Emulatore OpenGL ES" http://malideveloper.arm.com/resources/tools/opengl-es-emulator/ che "associa le chiamate API OpenGL ES 3.2 all'API OpenGL". Ma questo non viene fornito con l'origine, solo precompilato.

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

Testato su SDK v2.4.4.


5

Da quando è stata posta la domanda, è apparso un pacchetto che potrebbe aiutare:

sudo apt-get install libgles2-mesa-dev

5

Puoi cercare pacchetti e contenuti dei pacchetti con apt-cache:

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

L'output dice che OpenGLES è probabilmente nel pacchetto mesa-utils-extra . Mesa 3D ha una pagina di progetto per OpenGLES e vi scrive:

Mesa implementa OpenGL ES 1.1 e OpenGL ES 2.0. Ulteriori informazioni su OpenGL ES sono disponibili all'indirizzo http://www.khronos.org/opengles/ .

EGL è anche integrato in 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

Quindi è necessario installare mesa-utils-extrae probabilmente anche libegl1-mesa.


Grazie mille per la risposta Ma Mesa non utilizza la GPU virtuale VirtualBox per l'accelerazione hardware. Durante l'esecuzione di Mesa su VBox utilizza un rasterizzatore software. Il mio requisito è di utilizzare rigorosamente l'accelerazione 3D della scatola virtuale per le demo di Opengles.
vboxuser,

Quindi forse dovremmo guardare questa / la tua domanda qui: forums.virtualbox.org/…
qbi

1

Prova l' emulatore ARM OpenGL ES 2.0 , io stesso non sono riuscito a far funzionare OpenGL ES 2.0, ma 1.1 sembra funzionare bene (demo di SimpleApp). A quanto ho capito, dovrebbe essere accelerato dall'hardware poiché l'emulatore utilizza le GLlibrerie della piattaforma e mesa3d è (non sicuro però) accelerato.

C'è anche libgles2-mesa- ma sfortunatamente non sono riuscito a farlo funzionare. I campioni es2gears / es2tri si arrestano in modo anomalo e simpleApp è collegata a librerie mesa.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.