¿Cómo desarrollar aplicaciones OpenGL ES (GLES) 2.0 en Linux?

Question

Me gustaría desarrollar aplicaciones OpenGL ES 2.0 en mi máquina Ubuntu. No pude encontrar bibliotecas/emuladores que admitan GLES 2.0 todavía. ¿Alguna sugerencia?

Answer 1

Puede usar POWERVR SDK para emular OpenGL en su PC. Puede descargar el SDK here. El archivo proporciona los pasos necesarios para instalar las bibliotecas de emulación como un archivo de documentación e incluye tutoriales y aplicaciones de demostración con códigos fuente.

Answer 2

desarrollarse hasta el OpenGL 2.0 standard, y de no utilizar el modo inmediato o el modo de función fija. Esencialmente, su programa cumplirá con ES 2.0.

Answer 3

Mesa supports it. Si desea restringirse a OpenGL ES solo, deberá compilarlo en un directorio aparte y luego agregar los directorios apropiados de inclusión y biblioteca.

Answer 4

puede generar un encabezado que tiene solo aquellas funciones que realmente necesita. Y con glfw puede crear un contexto abierto. Por lo tanto, no puede utilizar accidentalmente funciones que no desea usar, ya que no se definirán de esta manera. Encontré esto que podría ayudarte aquí.

gl load from the unofficial opengl sdk

Answer 5

GLFW, Mesa, Ubuntu 16.04 AMD64

Esto no era fácil de instalar en Ubuntu 14.04, pero ahora simplemente funciona.

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

Salida:

Fuente:

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

Las líneas principales línea de código son:

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

GLFW_INCLUDE_ES2 es d ocumented en: http://www.glfw.org/docs/latest/build_guide.html#build_macros y un rápido vistazo a la fuente muestra que se envía a GLES:

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

Esta fuente parece estar escrito en el subconjunto común de GLES y OpenGL (como gran parte de GLES), y también compila con -lGL si eliminamos el #define GLFW_INCLUDE_ES2.

Si añadimos cosas que no están en GLES como la prestación inmediata glBegin, de enlace no como se esperaba.

Consulte también: https://askubuntu.com/questions/244133/how-do-i-get-egl-and-opengles-libraries-for-ubuntu-running-on-virtualbox

Créditos: genpfult hizo que el código mucho más correcto.

ARM Mali OpenGL ES SDK

• descarga desde: http://malideveloper.arm.com/resources/sdks/opengl-es-sdk-for-linux/
• abrir la Documentación HTML en un navegador
• siguen la "Guía de inicio rápido", es simple

Contiene varios ejemplos interesantes de código abierto + texto repetitivo del sistema de ventanas (X11 + EGL).

El sistema de compilación admite la compilación cruzada fácil para los SoCs ARM/Mali, pero aún no lo he probado.

El componente clave incluido parece ser el "Emulador de OpenGL ES" http://malideveloper.arm.com/resources/tools/opengl-es-emulator/ que "asigna las llamadas de la API de OpenGL ES 3.2 a la API de OpenGL". Pero eso no se envía con la fuente, solo precompilado.

Utiliza un EULA empresarial personalizado que parece ser permisivo, pero sí, consulte a su abogado.

Probado en SDK v2.4.4.