Wie bekomme ich EGL- und OpenGLES-Bibliotheken für Ubuntu auf VirtualBox?

Ich habe Ubuntu auf VirtualBox. Gastzugaben sind installiert und das Betriebssystem ist nun hardwarebeschleunigungsfähig. Ich habe OpenGL-Bibliothek vorhanden.

Jetzt möchte ich Apps mit egl + opengles1.1 & 2.0 ausführen. Wie bekomme ich sie auf Ubuntu?

Gibt es Open-Source-Bibliotheken?

Die Bibliotheken sollten die von VirtualBox bereitgestellten Hardwarebeschleunigungsfunktionen verwenden.

GLFW, Mesa, Ubuntu 16.04 AMD64

Ich habe es nicht in Virtual Box ausprobiert, aber das sollte funktionieren, da Mesa eine Software-Implementierung hat.

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

Ausgabe:

Quelle:

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

Die wichtigsten Codezeilen sind:

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

GLFW_INCLUDE_ES2ist dokumentiert unter: http://www.glfw.org/docs/latest/build_guide.html#build_macros und ein kurzer Blick auf die Quelle zeigt, dass es an GLES weiterleitet:

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

Diese Quelle scheint in der gemeinsamen Teilmenge von GLES und OpenGL zu sein (wie viel von GLES) und kompiliert auch mit, -lGLwenn wir die entfernen #define GLFW_INCLUDE_ES2.

Wenn wir Dinge hinzufügen, die nicht in GLES enthalten sind, wie das sofortige Rendern glBegin, schlägt die Verknüpfung wie erwartet fehl.

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

Credits: genpfult hat den Code viel korrekter gemacht.

ARM Mali OpenGL ES SDK

• Download von: http://malideveloper.arm.com/resources/sdks/opengl-es-sdk-for-linux/
• Öffnen Sie die HTML-Dokumentation in einem Browser
• Folgen Sie der "Schnellstartanleitung", es ist ganz einfach

Enthält mehrere interessante Open Source-Beispiele + Boilerplate des Fenstersystems (X11 + EGL).

Das Build-System unterstützt die einfache Cross-Kompilierung für ARM / Mali-SoCs, aber das habe ich noch nicht getestet.

Die enthaltene Schlüsselkomponente scheint der "OpenGL ES-Emulator" zu sein ( http://malideveloper.arm.com/resources/tools/opengl-es-emulator/), der "OpenGL ES 3.2-API-Aufrufe der OpenGL-API zuordnet". Das wird aber nicht mit Source ausgeliefert, sondern nur vorkompiliert.

Verwendet einen benutzerdefinierten EULA für Unternehmen, der zulässig zu sein scheint, aber fragen Sie Ihren Anwalt.

Getestet mit SDK v2.4.4.

Da die Frage gestellt wurde, erschien ein Paket und konnte helfen:

sudo apt-get install libgles2-mesa-dev

Sie können nach Paketen und Paketinhalten suchen mit apt-cache:

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

Die Ausgabe besagt, dass OpenGLES wahrscheinlich im Paket mesa-utils-extra enthalten ist . Mesa 3D hat eine Projektseite für OpenGLES und schreibt dort:

Mesa implementiert OpenGL ES 1.1 und OpenGL ES 2.0. Weitere Informationen zu OpenGL ES finden Sie unter http://www.khronos.org/opengles/ .

EGL ist auch in Mesa integriert:

> 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

Also musst du mesa-utils-extraund wahrscheinlich auch installieren libegl1-mesa.

Probieren Sie den ARM OpenGL ES 2.0 Emulator aus . Ich selbst habe es nicht geschafft, OpenGL ES 2.0 zum Laufen zu bringen, aber 1.1 scheint gut zu laufen (simpleApp-Demo). Soweit ich weiß, soll es hardwarebeschleunigt sein, da der Emulator Plattformbibliotheken verwendet GLund mesa3d (obwohl nicht sicher) beschleunigt ist.

Es gibt auch libgles2-mesa- aber leider konnte ich es nicht zum Laufen bringen. es2gears / es2tri-Beispiele stürzen ab und simpleApp ist mit Mesa-Bibliotheken verknüpft.