Como obtenho as bibliotecas EGL e OpenGLES para Ubuntu em execução no VirtualBox?

Eu tenho o Ubuntu rodando no VirtualBox. Adições de convidados estão instaladas e agora o sistema operacional é capaz de acelerar o hardware. Eu tenho a biblioteca OpenGL no lugar.

Agora eu quero executar aplicativos usando o egl + opengles1.1 e 2.0. Como faço para obtê-los no Ubuntu?

Existem bibliotecas de código aberto disponíveis?

As bibliotecas devem usar os recursos de aceleração de hardware fornecidos pelo VirtualBox.

GLFW, Mesa, Ubuntu 16.04 AMD64

Eu não tentei dentro do Virtual Box, mas isso deve funcionar independentemente, pois o Mesa possui uma implementação de software.

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

Resultado:

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

As principais linhas de código são:

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

GLFW_INCLUDE_ES2está documentado em: http://www.glfw.org/docs/latest/build_guide.html#build_macros e uma rápida olhada na fonte mostra que ela encaminha para o GLES:

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

Essa fonte parece estar no subconjunto comum do GLES e OpenGL (como grande parte do GLES) e também compila -lGLse removermos o arquivo #define GLFW_INCLUDE_ES2.

Se adicionarmos coisas que não estão no GLES como renderização imediata glBegin, o link falhará conforme o esperado.

Consulte também: /programming/3809236/how-to-develop-opengl-es-gles-2-0-applications-on-linux/39356268#39356268

Créditos: genpfult tornou o código muito mais correto.

ARM Mali OpenGL ES SDK

• faça o download em: http://malideveloper.arm.com/resources/sdks/opengl-es-sdk-for-linux/
• abra a documentação HTML em um navegador
• siga o "Guia de início rápido", é simples

Contém vários exemplos interessantes de código aberto + clichê do sistema de janelas (X11 + EGL).

O sistema de compilação suporta fácil compilação cruzada para SoCs ARM / Mali, mas ainda não testei isso.

O principal componente incluído parece ser o "OpenGL ES Emulator" http://malideveloper.arm.com/resources/tools/opengl-es-emulator/, que "mapeia as chamadas da API do OpenGL ES 3.2 para a API do OpenGL". Mas isso não é fornecido com a fonte, apenas pré-compilado.

Usa um EULA corporativo personalizado que parece permissivo, mas sim, pergunte ao seu advogado.

Testado no SDK v2.4.4.

Desde que a pergunta foi feita, um pacote apareceu e poderia ajudar:

sudo apt-get install libgles2-mesa-dev

Você pode procurar por pacotes e seu conteúdo com apt-cache:

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

A saída diz que o OpenGLES provavelmente está no pacote mesa-utils-extra . O Mesa 3D tem uma página de projeto para o OpenGLES e escreve lá:

O Mesa implementa o OpenGL ES 1.1 e o OpenGL ES 2.0. Mais informações sobre o OpenGL ES podem ser encontradas em http://www.khronos.org/opengles/ .

O EGL também está embutido no 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

Então você precisa instalar mesa-utils-extrae provavelmente também libegl1-mesa.

Tente o ARM OpenGL ES 2.0 Emulator , eu mesmo não consegui fazer o OpenGL ES 2.0 funcionar, mas o 1.1 parece funcionar bem (demo do simpleApp). Pelo que entendi, ele deveria ser acelerado por hardware, pois o emulador usa a plataformaGL bibliotecas de e o mesa3d é (não tenho certeza).

Há também libgles2-mesa- mas infelizmente eu não consegui fazê-lo funcionar. As amostras es2gears / es2tri falham, bem como o simpleApp vinculado a bibliotecas de mesa.