Added GLES 3 renderer for testing.

include/SDL_gpu_GLES_3.h

···
+#ifndef _SDL_GPU_GLES_3_H__
+#define _SDL_GPU_GLES_3_H__
+
+#include "SDL_gpu.h"
+#include "SDL_platform.h"
+
+#if !defined(SDL_GPU_DISABLE_GLES) && !defined(SDL_GPU_DISABLE_GLES_3)
+
+#ifdef __IPHONEOS__
+    #include <OpenGLES/ES3/gl.h>
+    #include <OpenGLES/ES3/glext.h>
+#else
+    #include "GLES3/gl3.h"
+    #include "GLES3/gl3ext.h"
+#endif
+
+	#define glVertexAttribI1i glVertexAttrib1f
+	#define glVertexAttribI2i glVertexAttrib2f
+	#define glVertexAttribI3i glVertexAttrib3f
+	#define glVertexAttribI1ui glVertexAttrib1f
+	#define glVertexAttribI2ui glVertexAttrib2f
+	#define glVertexAttribI3ui glVertexAttrib3f
+    #define glMapBuffer glMapBufferOES
+    #define glUnmapBuffer glUnmapBufferOES
+    #define GL_WRITE_ONLY GL_WRITE_ONLY_OES
+#endif
+
+
+
+#define GPU_CONTEXT_DATA ContextData_GLES_3
+#define GPU_IMAGE_DATA ImageData_GLES_3
+#define GPU_TARGET_DATA TargetData_GLES_3
+
+
+#define GPU_DEFAULT_TEXTURED_VERTEX_SHADER_SOURCE \
+"#version 300 es\n\
+precision mediump float;\n\
+precision mediump int;\n\
+\
+in vec2 gpu_Vertex;\n\
+in vec2 gpu_TexCoord;\n\
+in vec4 gpu_Color;\n\
+uniform mat4 gpu_ModelViewProjectionMatrix;\n\
+\
+out vec4 color;\n\
+out vec2 texCoord;\n\
+\
+void main(void)\n\
+{\n\
+	color = gpu_Color;\n\
+	texCoord = vec2(gpu_TexCoord);\n\
+	gl_Position = gpu_ModelViewProjectionMatrix * vec4(gpu_Vertex, 0.0, 1.0);\n\
+}"
+
+// Tier 3 uses shader attributes to send position, texcoord, and color data for each vertex.
+#define GPU_DEFAULT_UNTEXTURED_VERTEX_SHADER_SOURCE \
+"#version 300 es\n\
+precision mediump float;\n\
+precision mediump int;\n\
+\
+in vec2 gpu_Vertex;\n\
+in vec4 gpu_Color;\n\
+uniform mat4 gpu_ModelViewProjectionMatrix;\n\
+\
+out vec4 color;\n\
+\
+void main(void)\n\
+{\n\
+	color = gpu_Color;\n\
+	gl_Position = gpu_ModelViewProjectionMatrix * vec4(gpu_Vertex, 0.0, 1.0);\n\
+}"
+
+
+#define GPU_DEFAULT_TEXTURED_FRAGMENT_SHADER_SOURCE \
+"#version 300 es\n\
+precision mediump float;\n\
+precision mediump int;\n\
+\
+in vec4 color;\n\
+in vec2 texCoord;\n\
+\
+uniform sampler2D tex;\n\
+\
+out vec4 fragColor;\n\
+\
+void main(void)\n\
+{\n\
+    fragColor = texture(tex, texCoord) * color;\n\
+}"
+
+#define GPU_DEFAULT_UNTEXTURED_FRAGMENT_SHADER_SOURCE \
+"#version 300 es\n\
+precision mediump float;\n\
+precision mediump int;\n\
+\
+in vec4 color;\n\
+\
+out vec4 fragColor;\n\
+\
+void main(void)\n\
+{\n\
+    fragColor = color;\n\
+}"
+
+
+
+
+typedef struct ContextData_GLES_3
+{
+	SDL_Color last_color;
+	Uint8 last_use_texturing;
+	unsigned int last_shape;
+	Uint8 last_use_blending;
+	GPU_BlendMode last_blend_mode;
+	GPU_Rect last_viewport;
+	GPU_Camera last_camera;
+	Uint8 last_camera_inverted;
+	
+	GPU_Image* last_image;
+	GPU_Target* last_target;
+	float* blit_buffer;  // Holds sets of 4 vertices, each with interleaved position, tex coords, and colors (e.g. [x0, y0, z0, s0, t0, r0, g0, b0, a0, ...]).
+	unsigned short blit_buffer_num_vertices;
+	unsigned short blit_buffer_max_num_vertices;
+	unsigned short* index_buffer;  // Indexes into the blit buffer so we can use 4 vertices for every 2 triangles (1 quad)
+	unsigned int index_buffer_num_vertices;
+	unsigned int index_buffer_max_num_vertices;
+    
+    // Tier 3 rendering
+    unsigned int blit_VAO;
+    unsigned int blit_VBO[2];  // For double-buffering
+    unsigned int blit_IBO;
+    Uint8 blit_VBO_flop;
+    GPU_ShaderBlock shader_block[2];
+    GPU_ShaderBlock current_shader_block;
+    
+	GPU_AttributeSource shader_attributes[16];
+	unsigned int attribute_VBO[16];
+} ContextData_GLES_3;
+
+typedef struct ImageData_GLES_3
+{
+    int refcount;
+    Uint8 owns_handle;
+	Uint32 handle;
+	Uint32 format;
+} ImageData_GLES_3;
+
+typedef struct TargetData_GLES_3
+{
+    int refcount;
+	Uint32 handle;
+	Uint32 format;
+} TargetData_GLES_3;
+
+
+
+#endif

src/CMakeLists.txt

···
 	renderer_OpenGL_3.c
 	renderer_GLES_1.c
 	renderer_GLES_2.c
+	renderer_GLES_3.c
 )
 
 set(SDL_gpu_HDRS
···
 	../include/SDL_gpu_OpenGL_3.h
 	../include/SDL_gpu_GLES_1.h
 	../include/SDL_gpu_GLES_2.h
+	../include/SDL_gpu_GLES_3.h
 	renderer_GL_common.inl
 	renderer_shapes_GL_common.inl
 )
···
 	../include/SDL_gpu_OpenGL_3.h
 	../include/SDL_gpu_GLES_1.h
 	../include/SDL_gpu_GLES_2.h
+	../include/SDL_gpu_GLES_3.h
 )
 
 # Set the appropriate library name for the version of SDL used

src/SDL_gpu_renderer.c

···
 void GPU_FreeRenderer_GLES_1(GPU_Renderer* renderer);
 GPU_Renderer* GPU_CreateRenderer_GLES_2(GPU_RendererID request);
 void GPU_FreeRenderer_GLES_2(GPU_Renderer* renderer);
+GPU_Renderer* GPU_CreateRenderer_GLES_3(GPU_RendererID request);
+void GPU_FreeRenderer_GLES_3(GPU_Renderer* renderer);
 
 void GPU_RegisterRenderer(GPU_RendererID id, GPU_Renderer* (*create_renderer)(GPU_RendererID request), void (*free_renderer)(GPU_Renderer* renderer))
 {
···
         GPU_RegisterRenderer(GPU_MakeRendererID("OpenGLES 2", GPU_RENDERER_GLES_2, 2, 0),
                              &GPU_CreateRenderer_GLES_2,
                              &GPU_FreeRenderer_GLES_2);
+        #endif
+        #ifndef SDL_GPU_DISABLE_GLES_3
+        GPU_RegisterRenderer(GPU_MakeRendererID("OpenGLES 3", GPU_RENDERER_GLES_3, 3, 0),
+                             &GPU_CreateRenderer_GLES_3,
+                             &GPU_FreeRenderer_GLES_3);
         #endif
     #endif
 	
···
     GPU_RendererID default_order[GPU_RENDERER_ORDER_MAX];
     
     #if defined(__ANDROID__) || defined(__IPHONEOS__)
+        default_order[count++] = GPU_MakeRendererID("OpenGLES 3", GPU_RENDERER_GLES_3, 3, 0);
         default_order[count++] = GPU_MakeRendererID("OpenGLES 2", GPU_RENDERER_GLES_2, 2, 0);
         default_order[count++] = GPU_MakeRendererID("OpenGLES 1", GPU_RENDERER_GLES_1, 1, 1);
     #else

src/renderer_GLES_3.c

···
+#include "SDL_gpu_GLES_3.h"
+#include "SDL_gpu_RendererImpl.h"
+
+
+#if defined(SDL_GPU_DISABLE_GLES) || defined(SDL_GPU_DISABLE_GLES_3)
+
+// Dummy implementations
+GPU_Renderer* GPU_CreateRenderer_GLES_3(GPU_RendererID request) {return NULL;}
+void GPU_FreeRenderer_GLES_3(GPU_Renderer* renderer) {}
+
+#else
+
+
+// Most of the code pulled in from here...
+#define SDL_GPU_USE_GLES
+#define SDL_GPU_GL_TIER 3
+#define SDL_GPU_GLES_MAJOR_VERSION 3
+#define SDL_GPU_GLSL_VERSION 300
+
+#define SDL_GPU_USE_BUFFER_PIPELINE
+#ifdef __IPHONEOS__
+    #define SDL_GPU_USE_BUFFER_RESET
+#endif
+#define SDL_GPU_SKIP_ENABLE_TEXTURE_2D
+#define SDL_GPU_ASSUME_SHADERS
+
+#include "renderer_GL_common.inl"
+#include "renderer_shapes_GL_common.inl"
+
+
+GPU_Renderer* GPU_CreateRenderer_GLES_3(GPU_RendererID request)
+{
+    GPU_Renderer* renderer = (GPU_Renderer*)SDL_malloc(sizeof(GPU_Renderer));
+    if(renderer == NULL)
+        return NULL;
+
+    memset(renderer, 0, sizeof(GPU_Renderer));
+
+    renderer->id = request;
+    renderer->id.renderer = GPU_RENDERER_GLES_3;
+    renderer->shader_language = GPU_LANGUAGE_GLSLES;
+    renderer->shader_version = SDL_GPU_GLSL_VERSION;
+    
+    renderer->current_context_target = NULL;
+    
+    renderer->impl = (GPU_RendererImpl*)SDL_malloc(sizeof(GPU_RendererImpl));
+    memset(renderer->impl, 0, sizeof(GPU_RendererImpl));
+    SET_COMMON_FUNCTIONS(renderer->impl);
+
+    return renderer;
+}
+
+void GPU_FreeRenderer_GLES_3(GPU_Renderer* renderer)
+{
+    if(renderer == NULL)
+        return;
+
+    SDL_free(renderer);
+}
+
+
+#endif

src/renderer_GL_common.inl

···
     
 	GPU_Image* result;
 	GPU_IMAGE_DATA* data;
+	
+	#ifdef SDL_GPU_USE_GLES
+	if(renderer->id.major_version == 3 && renderer->id.minor_version == 0)
+	{
+	    GPU_PushErrorCode("GPU_CreateImageUsingTexture", GPU_ERROR_UNSUPPORTED_FUNCTION, "Renderer %s's runtime version on this device (3.0) does not support this function", renderer->id.name);
+        return NULL;
+	}
+    #endif
 
     flushAndBindTexture(renderer, handle);