Come sviluppare le applicazioni OpenGL ES (GLES) 2.0 su Linux?

Question

Mi piacerebbe sviluppare app OpenGL ES 2.0 sulla mia macchina Ubuntu. Non sono riuscito a trovare librerie/emulatori che supportino ancora GLES 2.0. Eventuali suggerimenti?

Answer 1

È possibile utilizzare POWERVR SDK per emulare Opengl es sul PC. È possibile scaricare l'SDK here. L'archivio fornisce i passaggi necessari per installare le librerie di emulazione come file di documentazione e include tutorial e applicazioni demo con i codici sorgente.

Answer 2

Sviluppare su OpenGL 2.0 standard e non utilizzare la modalità immediata o la modalità funzione fissa. Essenzialmente il tuo programma sarà compatibile con ES 2.0.

Answer 3

Mesa supports it. Se si desidera limitarsi a OpenGL ES solo, è necessario crearlo in una directory separata e quindi aggiungere le directory di inclusione e libreria appropriate.

Answer 4

è possibile generare un'intestazione con solo le funzioni di cui si ha realmente bisogno. E con glfw puoi creare un contesto opengl es. Quindi non puoi usare accidentalmente funzioni che non vuoi usare, perché non saranno definite in questo modo. Ho trovato questo che potrebbe aiutarti qui.

gl load from the unofficial opengl sdk

Answer 5

GLFW, Mesa, Ubuntu 16.04 AMD64

questo non era facile da installare su Ubuntu 14.04, ma ora funziona solo.

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

uscita:

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 linee principali linee di codice sono:

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

GLFW_INCLUDE_ES2 è d ocumented a: http://www.glfw.org/docs/latest/build_guide.html#build_macros e un rapido sguardo alla fonte dimostra 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 scritto nel sottoinsieme comune di GLES e OpenGL (come gran parte GLES), e anche compila con -lGL se rimuoviamo lo #define GLFW_INCLUDE_ES2.

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

Consulta anche: https://askubuntu.com/questions/244133/how-do-i-get-egl-and-opengles-libraries-for-ubuntu-running-on-virtualbox

Credits: genpfult reso il codice molto più corretto.

ARM Mali OpenGL ES SDK

• scaricare da: http://malideveloper.arm.com/resources/sdks/opengl-es-sdk-for-linux/
• aprire il codice HTML di documentazione su un browser
• seguire la "Guida rapida", è semplice

Contiene diversi esempi open source interessanti + boilerplate system window (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 "OpenGL ES Emulator" http://malideveloper.arm.com/resources/tools/opengl-es-emulator/ che "esegue il mapping delle API API OpenGL ES 3.2 all'API OpenGL". Ma questo non viene fornito con la fonte, ma solo precompilato.

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

Testato su SDK v2.4.4.