Wie entwickelt man OpenGL ES (GLES) 2.0 Anwendungen unter Linux?

Question

Ich möchte OpenGL ES 2.0 Apps auf meinem Ubuntu-Rechner entwickeln. Ich konnte keine Bibliotheken/Emulatoren finden, die GLES 2.0 unterstützen. Irgendwelche Vorschläge?

Answer 1

Sie können POWERVR SDK verwenden, um auf Ihrem PC OpenGLs zu emulieren. Sie können das SDK here herunterladen. Das Archiv enthält die notwendigen Schritte, um die Emulationsbibliotheken als Dokumentationsdatei zu installieren, und enthält Lernprogramme und Demoanwendungen mit Quellcodes.

Answer 2

Entwickeln Sie die OpenGL 2.0 standard, und verwenden Sie nicht Sofortmodus oder festen Funktionsmodus. Im Wesentlichen wird Ihr Programm ES 2.0-konform sein.

Answer 3

Mesa supports it. Wenn Sie sich auf OpenGL ES nur beschränken möchten, müssen Sie es in ein separates Verzeichnis erstellen und dann die entsprechenden Include- und Bibliotheksverzeichnisse hinzufügen.

Answer 4

können Sie eine Kopfzeile generieren, die nur die Funktionen enthält, die Sie wirklich benötigen. Und mit GLFW können Sie einen OpenGLs Kontext erstellen. Sie können also nicht versehentlich Funktionen verwenden, die Sie nicht verwenden möchten, weil sie nicht auf diese Weise definiert werden. Ich habe das gefunden, was dir hier helfen könnte.

gl load from the unofficial opengl sdk

Answer 5

GLFW, Mesa, Ubuntu 16.04 AMD64

Dies war die Einrichtung auf Ubuntu nicht einfach 14.04, aber jetzt ist es funktioniert einfach.

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

Output:

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 Hauptleitungscodezeilen sind:

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

GLFW_INCLUDE_ES2 ist d ocumented an: http://www.glfw.org/docs/latest/build_guide.html#build_macros und ein kurzer Blick auf die Quelle zeigt, dass es zu GLES leitet:

#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 geschrieben werden (wie viel von GLES), und erstellt auch mit -lGL wenn wir die #define GLFW_INCLUDE_ES2 entfernen.

Wenn wir Dinge hinzufügen, die nicht in GLES sind wie sofortiges Rendern glBegin, schlägt Verbindung wie erwartet fehl.

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

Credits: genpfult der Code viel mehr richtig gemacht.

ARM Mali OpenGL ES SDK

• Download: http://malideveloper.arm.com/resources/sdks/opengl-es-sdk-for-linux/
• öffnen Sie die Dokumentation HTML-Browser auf die
• die "Quick Start Guide" folgen, dann ist es einfach

Enthält einige interessante Open-Source-Beispiele + Boilerplate (X11 + EGL).

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

Die enthaltene Schlüsselkomponente scheint der "OpenGL ES Emulator" http://malideveloper.arm.com/resources/tools/opengl-es-emulator/ zu sein, der "OpenGL ES 3.2 API-Aufrufe an die OpenGL-API mappt". Aber das wird nicht mit Quelle geliefert, nur vorkompiliert.

Verwendet eine benutzerdefinierte Enterprise EULA, die permissiv erscheint, aber ja, fragen Sie Ihren Anwalt.

Getestet auf SDK v2.4.4.