Use Newer GLES Compatibility Layer

.gitmodules

@@ -18,3 +18,6 @@
 	path = dependencies/qemu/src
 	url = https://gitlab.com/qemu-project/qemu.git
 	ignore = dirty
+[submodule "media-layer/core/gles/dependencies/gles-compatibility-layer"]
+	path = media-layer/core/gles/dependencies/gles-compatibility-layer
+	url = https://gitea.thebrokenrail.com/minecraft-pi-reborn/gles-compatibility-layer.git

media-layer/core/gles/CMakeLists.txt

@@ -3,30 +3,24 @@ project(media-layer-gles)
 # Build
 if(MCPI_HEADLESS_MODE)
     # Stubs For Headless Mode
-    set(GLES_SRC src/stubs.c)
+    add_library(GLESv1_CM OBJECT src/stubs.c)
+    target_link_libraries(GLESv1_CM PRIVATE media-layer-headers)
 elseif(MCPI_USE_GLES1_COMPATIBILITY_LAYER)
     # GLESv1_CM Compatibility Layer
-    set(GLES_SRC src/compatibility-layer/state.c src/compatibility-layer/passthrough.c src/compatibility-layer/matrix.c src/compatibility-layer/draw.c)
+    set(GLES_COMPATIBILITY_LAYER_USE_SDL FALSE)
+    set(GLES_COMPATIBILITY_LAYER_DEPENDENCY glfw)
+    add_subdirectory(dependencies/gles-compatibility-layer)
+    add_library(GLESv1_CM ALIAS gles-compatibility-layer)
 else()
     # Passthrough To glfwGetProcAddress()
-    set(GLES_SRC src/passthrough.c)
+    add_library(GLESv1_CM OBJECT src/passthrough.c)
-endif()
+    target_link_libraries(GLESv1_CM PRIVATE glfw media-layer-headers)
-add_library(GLESv1_CM OBJECT ${GLES_SRC})
-if(NOT MCPI_HEADLESS_MODE)
-    target_link_libraries(GLESv1_CM PRIVATE glfw PUBLIC reborn-util PRIVATE dl PRIVATE m)
-    # Shaders
-    if(MCPI_USE_GLES1_COMPATIBILITY_LAYER)
-        embed_resource(GLESv1_CM src/compatibility-layer/shaders/main.vsh)
-        embed_resource(GLESv1_CM src/compatibility-layer/shaders/main.fsh)
-    endif()
 endif()
 
-# Common
-target_link_libraries(GLESv1_CM PUBLIC media-layer-headers)
-set_target_properties(GLESv1_CM PROPERTIES SOVERSION "1")
-# Install
-install(TARGETS GLESv1_CM DESTINATION "${MCPI_LIB_DIR}")
 # SDK
 if(BUILD_ARM_COMPONENTS)
     install(TARGETS GLESv1_CM EXPORT sdk DESTINATION "${MCPI_SDK_LIB_DIR}")
+    if(MCPI_USE_GLES1_COMPATIBILITY_LAYER)
+        install(TARGETS gles-compatibility-layer EXPORT sdk DESTINATION "${MCPI_SDK_LIB_DIR}")
+    endif()
 endif()

media-layer/core/gles/dependencies/gles-compatibility-layer

@@ -0,0 +1 @@
+Subproject commit 38d17dd0801f922b1311b822d2243eb528af9725

media-layer/core/gles/src/compatibility-layer/draw.c

@@ -1,204 +0,0 @@
-#include "state.h"
-#include "../passthrough.h"
-
-#include <GLES/gl.h>
-
-#include <libreborn/libreborn.h>
-
-// Shaders
-#define REAL_GL_FRAGMENT_SHADER 0x8b30
-#define REAL_GL_VERTEX_SHADER 0x8b31
-#define REAL_GL_INFO_LOG_LENGTH 0x8b84
-#define REAL_GL_COMPILE_STATUS 0x8b81
-GL_FUNC(glUseProgram, void, (GLuint program));
-GL_FUNC(glGetUniformLocation, GLint, (GLuint program, const GLchar *name));
-GL_FUNC(glUniformMatrix4fv, void, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value));
-GL_FUNC(glUniform1i, void, (GLint location, GLint v0));
-GL_FUNC(glUniform1f, void, (GLint location, GLfloat v0));
-GL_FUNC(glUniform4f, void, (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3));
-GL_FUNC(glGetAttribLocation, GLint, (GLuint program, const GLchar *name));
-GL_FUNC(glEnableVertexAttribArray, void, (GLuint index));
-GL_FUNC(glDisableVertexAttribArray, void, (GLuint index));
-GL_FUNC(glVertexAttribPointer, void, (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer));
-GL_FUNC(glVertexAttrib3f, void, (GLuint index, GLfloat v0, GLfloat v1, GLfloat v2));
-GL_FUNC(glVertexAttrib4f, void, (GLuint index, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3));
-GL_FUNC(glCreateShader, GLuint, (GLenum type));
-GL_FUNC(glShaderSource, void, (GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length));
-GL_FUNC(glCompileShader, void, (GLuint shader));
-GL_FUNC(glCreateProgram, GLuint, ());
-GL_FUNC(glAttachShader, void, (GLuint program, GLuint shader));
-GL_FUNC(glLinkProgram, void, (GLuint program));
-GL_FUNC(glGetShaderiv, void, (GLuint shader, GLenum pname, GLint *params));
-GL_FUNC(glGetShaderInfoLog, void, (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog));
-
-// Compile Shader
-static void log_shader(GLuint shader, const char *name) {
-    // Log
-    GLint log_length = 0;
-    real_glGetShaderiv()(shader, REAL_GL_INFO_LOG_LENGTH, &log_length);
-    GLchar *log = malloc(log_length * sizeof (GLchar));
-    ALLOC_CHECK(log);
-    real_glGetShaderInfoLog()(shader, log_length, &log_length, log);
-    if (log_length > 0) {
-        if (log_length > 1 && log[log_length - 1] == '\n') {
-            log[log_length - 1] = '\0';
-        }
-        DEBUG("%s Shader Compile Log: %s", name, log);
-    }
-    free(log);
-
-    // Check Status
-    GLint is_compiled = 0;
-    real_glGetShaderiv()(shader, REAL_GL_COMPILE_STATUS, &is_compiled);
-    if (!is_compiled) {
-        ERR("Failed To Compile %s Shader", name);
-    }
-}
-static GLuint compile_shader(const char *vertex_shader_text, const int vertex_shader_length, const char *fragment_shader_text, const int fragment_shader_length) {
-    // Vertex Shader
-    const GLuint vertex_shader = real_glCreateShader()(REAL_GL_VERTEX_SHADER);
-    real_glShaderSource()(vertex_shader, 1, &vertex_shader_text, &vertex_shader_length);
-    real_glCompileShader()(vertex_shader);
-    log_shader(vertex_shader, "Vertex");
-
-    // Fragment Shader
-    const GLuint fragment_shader = real_glCreateShader()(REAL_GL_FRAGMENT_SHADER);
-    real_glShaderSource()(fragment_shader, 1, &fragment_shader_text, &fragment_shader_length);
-    real_glCompileShader()(fragment_shader);
-    log_shader(fragment_shader, "Fragment");
-
-    // Link
-    GLuint program = real_glCreateProgram()();
-    real_glAttachShader()(program, vertex_shader);
-    real_glAttachShader()(program, fragment_shader);
-    real_glLinkProgram()(program);
-
-    // Return
-    return program;
-}
-
-// Shader
-extern unsigned char main_vsh[];
-extern size_t main_vsh_len;
-extern unsigned char main_fsh[];
-extern size_t main_fsh_len;
-static GLuint get_shader() {
-    static GLuint program = 0;
-    if (program == 0) {
-        program = compile_shader((const char *) main_vsh, main_vsh_len, (const char *) main_fsh, main_fsh_len);
-    }
-    return program;
-}
-
-// Shader Switching
-static void use_shader(GLuint program) {
-    static GLuint current_program = 0;
-    if (current_program != program) {
-        real_glUseProgram()(program);
-        current_program = program;
-    }
-}
-
-// Array Pointer Drawing
-GL_FUNC(glDrawArrays, void, (GLenum mode, GLint first, GLsizei count));
-#define lazy_uniform(name) \
-    static GLint name##_handle = -1; \
-    if (name##_handle == -1) { \
-        name##_handle = real_glGetUniformLocation()(program, #name); \
-    }
-void glDrawArrays(GLenum mode, GLint first, GLsizei count) {
-    // Verify
-    if (gl_state.array_pointers.vertex.size != 3 || !gl_state.array_pointers.vertex.enabled || gl_state.array_pointers.vertex.type != GL_FLOAT) {
-        ERR("Unsupported Vertex Conifguration");
-    }
-
-    // Check Mode
-    int use_color_pointer = gl_state.array_pointers.color.enabled;
-    if (use_color_pointer && (gl_state.array_pointers.color.size != 4 || gl_state.array_pointers.color.type != GL_UNSIGNED_BYTE)) {
-        ERR("Unsupported Color Conifguration");
-    }
-    int use_texture = gl_state.texture_2d && gl_state.array_pointers.tex_coord.enabled;
-    if (use_texture && (gl_state.array_pointers.tex_coord.size != 2 || gl_state.array_pointers.tex_coord.type != GL_FLOAT)) {
-        ERR("Unsupported Texture Conifguration");
-    }
-
-    // Load Shader
-    GLuint program = get_shader();
-    use_shader(program);
-
-    // Projection Matrix
-    lazy_uniform(u_projection);
-    matrix_t *p = &gl_state.matrix_stacks.projection.stack[gl_state.matrix_stacks.projection.i];
-    real_glUniformMatrix4fv()(u_projection_handle, 1, 0, (GLfloat *) &p->data[0][0]);
-
-    // Model View Matrix
-    lazy_uniform(u_model_view);
-    p = &gl_state.matrix_stacks.model_view.stack[gl_state.matrix_stacks.model_view.i];
-    real_glUniformMatrix4fv()(u_model_view_handle, 1, 0, (GLfloat *) &p->data[0][0]);
-
-    // Has Texture
-    lazy_uniform(u_has_texture); \
-    real_glUniform1i()(u_has_texture_handle, use_texture); \
-
-    // Texture Matrix
-    lazy_uniform(u_texture);
-    p = &gl_state.matrix_stacks.texture.stack[gl_state.matrix_stacks.texture.i];
-    real_glUniformMatrix4fv()(u_texture_handle, 1, 0, (GLfloat *) &p->data[0][0]);
-
-    // Texture Unit
-    lazy_uniform(u_texture_unit);
-    real_glUniform1i()(u_texture_unit_handle, 0);
-
-    // Alpha Test
-    lazy_uniform(u_alpha_test);
-    real_glUniform1i()(u_alpha_test_handle, gl_state.alpha_test);
-
-    // Color
-    GLint a_color_handle = real_glGetAttribLocation()(program, "a_color");
-    if (use_color_pointer) {
-        real_glVertexAttribPointer()(a_color_handle, gl_state.array_pointers.color.size, gl_state.array_pointers.color.type, 1, gl_state.array_pointers.color.stride, gl_state.array_pointers.color.pointer);
-        real_glEnableVertexAttribArray()(a_color_handle);
-    } else {
-        real_glVertexAttrib4f()(a_color_handle, gl_state.color.red, gl_state.color.green, gl_state.color.blue, gl_state.color.alpha);
-    }
-
-    // Fog
-    lazy_uniform(u_fog);
-    real_glUniform1i()(u_fog_handle, gl_state.fog.enabled);
-    if (gl_state.fog.enabled) {
-        lazy_uniform(u_fog_color);
-        real_glUniform4f()(u_fog_color_handle, gl_state.fog.color[0], gl_state.fog.color[1], gl_state.fog.color[2], gl_state.fog.color[3]);
-        lazy_uniform(u_fog_is_linear);
-        real_glUniform1i()(u_fog_is_linear_handle, gl_state.fog.mode == GL_LINEAR);
-        lazy_uniform(u_fog_start);
-        real_glUniform1f()(u_fog_start_handle, gl_state.fog.start);
-        lazy_uniform(u_fog_end);
-        real_glUniform1f()(u_fog_end_handle, gl_state.fog.end);
-    }
-
-    // Vertices
-    GLint a_vertex_coords_handle = real_glGetAttribLocation()(program, "a_vertex_coords");
-    real_glVertexAttribPointer()(a_vertex_coords_handle, gl_state.array_pointers.vertex.size, gl_state.array_pointers.vertex.type, 0, gl_state.array_pointers.vertex.stride, gl_state.array_pointers.vertex.pointer);
-    real_glEnableVertexAttribArray()(a_vertex_coords_handle);
-
-    // Texture Coordinates
-    GLint a_texture_coords_handle = real_glGetAttribLocation()(program, "a_texture_coords");
-    if (use_texture) {
-        real_glVertexAttribPointer()(a_texture_coords_handle, gl_state.array_pointers.tex_coord.size, gl_state.array_pointers.tex_coord.type, 0, gl_state.array_pointers.tex_coord.stride, gl_state.array_pointers.tex_coord.pointer);
-        real_glEnableVertexAttribArray()(a_texture_coords_handle);
-    } else {
-        real_glVertexAttrib3f()(a_texture_coords_handle, 0, 0, 0);
-    }
-
-    // Draw
-    real_glDrawArrays()(mode, first, count);
-
-    // Cleanup
-    if (use_color_pointer) {
-        real_glDisableVertexAttribArray()(a_color_handle);
-    }
-    real_glDisableVertexAttribArray()(a_vertex_coords_handle);
-    if (use_texture) {
-        real_glDisableVertexAttribArray()(a_texture_coords_handle);
-    }
-}

media-layer/core/gles/src/compatibility-layer/matrix.c

@@ -1,131 +0,0 @@
-#include <math.h>
-#include <string.h>
-
-#include <libreborn/libreborn.h>
-
-#include "state.h"
-
-// Matrix Common
-static void matrix_copy(matrix_t *src, matrix_t *dst) {
-    memcpy((void *) dst->data, (void *) src->data, MATRIX_DATA_SIZE);
-}
-
-// Identity Matrix
-static matrix_t identity_matrix = {
-    .data = {
-        {1, 0, 0, 0},
-        {0, 1, 0, 0},
-        {0, 0, 1, 0},
-        {0, 0, 0, 1}
-    }
-};
-static void init_matrix_stack(matrix_stack_t *stack) {
-    matrix_copy(&identity_matrix, &stack->stack[0]);
-}
-__attribute__((constructor)) static void init_matrix_stacks() {
-    init_matrix_stack(&gl_state.matrix_stacks.model_view);
-    init_matrix_stack(&gl_state.matrix_stacks.projection);
-    init_matrix_stack(&gl_state.matrix_stacks.texture);
-}
-
-// Matrix Mode
-static matrix_stack_t *get_matrix_stack() {
-    switch (gl_state.matrix_stacks.mode) {
-        case GL_MODELVIEW: {
-            return &gl_state.matrix_stacks.model_view;
-        }
-        case GL_PROJECTION: {
-            return &gl_state.matrix_stacks.projection;
-        }
-        case GL_TEXTURE: {
-            return &gl_state.matrix_stacks.texture;
-        }
-        default: {
-            ERR("Unsupported Matrix Mode: %i", gl_state.matrix_stacks.mode);
-        }
-    }
-}
-
-// Matrix Functions
-void glMatrixMode(GLenum mode) {
-    gl_state.matrix_stacks.mode = mode;
-}
-void glPopMatrix() {
-    get_matrix_stack()->i--;
-}
-void glLoadIdentity() {
-    matrix_stack_t *stack = get_matrix_stack();
-    matrix_copy(&identity_matrix, &stack->stack[stack->i]);
-}
-void glPushMatrix() {
-    matrix_stack_t *stack = get_matrix_stack();
-    matrix_copy(&stack->stack[stack->i], &stack->stack[stack->i + 1]);
-    stack->i++;
-}
-void glMultMatrixf(const GLfloat *m) {
-    matrix_t new_matrix;
-    matrix_stack_t *stack = get_matrix_stack();
-    matrix_t *current_matrix = &stack->stack[stack->i];
-    for (int x = 0; x < MATRIX_SIZE; x++) {
-        for (int y = 0; y < MATRIX_SIZE; y++) {
-            GLfloat result = 0;
-            for (int i = 0; i < MATRIX_SIZE; i++) {
-                result += (current_matrix->data[i][y] * m[(x * MATRIX_SIZE) + i]);
-            }
-            new_matrix.data[x][y] = result;
-        }
-    }
-    matrix_copy(&new_matrix, current_matrix);
-}
-void glScalef(GLfloat x, GLfloat y, GLfloat z) {
-    GLfloat m[] = {
-        x, 0, 0, 0,
-        0, y, 0, 0,
-        0, 0, z, 0,
-        0, 0, 0, 1
-    };
-    glMultMatrixf(m);
-}
-void glTranslatef(GLfloat x, GLfloat y, GLfloat z) {
-    GLfloat m[] = {
-        1, 0, 0, 0,
-        0, 1, 0, 0,
-        0, 0, 1, 0,
-        x, y, z, 1
-    };
-    glMultMatrixf(m);
-}
-void glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat near, GLfloat far) {
-    GLfloat m[] = {
-        (2.f / (right - left)), 0, 0, 0,
-        0, (2.f / (top - bottom)), 0, 0,
-        0, 0, (-2.f / (far - near)), 0,
-        -((right + left) / (right - left)), -((top + bottom) / (top - bottom)), -((far + near) / (far - near)), 1
-    };
-    glMultMatrixf(m);
-}
-#define DEG2RAD (M_PI / 180.f)
-void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
-    // Normalize
-    GLfloat length = sqrtf((x * x) + (y * y) + (z * z));
-    x /= length;
-    y /= length;
-    z /= length;
-
-    // Values
-    GLfloat angle_radians = angle * DEG2RAD;
-    GLfloat c = cosf(angle_radians);
-    GLfloat s = sinf(angle_radians);
-    GLfloat x2 = x * x;
-    GLfloat y2 = y * y;
-    GLfloat z2 = z * z;
-
-    // Multiply
-    GLfloat m[] = {
-        x2 * (1.f - c) + c, (x * y) * (1.f - c) + (z * s), (x * z) * (1.f - c) - (y * s), 0,
-        (x * y) * (1.f - c) - (z * s), y2 * (1.f - c) + c, (y * z) * (1.f - c) + (x * s), 0,
-        (x * z) * (1.f - c) + (y * s), (y * z) * (1.f - c) - (x * s), z2 * (1.f - c) + c, 0,
-        0, 0, 0, 1.f
-    };
-    glMultMatrixf(m);
-}

media-layer/core/gles/src/compatibility-layer/matrix.h

@@ -1,9 +0,0 @@
-#include <GLES/gl.h>
-
-// Matrix Common
-#define MATRIX_SIZE 4
-#define MATRIX_DATA_SIZE (sizeof (GLfloat) * MATRIX_SIZE * MATRIX_SIZE)
-// OpenGL Matrices Are Column-Major
-typedef struct {
-    GLfloat data[MATRIX_SIZE][MATRIX_SIZE];
-} matrix_t;

media-layer/core/gles/src/compatibility-layer/passthrough.c

@@ -1,117 +0,0 @@
-#include <GLES/gl.h>
-
-#include "../passthrough.h"
-
-// Simple v1.1 -> v2.0 Passthrough Functions
-GL_FUNC(glLineWidth, void, (GLfloat width));
-void glLineWidth(GLfloat width) {
-    real_glLineWidth()(width);
-}
-GL_FUNC(glBlendFunc, void, (GLenum sfactor, GLenum dfactor));
-void glBlendFunc(GLenum sfactor, GLenum dfactor) {
-    real_glBlendFunc()(sfactor, dfactor);
-}
-GL_FUNC(glClear, void, (GLbitfield mask));
-void glClear(GLbitfield mask) {
-    real_glClear()(mask);
-}
-GL_FUNC(glBufferData, void, (GLenum target, GLsizeiptr size, const void *data, GLenum usage));
-void glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage) {
-    real_glBufferData()(target, size, data, usage);
-}
-GL_FUNC(glScissor, void, (GLint x, GLint y, GLsizei width, GLsizei height));
-void glScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
-    real_glScissor()(x, y, width, height);
-}
-GL_FUNC(glTexParameteri, void, (GLenum target, GLenum pname, GLint param));
-void glTexParameteri(GLenum target, GLenum pname, GLint param) {
-    real_glTexParameteri()(target, pname, param);
-}
-GL_FUNC(glTexImage2D, void, (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels));
-void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) {
-    real_glTexImage2D()(target, level, internalformat, width, height, border, format, type, pixels);
-}
-GL_FUNC(glPolygonOffset, void, (GLfloat factor, GLfloat units));
-void glPolygonOffset(GLfloat factor, GLfloat units) {
-    real_glPolygonOffset()(factor, units);
-}
-GL_FUNC(glDepthRangef, void, (GLclampf near, GLclampf far));
-void glDepthRangef(GLclampf near, GLclampf far) {
-    real_glDepthRangef()(near, far);
-}
-GL_FUNC(glBindBuffer, void, (GLenum target, GLuint buffer));
-void glBindBuffer(GLenum target, GLuint buffer) {
-    real_glBindBuffer()(target, buffer);
-}
-GL_FUNC(glDepthFunc, void, (GLenum func));
-void glDepthFunc(GLenum func) {
-    real_glDepthFunc()(func);
-}
-GL_FUNC(glClearColor, void, (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha));
-void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
-    real_glClearColor()(red, green, blue, alpha);
-}
-GL_FUNC(glDepthMask, void, (GLboolean flag));
-void glDepthMask(GLboolean flag) {
-    real_glDepthMask()(flag);
-}
-GL_FUNC(glHint, void, (GLenum target, GLenum mode));
-void glHint(GLenum target, GLenum mode) {
-    if (target != GL_PERSPECTIVE_CORRECTION_HINT) {
-        real_glHint()(target, mode);
-    }
-}
-GL_FUNC(glDeleteBuffers, void, (GLsizei n, const GLuint *buffers));
-void glDeleteBuffers(GLsizei n, const GLuint *buffers) {
-    real_glDeleteBuffers()(n, buffers);
-}
-GL_FUNC(glColorMask, void, (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha));
-void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
-    real_glColorMask()(red, green, blue, alpha);
-}
-GL_FUNC(glTexSubImage2D, void, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels));
-void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) {
-    real_glTexSubImage2D()(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-GL_FUNC(glGenTextures, void, (GLsizei n, GLuint *textures));
-void glGenTextures(GLsizei n, GLuint *textures) {
-    real_glGenTextures()(n, textures);
-}
-GL_FUNC(glDeleteTextures, void, (GLsizei n, const GLuint *textures));
-void glDeleteTextures(GLsizei n, const GLuint *textures) {
-    real_glDeleteTextures()(n, textures);
-}
-GL_FUNC(glBindTexture, void, (GLenum target, GLuint texture));
-void glBindTexture(GLenum target, GLuint texture) {
-    real_glBindTexture()(target, texture);
-}
-GL_FUNC(glCullFace, void, (GLenum mode));
-void glCullFace(GLenum mode) {
-    real_glCullFace()(mode);
-}
-GL_FUNC(glViewport, void, (GLint x, GLint y, GLsizei width, GLsizei height));
-void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
-    real_glViewport()(x, y, width, height);
-}
-GL_FUNC(glIsEnabled, GLboolean, (GLenum cap));
-GLboolean glIsEnabled(GLenum cap) {
-    return real_glIsEnabled()(cap);
-}
-GL_FUNC(glGetIntegerv, void, (GLenum pname, GLint *data));
-void glGetIntegerv(GLenum pname, GLint *data) {
-    real_glGetIntegerv()(pname, data);
-}
-GL_FUNC(glReadPixels, void, (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *data));
-void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *data) {
-    real_glReadPixels()(x, y, width, height, format, type, data);
-}
-void glShadeModel(__attribute__((unused)) GLenum mode) {
-    // Do Nothing
-}
-void glNormal3f(__attribute__((unused)) GLfloat nx, __attribute__((unused)) GLfloat ny, __attribute__((unused)) GLfloat nz) {
-    // Do Nothing
-}
-GL_FUNC(glGenBuffers, void, (GLsizei n, GLuint *buffers));
-void glGenBuffers(GLsizei n, GLuint *buffers) {
-    real_glGenBuffers()(n, buffers);
-}

media-layer/core/gles/src/compatibility-layer/shaders/main.fsh

@@ -1,40 +0,0 @@
-#version 100
-precision highp float;
-// Texture
-uniform bool u_has_texture;
-uniform sampler2D u_texture_unit;
-// Color
-varying vec4 v_color;
-varying vec4 v_texture_pos;
-// Alpha Test
-uniform bool u_alpha_test;
-// Fog
-uniform bool u_fog;
-uniform vec4 u_fog_color;
-uniform bool u_fog_is_linear;
-uniform float u_fog_start;
-uniform float u_fog_end;
-varying vec4 v_fog_eye_position;
-// Main
-void main(void) {
-    gl_FragColor = v_color;
-    // Texture
-    if (u_has_texture) {
-        gl_FragColor *= texture2D(u_texture_unit, v_texture_pos.xy);
-    }
-    // Fog
-    if (u_fog) {
-        float fog_factor;
-        if (u_fog_is_linear) {
-            fog_factor = (u_fog_end - length(v_fog_eye_position)) / (u_fog_end - u_fog_start);
-        } else {
-            fog_factor = exp(-u_fog_start * length(v_fog_eye_position));
-        }
-        fog_factor = clamp(fog_factor, 0.0, 1.0);
-        gl_FragColor.rgb = mix(gl_FragColor, u_fog_color, 1.0 - fog_factor).rgb;
-    }
-    // Alpha Test
-    if (u_alpha_test && gl_FragColor.a <= 0.1) {
-        discard;
-    }
-}

media-layer/core/gles/src/compatibility-layer/shaders/main.vsh

@@ -1,22 +0,0 @@
-#version 100
-precision highp float;
-// Matrices
-uniform mat4 u_projection;
-uniform mat4 u_model_view;
-uniform mat4 u_texture;
-// Texture
-attribute vec3 a_vertex_coords;
-attribute vec2 a_texture_coords;
-varying vec4 v_texture_pos;
-// Color
-attribute vec4 a_color;
-varying vec4 v_color;
-// Fog
-varying vec4 v_fog_eye_position;
-// Main
-void main(void) {
-    v_texture_pos = u_texture * vec4(a_texture_coords.xy, 0.0, 1.0);
-    gl_Position = u_projection * u_model_view * vec4(a_vertex_coords.xyz, 1.0);
-    v_color = a_color;
-    v_fog_eye_position = u_model_view * vec4(a_vertex_coords.xyz, 1.0);
-}

media-layer/core/gles/src/compatibility-layer/state.c

@@ -1,178 +0,0 @@
-#include <libreborn/libreborn.h>
-
-#include "state.h"
-#include "../passthrough.h"
-
-// GL State
-gl_state_t gl_state = {
-    .color = {
-        .red = 1,
-        .green = 1,
-        .blue = 1,
-        .alpha = 1
-    },
-    .matrix_stacks = {
-        .mode = GL_MODELVIEW
-    },
-    .alpha_test = 0,
-    .texture_2d = 0,
-    .fog = {
-        .enabled = 0,
-        .mode = GL_LINEAR,
-        .color = {0, 0, 0, 0},
-        .start = 0,
-        .end = 1
-    }
-};
-
-// Change Color
-void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
-    gl_state.color.red = red;
-    gl_state.color.green = green;
-    gl_state.color.blue = blue;
-    gl_state.color.alpha = alpha;
-}
-
-// Array Pointer Storage
-#define ARRAY_POINTER_FUNC(func, name) \
-    void func(GLint size, GLenum type, GLsizei stride, const void *pointer) { \
-        gl_state.array_pointers.name.size = size; \
-        gl_state.array_pointers.name.type = type; \
-        gl_state.array_pointers.name.stride = stride; \
-        gl_state.array_pointers.name.pointer = pointer; \
-    }
-ARRAY_POINTER_FUNC(glVertexPointer, vertex)
-ARRAY_POINTER_FUNC(glColorPointer, color)
-ARRAY_POINTER_FUNC(glTexCoordPointer, tex_coord)
-static array_pointer_t *get_array_pointer(GLenum array) {
-    switch (array) {
-        case GL_VERTEX_ARRAY: {
-            return &gl_state.array_pointers.vertex;
-        }
-        case GL_COLOR_ARRAY: {
-            return &gl_state.array_pointers.color;
-        }
-        case GL_TEXTURE_COORD_ARRAY: {
-            return &gl_state.array_pointers.tex_coord;
-        }
-        default: {
-            ERR("Unsupported Array Pointer: %i", array);
-        }
-    }
-}
-void glEnableClientState(GLenum array) {
-    get_array_pointer(array)->enabled = 1;
-}
-void glDisableClientState(GLenum array) {
-    get_array_pointer(array)->enabled = 0;
-}
-
-// Enable/Disable State
-GL_FUNC(glEnable, void, (GLenum cap));
-void glEnable(GLenum cap) {
-    switch (cap) {
-        case GL_ALPHA_TEST: {
-            gl_state.alpha_test = 1;
-            break;
-        }
-        case GL_TEXTURE_2D: {
-            gl_state.texture_2d = 1;
-            break;
-        }
-        case GL_COLOR_MATERIAL: {
-            // Ignore
-            break;
-        }
-        case GL_FOG: {
-            gl_state.fog.enabled = 1;
-            break;
-        }
-        default: {
-            real_glEnable()(cap);
-            break;
-        }
-    }
-}
-GL_FUNC(glDisable, void, (GLenum cap));
-void glDisable(GLenum cap) {
-    switch (cap) {
-        case GL_ALPHA_TEST: {
-            gl_state.alpha_test = 0;
-            break;
-        }
-        case GL_TEXTURE_2D: {
-            gl_state.texture_2d = 0;
-            break;
-        }
-        case GL_COLOR_MATERIAL: {
-            // Ignore
-            break;
-        }
-        case GL_FOG: {
-            gl_state.fog.enabled = 0;
-            break;
-        }
-        default: {
-            real_glDisable()(cap);
-            break;
-        }
-    }
-}
-void glAlphaFunc(GLenum func, GLclampf ref) {
-    if (func != GL_GREATER && ref != 0.1f) {
-        ERR("Unsupported Alpha Function");
-    }
-}
-
-// Fog
-#define UNSUPPORTED_FOG() ERR("Unsupported Fog Configuration")
-void glFogfv(GLenum pname, const GLfloat *params) {
-    if (pname == GL_FOG_COLOR) {
-        memcpy((void *) gl_state.fog.color, params, sizeof (gl_state.fog.color));
-    } else {
-        UNSUPPORTED_FOG();
-    }
-}
-void glFogx(GLenum pname, GLfixed param) {
-    if (pname == GL_FOG_MODE && (param == GL_LINEAR || param == GL_EXP)) {
-        gl_state.fog.mode = param;
-    } else {
-        UNSUPPORTED_FOG();
-    }
-}
-void glFogf(GLenum pname, GLfloat param) {
-    switch (pname) {
-        case GL_FOG_DENSITY:
-        case GL_FOG_START: {
-            gl_state.fog.start = param;
-            break;
-        }
-        case GL_FOG_END: {
-            gl_state.fog.end = param;
-            break;
-        }
-        default: {
-            UNSUPPORTED_FOG();
-            break;
-        }
-    }
-}
-
-// Get Matrix Data
-GL_FUNC(glGetFloatv, void, (GLenum pname, GLfloat *params));
-void glGetFloatv(GLenum pname, GLfloat *params) {
-    switch (pname) {
-        case GL_MODELVIEW_MATRIX: {
-            memcpy((void *) params, gl_state.matrix_stacks.model_view.stack[gl_state.matrix_stacks.model_view.i].data, MATRIX_DATA_SIZE);
-            break;
-        }
-        case GL_PROJECTION_MATRIX: {
-            memcpy((void *) params, gl_state.matrix_stacks.projection.stack[gl_state.matrix_stacks.projection.i].data, MATRIX_DATA_SIZE);
-            break;
-        }
-        default: {
-            real_glGetFloatv()(pname, params);
-            break;
-        }
-    }
-}

media-layer/core/gles/src/compatibility-layer/state.h

@@ -1,50 +0,0 @@
-#include <GLES/gl.h>
-
-#include "matrix.h"
-
-// Matrix Data
-#define MATRIX_STACK_DEPTH 256
-typedef struct {
-    matrix_t stack[MATRIX_STACK_DEPTH];
-    unsigned int i;
-} matrix_stack_t;
-
-// Array Pointer Storage
-typedef struct {
-    GLboolean enabled;
-    GLint size;
-    GLenum type;
-    GLsizei stride;
-    const void *pointer;
-} array_pointer_t;
-
-// GL State
-typedef struct {
-    struct {
-        GLfloat red;
-        GLfloat green;
-        GLfloat blue;
-        GLfloat alpha;
-    } color;
-    struct {
-        GLenum mode;
-        matrix_stack_t model_view;
-        matrix_stack_t projection;
-        matrix_stack_t texture;
-    } matrix_stacks;
-    struct {
-        array_pointer_t vertex;
-        array_pointer_t color;
-        array_pointer_t tex_coord;
-    } array_pointers;
-    GLboolean alpha_test;
-    GLboolean texture_2d;
-    struct {
-        GLboolean enabled;
-        GLfixed mode;
-        GLfloat color[4];
-        GLfloat start;
-        GLfloat end;
-    } fog;
-} gl_state_t;
-extern gl_state_t gl_state;

media-layer/core/gles/src/passthrough.c

@@ -1,6 +1,6 @@
 #include <GLES/gl.h>
 
-#include "passthrough.h"
+#include "../dependencies/gles-compatibility-layer/src/passthrough.h"
 
 GL_FUNC(glFogfv, void, (GLenum pname, const GLfloat *params));
 void glFogfv(GLenum pname, const GLfloat *params) {

media-layer/core/gles/src/passthrough.h

@@ -1,19 +0,0 @@
-#define GLFW_INCLUDE_NONE
-#include <GLFW/glfw3.h>
-
-#include <libreborn/libreborn.h>
-
-// Load GL Function
-#define GL_FUNC(name, return_type, args) \
-    typedef return_type (*real_##name##_t)args; \
-    \
-    static real_##name##_t real_##name() { \
-        static real_##name##_t func = NULL; \
-        if (!func) { \
-            func = (real_##name##_t) glfwGetProcAddress(#name); \
-            if (!func) { \
-                ERR("Error Resolving GL Symbol: " #name ": %s", dlerror()); \
-            } \
-        } \
-        return func; \
-    }

media-layer/core/src/media.c

@@ -577,7 +577,7 @@ void SDL_WM_SetCaption(const char *title, __attribute__((unused)) const char *ic
     // Create OpenGL ES Context
     glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
 #ifdef MCPI_USE_GLES1_COMPATIBILITY_LAYER
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
     glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
 #else
     glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 1);
@@ -614,6 +614,12 @@ void SDL_WM_SetCaption(const char *title, __attribute__((unused)) const char *ic
 
     // Make Window Context Current
     glfwMakeContextCurrent(glfw_window);
+    
+    // Setup Compatibility Layer
+#ifdef MCPI_USE_GLES1_COMPATIBILITY_LAYER
+    extern void init_gles_compatibility_layer();
+    init_gles_compatibility_layer();
+#endif
 
     // Debug
     glGetString_t glGetString = (glGetString_t) glfwGetProcAddress("glGetString");

media-layer/include/GLES

@@ -0,0 +1 @@
+../core/gles/dependencies/gles-compatibility-layer/include/GLES

media-layer/include/GLES/gl.h

@@ -1,114 +0,0 @@
-#pragma once
-
-#include <stdio.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define GL_FALSE 0
-#define GL_ARRAY_BUFFER_BINDING 0x8894
-#define GL_ARRAY_BUFFER 0x8892
-#define GL_TEXTURE_BINDING_2D 0x8069
-#define GL_UNSIGNED_BYTE 0x1401
-#define GL_FLOAT 0x1406
-#define GL_RGB 0x1907
-#define GL_RGBA 0x1908
-#define GL_MODELVIEW_MATRIX 0xba6
-#define GL_PROJECTION_MATRIX 0xba7
-#define GL_VIEWPORT 0xba2
-#define GL_DEPTH_TEST 0xb71
-#define GL_PACK_ALIGNMENT 0xd05
-#define GL_UNPACK_ALIGNMENT 0xcf5
-#define GL_SRC_ALPHA 0x302
-#define GL_ONE_MINUS_SRC_ALPHA 0x303
-#define GL_MODELVIEW 0x1700
-#define GL_PROJECTION 0x1701
-#define GL_TEXTURE 0x1702
-#define GL_VERTEX_ARRAY 0x8074
-#define GL_COLOR_ARRAY 0x8076
-#define GL_TEXTURE_COORD_ARRAY 0x8078
-#define GL_GREATER 0x204
-#define GL_ALPHA_TEST 0xbc0
-#define GL_TEXTURE_2D 0xde1
-#define GL_COLOR_MATERIAL 0xb57
-#define GL_PERSPECTIVE_CORRECTION_HINT 0xc50
-#define GL_FOG 0xb60
-#define GL_LINEAR 0x2601
-#define GL_EXP 0x800
-#define GL_FOG_DENSITY 0xb62
-#define GL_FOG_START 0xb63
-#define GL_FOG_END 0xb64
-#define GL_FOG_MODE 0xb65
-#define GL_FOG_COLOR 0xb66
-#define GL_BLEND 0xbe2
-
-typedef float GLfloat;
-typedef float GLclampf;
-typedef int GLint;
-typedef unsigned char GLboolean;
-typedef int GLsizei;
-typedef unsigned int GLuint;
-typedef ssize_t GLsizeiptr;
-typedef intptr_t GLintptr;
-typedef int32_t GLfixed;
-typedef unsigned int GLbitfield;
-typedef unsigned int GLenum;
-typedef char GLchar;
-
-void glFogfv(GLenum pname, const GLfloat *params);
-void glVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer);
-void glLineWidth(GLfloat width);
-void glBlendFunc(GLenum sfactor, GLenum dfactor);
-void glDrawArrays(GLenum mode, GLint first, GLsizei count);
-void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-void glClear(GLbitfield mask);
-void glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage);
-void glFogx(GLenum pname, GLfixed param);
-void glFogf(GLenum pname, GLfloat param);
-void glMatrixMode(GLenum mode);
-void glColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer);
-void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
-void glTexParameteri(GLenum target, GLenum pname, GLint param);
-void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
-void glEnable(GLenum cap);
-void glEnableClientState(GLenum array);
-void glPolygonOffset(GLfloat factor, GLfloat units);
-void glDisableClientState(GLenum array);
-void glDepthRangef(GLclampf near, GLclampf far);
-void glDepthFunc(GLenum func);
-void glBindBuffer(GLenum target, GLuint buffer);
-void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
-void glPopMatrix();
-void glLoadIdentity();
-void glScalef(GLfloat x, GLfloat y, GLfloat z);
-void glPushMatrix();
-void glDepthMask(GLboolean flag);
-void glHint(GLenum target, GLenum mode);
-void glMultMatrixf(const GLfloat *m);
-void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer);
-void glDeleteBuffers(GLsizei n, const GLuint *buffers);
-void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
-void glGenTextures(GLsizei n, GLuint *textures);
-void glDeleteTextures(GLsizei n, const GLuint *textures);
-void glAlphaFunc(GLenum func, GLclampf ref);
-void glGetFloatv(GLenum pname, GLfloat *params);
-void glBindTexture(GLenum target, GLuint texture);
-void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
-void glShadeModel(GLenum mode);
-void glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat near, GLfloat far);
-void glDisable(GLenum cap);
-void glCullFace(GLenum mode);
-void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
-void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
-GLboolean glIsEnabled(GLenum cap);
-void glGetIntegerv(GLenum pname, GLint *data);
-void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *data);
-void glGenBuffers(GLsizei n, GLuint *buffers);
-
-#ifdef __cplusplus
-}
-#endif