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

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

Aktualisierung:

Sie können das PowerVR SDK (noch) verwenden und es unterstützt jetzt auch Vulkan. Aktualisierte Links:

• PowerVR SDK-Seite:https://www.imgtec.com/developers/powervr-sdk-tools/powervr-sdk/
• Downloadseite für Installer:https://www.imgtec.com/developers/powervr-sdk-tools/installers/
• Github-Repository:https://github.com/powervr-graphics/Native_SDK

Zum Zeitpunkt meiner ursprünglichen Antwort war PowerVR SDK die umfassendste Lösung (Mesa erhielt laut seiner Wikipedia-Seite mit seiner 3.1-Version volle OpenGL ES 2.0-Unterstützung).

Jetzt können auch Mesa und Mali SDK zur Auswahl stehen. Detaillierte Informationen dazu finden Sie in dieser ausführlichen Antwort von Ciro Santilli 冠状病毒审查六四事件法轮功

Ursprüngliche Antwort:

Sie können POWERVR SDK verwenden, um Opengles auf Ihrem PC zu emulieren. Sie können das SDK hier herunterladen. Das Archiv enthält die notwendigen Schritte zur Installation der Emulationsbibliotheken als Dokumentationsdatei und enthält Tutorials und Demoanwendungen mit Quellcodes.

GLFW, Mesa, Ubuntu 16.04 AMD64

Dies war unter Ubuntu 14.04 nicht einfach einzurichten, aber jetzt funktioniert es einfach.

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

Ausgabe:

glfw_triangle.c

#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 Schlüsselzeilen des Codes sind:

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

GLFW_INCLUDE_ES2 ist dokumentiert unter:http://www.glfw.org/docs/latest/build_guide.html#build_macros und ein kurzer Blick auf die Quelle zeigt, dass sie 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 geschrieben zu sein (wie vieles von GLES) und wird auch mit -lGL kompiliert wenn wir #define GLFW_INCLUDE_ES2 entfernen .

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

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

Credits:genpful hat den Code viel korrekter gemacht.

ARM Mali OpenGL ES SDK

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

Enthält mehrere interessante Open-Source-Beispiele + Boilerplate für Windowing-Systeme (X11 + EGL).

Das Build-System unterstützt eine einfache Cross-Kompilierung für ARM/Mali-SoCs, aber das habe ich 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 auf die OpenGL API abbildet". Aber das wird nicht mit dem Quellcode ausgeliefert, sondern nur vorkompiliert.

Verwendet eine benutzerdefinierte EULA für Unternehmen, die freizügig erscheint, aber ja, fragen Sie Ihren Anwalt.

Getestet auf SDK v2.4.4.