summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/SDL2/src/render/opengles2/SDL_render_gles2.c
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/SDL2/src/render/opengles2/SDL_render_gles2.c')
-rw-r--r--3rdparty/SDL2/src/render/opengles2/SDL_render_gles2.c2137
1 files changed, 0 insertions, 2137 deletions
diff --git a/3rdparty/SDL2/src/render/opengles2/SDL_render_gles2.c b/3rdparty/SDL2/src/render/opengles2/SDL_render_gles2.c
deleted file mode 100644
index c846a7b395f..00000000000
--- a/3rdparty/SDL2/src/render/opengles2/SDL_render_gles2.c
+++ /dev/null
@@ -1,2137 +0,0 @@
-/*
- Simple DirectMedia Layer
- Copyright (C) 1997-2016 Sam Lantinga <slouken@libsdl.org>
-
- This software is provided 'as-is', without any express or implied
- warranty. In no event will the authors be held liable for any damages
- arising from the use of this software.
-
- Permission is granted to anyone to use this software for any purpose,
- including commercial applications, and to alter it and redistribute it
- freely, subject to the following restrictions:
-
- 1. The origin of this software must not be misrepresented; you must not
- claim that you wrote the original software. If you use this software
- in a product, an acknowledgment in the product documentation would be
- appreciated but is not required.
- 2. Altered source versions must be plainly marked as such, and must not be
- misrepresented as being the original software.
- 3. This notice may not be removed or altered from any source distribution.
-*/
-#include "../../SDL_internal.h"
-
-#if SDL_VIDEO_RENDER_OGL_ES2 && !SDL_RENDER_DISABLED
-
-#include "SDL_hints.h"
-#include "SDL_opengles2.h"
-#include "../SDL_sysrender.h"
-#include "../../video/SDL_blit.h"
-#include "SDL_shaders_gles2.h"
-
-/* !!! FIXME: Emscripten makes these into WebGL calls, and WebGL doesn't offer
- !!! FIXME: client-side arrays (without an Emscripten compatibility hack,
- !!! FIXME: at least), but the current VBO code here is dramatically
- !!! FIXME: slower on actual iOS devices, even though the iOS Simulator
- !!! FIXME: is okay. Some time after 2.0.4 ships, we should revisit this,
- !!! FIXME: fix the performance bottleneck, and make everything use VBOs.
-*/
-#ifdef __EMSCRIPTEN__
-#define SDL_GLES2_USE_VBOS 1
-#else
-#define SDL_GLES2_USE_VBOS 0
-#endif
-
-/* To prevent unnecessary window recreation,
- * these should match the defaults selected in SDL_GL_ResetAttributes
- */
-#define RENDERER_CONTEXT_MAJOR 2
-#define RENDERER_CONTEXT_MINOR 0
-
-/* Used to re-create the window with OpenGL ES capability */
-extern int SDL_RecreateWindow(SDL_Window * window, Uint32 flags);
-
-/*************************************************************************************************
- * Bootstrap data *
- *************************************************************************************************/
-
-static SDL_Renderer *GLES2_CreateRenderer(SDL_Window *window, Uint32 flags);
-
-SDL_RenderDriver GLES2_RenderDriver = {
- GLES2_CreateRenderer,
- {
- "opengles2",
- (SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_TARGETTEXTURE),
- 4,
- {
- SDL_PIXELFORMAT_ARGB8888,
- SDL_PIXELFORMAT_ABGR8888,
- SDL_PIXELFORMAT_RGB888,
- SDL_PIXELFORMAT_BGR888
- },
- 0,
- 0
- }
-};
-
-/*************************************************************************************************
- * Context structures *
- *************************************************************************************************/
-
-typedef struct GLES2_FBOList GLES2_FBOList;
-
-struct GLES2_FBOList
-{
- Uint32 w, h;
- GLuint FBO;
- GLES2_FBOList *next;
-};
-
-typedef struct GLES2_TextureData
-{
- GLenum texture;
- GLenum texture_type;
- GLenum pixel_format;
- GLenum pixel_type;
- void *pixel_data;
- int pitch;
- /* YUV texture support */
- SDL_bool yuv;
- SDL_bool nv12;
- GLenum texture_v;
- GLenum texture_u;
- GLES2_FBOList *fbo;
-} GLES2_TextureData;
-
-typedef struct GLES2_ShaderCacheEntry
-{
- GLuint id;
- GLES2_ShaderType type;
- const GLES2_ShaderInstance *instance;
- int references;
- Uint8 modulation_r, modulation_g, modulation_b, modulation_a;
- struct GLES2_ShaderCacheEntry *prev;
- struct GLES2_ShaderCacheEntry *next;
-} GLES2_ShaderCacheEntry;
-
-typedef struct GLES2_ShaderCache
-{
- int count;
- GLES2_ShaderCacheEntry *head;
-} GLES2_ShaderCache;
-
-typedef struct GLES2_ProgramCacheEntry
-{
- GLuint id;
- SDL_BlendMode blend_mode;
- GLES2_ShaderCacheEntry *vertex_shader;
- GLES2_ShaderCacheEntry *fragment_shader;
- GLuint uniform_locations[16];
- Uint8 color_r, color_g, color_b, color_a;
- Uint8 modulation_r, modulation_g, modulation_b, modulation_a;
- GLfloat projection[4][4];
- struct GLES2_ProgramCacheEntry *prev;
- struct GLES2_ProgramCacheEntry *next;
-} GLES2_ProgramCacheEntry;
-
-typedef struct GLES2_ProgramCache
-{
- int count;
- GLES2_ProgramCacheEntry *head;
- GLES2_ProgramCacheEntry *tail;
-} GLES2_ProgramCache;
-
-typedef enum
-{
- GLES2_ATTRIBUTE_POSITION = 0,
- GLES2_ATTRIBUTE_TEXCOORD = 1,
- GLES2_ATTRIBUTE_ANGLE = 2,
- GLES2_ATTRIBUTE_CENTER = 3,
-} GLES2_Attribute;
-
-typedef enum
-{
- GLES2_UNIFORM_PROJECTION,
- GLES2_UNIFORM_TEXTURE,
- GLES2_UNIFORM_MODULATION,
- GLES2_UNIFORM_COLOR,
- GLES2_UNIFORM_TEXTURE_U,
- GLES2_UNIFORM_TEXTURE_V
-} GLES2_Uniform;
-
-typedef enum
-{
- GLES2_IMAGESOURCE_SOLID,
- GLES2_IMAGESOURCE_TEXTURE_ABGR,
- GLES2_IMAGESOURCE_TEXTURE_ARGB,
- GLES2_IMAGESOURCE_TEXTURE_RGB,
- GLES2_IMAGESOURCE_TEXTURE_BGR,
- GLES2_IMAGESOURCE_TEXTURE_YUV,
- GLES2_IMAGESOURCE_TEXTURE_NV12,
- GLES2_IMAGESOURCE_TEXTURE_NV21
-} GLES2_ImageSource;
-
-typedef struct GLES2_DriverContext
-{
- SDL_GLContext *context;
-
- SDL_bool debug_enabled;
-
- struct {
- int blendMode;
- SDL_bool tex_coords;
- } current;
-
-#define SDL_PROC(ret,func,params) ret (APIENTRY *func) params;
-#include "SDL_gles2funcs.h"
-#undef SDL_PROC
- GLES2_FBOList *framebuffers;
- GLuint window_framebuffer;
-
- int shader_format_count;
- GLenum *shader_formats;
- GLES2_ShaderCache shader_cache;
- GLES2_ProgramCache program_cache;
- GLES2_ProgramCacheEntry *current_program;
- Uint8 clear_r, clear_g, clear_b, clear_a;
-
-#if SDL_GLES2_USE_VBOS
- GLuint vertex_buffers[4];
- GLsizeiptr vertex_buffer_size[4];
-#endif
-} GLES2_DriverContext;
-
-#define GLES2_MAX_CACHED_PROGRAMS 8
-
-
-SDL_FORCE_INLINE const char*
-GL_TranslateError (GLenum error)
-{
-#define GL_ERROR_TRANSLATE(e) case e: return #e;
- switch (error) {
- GL_ERROR_TRANSLATE(GL_INVALID_ENUM)
- GL_ERROR_TRANSLATE(GL_INVALID_VALUE)
- GL_ERROR_TRANSLATE(GL_INVALID_OPERATION)
- GL_ERROR_TRANSLATE(GL_OUT_OF_MEMORY)
- GL_ERROR_TRANSLATE(GL_NO_ERROR)
- default:
- return "UNKNOWN";
-}
-#undef GL_ERROR_TRANSLATE
-}
-
-SDL_FORCE_INLINE void
-GL_ClearErrors(SDL_Renderer *renderer)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *) renderer->driverdata;
-
- if (!data->debug_enabled) {
- return;
- }
- while (data->glGetError() != GL_NO_ERROR) {
- continue;
- }
-}
-
-SDL_FORCE_INLINE int
-GL_CheckAllErrors (const char *prefix, SDL_Renderer *renderer, const char *file, int line, const char *function)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *) renderer->driverdata;
- int ret = 0;
-
- if (!data->debug_enabled) {
- return 0;
- }
- /* check gl errors (can return multiple errors) */
- for (;;) {
- GLenum error = data->glGetError();
- if (error != GL_NO_ERROR) {
- if (prefix == NULL || prefix[0] == '\0') {
- prefix = "generic";
- }
- SDL_SetError("%s: %s (%d): %s %s (0x%X)", prefix, file, line, function, GL_TranslateError(error), error);
- ret = -1;
- } else {
- break;
- }
- }
- return ret;
-}
-
-#if 0
-#define GL_CheckError(prefix, renderer)
-#elif defined(_MSC_VER)
-#define GL_CheckError(prefix, renderer) GL_CheckAllErrors(prefix, renderer, __FILE__, __LINE__, __FUNCTION__)
-#else
-#define GL_CheckError(prefix, renderer) GL_CheckAllErrors(prefix, renderer, __FILE__, __LINE__, __PRETTY_FUNCTION__)
-#endif
-
-
-/*************************************************************************************************
- * Renderer state APIs *
- *************************************************************************************************/
-
-static int GLES2_ActivateRenderer(SDL_Renderer *renderer);
-static void GLES2_WindowEvent(SDL_Renderer * renderer,
- const SDL_WindowEvent *event);
-static int GLES2_UpdateViewport(SDL_Renderer * renderer);
-static void GLES2_DestroyRenderer(SDL_Renderer *renderer);
-static int GLES2_SetOrthographicProjection(SDL_Renderer *renderer);
-
-
-static SDL_GLContext SDL_CurrentContext = NULL;
-
-static int GLES2_LoadFunctions(GLES2_DriverContext * data)
-{
-#if SDL_VIDEO_DRIVER_UIKIT
-#define __SDL_NOGETPROCADDR__
-#elif SDL_VIDEO_DRIVER_ANDROID
-#define __SDL_NOGETPROCADDR__
-#elif SDL_VIDEO_DRIVER_PANDORA
-#define __SDL_NOGETPROCADDR__
-#endif
-
-#if defined __SDL_NOGETPROCADDR__
-#define SDL_PROC(ret,func,params) data->func=func;
-#else
-#define SDL_PROC(ret,func,params) \
- do { \
- data->func = SDL_GL_GetProcAddress(#func); \
- if ( ! data->func ) { \
- return SDL_SetError("Couldn't load GLES2 function %s: %s\n", #func, SDL_GetError()); \
- } \
- } while ( 0 );
-#endif /* __SDL_NOGETPROCADDR__ */
-
-#include "SDL_gles2funcs.h"
-#undef SDL_PROC
- return 0;
-}
-
-GLES2_FBOList *
-GLES2_GetFBO(GLES2_DriverContext *data, Uint32 w, Uint32 h)
-{
- GLES2_FBOList *result = data->framebuffers;
- while ((result) && ((result->w != w) || (result->h != h)) ) {
- result = result->next;
- }
- if (result == NULL) {
- result = SDL_malloc(sizeof(GLES2_FBOList));
- result->w = w;
- result->h = h;
- data->glGenFramebuffers(1, &result->FBO);
- result->next = data->framebuffers;
- data->framebuffers = result;
- }
- return result;
-}
-
-static int
-GLES2_ActivateRenderer(SDL_Renderer * renderer)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
-
- if (SDL_CurrentContext != data->context) {
- /* Null out the current program to ensure we set it again */
- data->current_program = NULL;
-
- if (SDL_GL_MakeCurrent(renderer->window, data->context) < 0) {
- return -1;
- }
- SDL_CurrentContext = data->context;
-
- GLES2_UpdateViewport(renderer);
- }
-
- GL_ClearErrors(renderer);
-
- return 0;
-}
-
-static void
-GLES2_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
-
- if (event->event == SDL_WINDOWEVENT_SIZE_CHANGED ||
- event->event == SDL_WINDOWEVENT_SHOWN ||
- event->event == SDL_WINDOWEVENT_HIDDEN) {
- /* Rebind the context to the window area */
- SDL_CurrentContext = NULL;
- }
-
- if (event->event == SDL_WINDOWEVENT_MINIMIZED) {
- /* According to Apple documentation, we need to finish drawing NOW! */
- data->glFinish();
- }
-}
-
-static int
-GLES2_GetOutputSize(SDL_Renderer * renderer, int *w, int *h)
-{
- SDL_GL_GetDrawableSize(renderer->window, w, h);
- return 0;
-}
-
-static int
-GLES2_UpdateViewport(SDL_Renderer * renderer)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
-
- if (SDL_CurrentContext != data->context) {
- /* We'll update the viewport after we rebind the context */
- return 0;
- }
-
- if (renderer->target) {
- data->glViewport(renderer->viewport.x, renderer->viewport.y,
- renderer->viewport.w, renderer->viewport.h);
- } else {
- int w, h;
-
- SDL_GL_GetDrawableSize(renderer->window, &w, &h);
- data->glViewport(renderer->viewport.x, (h - renderer->viewport.y - renderer->viewport.h),
- renderer->viewport.w, renderer->viewport.h);
- }
-
- if (data->current_program) {
- GLES2_SetOrthographicProjection(renderer);
- }
- return GL_CheckError("", renderer);
-}
-
-static int
-GLES2_UpdateClipRect(SDL_Renderer * renderer)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
-
- if (SDL_CurrentContext != data->context) {
- /* We'll update the clip rect after we rebind the context */
- return 0;
- }
-
- if (renderer->clipping_enabled) {
- const SDL_Rect *rect = &renderer->clip_rect;
- data->glEnable(GL_SCISSOR_TEST);
- if (renderer->target) {
- data->glScissor(renderer->viewport.x + rect->x, renderer->viewport.y + rect->y, rect->w, rect->h);
- } else {
- int w, h;
-
- SDL_GL_GetDrawableSize(renderer->window, &w, &h);
- data->glScissor(renderer->viewport.x + rect->x, h - renderer->viewport.y - rect->y - rect->h, rect->w, rect->h);
- }
- } else {
- data->glDisable(GL_SCISSOR_TEST);
- }
- return 0;
-}
-
-static void
-GLES2_DestroyRenderer(SDL_Renderer *renderer)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
-
- /* Deallocate everything */
- if (data) {
- GLES2_ActivateRenderer(renderer);
-
- {
- GLES2_ShaderCacheEntry *entry;
- GLES2_ShaderCacheEntry *next;
- entry = data->shader_cache.head;
- while (entry) {
- data->glDeleteShader(entry->id);
- next = entry->next;
- SDL_free(entry);
- entry = next;
- }
- }
- {
- GLES2_ProgramCacheEntry *entry;
- GLES2_ProgramCacheEntry *next;
- entry = data->program_cache.head;
- while (entry) {
- data->glDeleteProgram(entry->id);
- next = entry->next;
- SDL_free(entry);
- entry = next;
- }
- }
- if (data->context) {
- while (data->framebuffers) {
- GLES2_FBOList *nextnode = data->framebuffers->next;
- data->glDeleteFramebuffers(1, &data->framebuffers->FBO);
- GL_CheckError("", renderer);
- SDL_free(data->framebuffers);
- data->framebuffers = nextnode;
- }
- SDL_GL_DeleteContext(data->context);
- }
- SDL_free(data->shader_formats);
- SDL_free(data);
- }
- SDL_free(renderer);
-}
-
-/*************************************************************************************************
- * Texture APIs *
- *************************************************************************************************/
-
-static int GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture);
-static int GLES2_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect,
- const void *pixels, int pitch);
-static int GLES2_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
- const SDL_Rect * rect,
- const Uint8 *Yplane, int Ypitch,
- const Uint8 *Uplane, int Upitch,
- const Uint8 *Vplane, int Vpitch);
-static int GLES2_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect,
- void **pixels, int *pitch);
-static void GLES2_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture);
-static int GLES2_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture);
-static void GLES2_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture);
-
-static GLenum
-GetScaleQuality(void)
-{
- const char *hint = SDL_GetHint(SDL_HINT_RENDER_SCALE_QUALITY);
-
- if (!hint || *hint == '0' || SDL_strcasecmp(hint, "nearest") == 0) {
- return GL_NEAREST;
- } else {
- return GL_LINEAR;
- }
-}
-
-static int
-GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
-{
- GLES2_DriverContext *renderdata = (GLES2_DriverContext *)renderer->driverdata;
- GLES2_TextureData *data;
- GLenum format;
- GLenum type;
- GLenum scaleMode;
-
- GLES2_ActivateRenderer(renderer);
-
- /* Determine the corresponding GLES texture format params */
- switch (texture->format)
- {
- case SDL_PIXELFORMAT_ARGB8888:
- case SDL_PIXELFORMAT_ABGR8888:
- case SDL_PIXELFORMAT_RGB888:
- case SDL_PIXELFORMAT_BGR888:
- format = GL_RGBA;
- type = GL_UNSIGNED_BYTE;
- break;
- case SDL_PIXELFORMAT_IYUV:
- case SDL_PIXELFORMAT_YV12:
- case SDL_PIXELFORMAT_NV12:
- case SDL_PIXELFORMAT_NV21:
- format = GL_LUMINANCE;
- type = GL_UNSIGNED_BYTE;
- break;
- default:
- return SDL_SetError("Texture format not supported");
- }
-
- /* Allocate a texture struct */
- data = (GLES2_TextureData *)SDL_calloc(1, sizeof(GLES2_TextureData));
- if (!data) {
- return SDL_OutOfMemory();
- }
- data->texture = 0;
- data->texture_type = GL_TEXTURE_2D;
- data->pixel_format = format;
- data->pixel_type = type;
- data->yuv = ((texture->format == SDL_PIXELFORMAT_IYUV) || (texture->format == SDL_PIXELFORMAT_YV12));
- data->nv12 = ((texture->format == SDL_PIXELFORMAT_NV12) || (texture->format == SDL_PIXELFORMAT_NV21));
- data->texture_u = 0;
- data->texture_v = 0;
- scaleMode = GetScaleQuality();
-
- /* Allocate a blob for image renderdata */
- if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
- size_t size;
- data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
- size = texture->h * data->pitch;
- if (data->yuv) {
- /* Need to add size for the U and V planes */
- size += (2 * (texture->h * data->pitch) / 4);
- }
- if (data->nv12) {
- /* Need to add size for the U/V plane */
- size += ((texture->h * data->pitch) / 2);
- }
- data->pixel_data = SDL_calloc(1, size);
- if (!data->pixel_data) {
- SDL_free(data);
- return SDL_OutOfMemory();
- }
- }
-
- /* Allocate the texture */
- GL_CheckError("", renderer);
-
- if (data->yuv) {
- renderdata->glGenTextures(1, &data->texture_v);
- if (GL_CheckError("glGenTexures()", renderer) < 0) {
- return -1;
- }
- renderdata->glActiveTexture(GL_TEXTURE2);
- renderdata->glBindTexture(data->texture_type, data->texture_v);
- renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MIN_FILTER, scaleMode);
- renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MAG_FILTER, scaleMode);
- renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
- renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
- renderdata->glTexImage2D(data->texture_type, 0, format, texture->w / 2, texture->h / 2, 0, format, type, NULL);
-
- renderdata->glGenTextures(1, &data->texture_u);
- if (GL_CheckError("glGenTexures()", renderer) < 0) {
- return -1;
- }
- renderdata->glActiveTexture(GL_TEXTURE1);
- renderdata->glBindTexture(data->texture_type, data->texture_u);
- renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MIN_FILTER, scaleMode);
- renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MAG_FILTER, scaleMode);
- renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
- renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
- renderdata->glTexImage2D(data->texture_type, 0, format, texture->w / 2, texture->h / 2, 0, format, type, NULL);
- if (GL_CheckError("glTexImage2D()", renderer) < 0) {
- return -1;
- }
- }
-
- if (data->nv12) {
- renderdata->glGenTextures(1, &data->texture_u);
- if (GL_CheckError("glGenTexures()", renderer) < 0) {
- return -1;
- }
- renderdata->glActiveTexture(GL_TEXTURE1);
- renderdata->glBindTexture(data->texture_type, data->texture_u);
- renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MIN_FILTER, scaleMode);
- renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MAG_FILTER, scaleMode);
- renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
- renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
- renderdata->glTexImage2D(data->texture_type, 0, GL_LUMINANCE_ALPHA, texture->w / 2, texture->h / 2, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
- if (GL_CheckError("glTexImage2D()", renderer) < 0) {
- return -1;
- }
- }
-
- renderdata->glGenTextures(1, &data->texture);
- if (GL_CheckError("glGenTexures()", renderer) < 0) {
- return -1;
- }
- texture->driverdata = data;
- renderdata->glActiveTexture(GL_TEXTURE0);
- renderdata->glBindTexture(data->texture_type, data->texture);
- renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MIN_FILTER, scaleMode);
- renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_MAG_FILTER, scaleMode);
- renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
- renderdata->glTexParameteri(data->texture_type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
- renderdata->glTexImage2D(data->texture_type, 0, format, texture->w, texture->h, 0, format, type, NULL);
- if (GL_CheckError("glTexImage2D()", renderer) < 0) {
- return -1;
- }
-
- if (texture->access == SDL_TEXTUREACCESS_TARGET) {
- data->fbo = GLES2_GetFBO(renderer->driverdata, texture->w, texture->h);
- } else {
- data->fbo = NULL;
- }
-
- return GL_CheckError("", renderer);
-}
-
-static int
-GLES2_TexSubImage2D(GLES2_DriverContext *data, GLenum target, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels, GLint pitch, GLint bpp)
-{
- Uint8 *blob = NULL;
- Uint8 *src;
- int src_pitch;
- int y;
-
- /* Reformat the texture data into a tightly packed array */
- src_pitch = width * bpp;
- src = (Uint8 *)pixels;
- if (pitch != src_pitch) {
- blob = (Uint8 *)SDL_malloc(src_pitch * height);
- if (!blob) {
- return SDL_OutOfMemory();
- }
- src = blob;
- for (y = 0; y < height; ++y)
- {
- SDL_memcpy(src, pixels, src_pitch);
- src += src_pitch;
- pixels = (Uint8 *)pixels + pitch;
- }
- src = blob;
- }
-
- data->glTexSubImage2D(target, 0, xoffset, yoffset, width, height, format, type, src);
- if (blob) {
- SDL_free(blob);
- }
- return 0;
-}
-
-static int
-GLES2_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect,
- const void *pixels, int pitch)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
- GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;
-
- GLES2_ActivateRenderer(renderer);
-
- /* Bail out if we're supposed to update an empty rectangle */
- if (rect->w <= 0 || rect->h <= 0) {
- return 0;
- }
-
- /* Create a texture subimage with the supplied data */
- data->glBindTexture(tdata->texture_type, tdata->texture);
- GLES2_TexSubImage2D(data, tdata->texture_type,
- rect->x,
- rect->y,
- rect->w,
- rect->h,
- tdata->pixel_format,
- tdata->pixel_type,
- pixels, pitch, SDL_BYTESPERPIXEL(texture->format));
-
- if (tdata->yuv) {
- /* Skip to the correct offset into the next texture */
- pixels = (const void*)((const Uint8*)pixels + rect->h * pitch);
- if (texture->format == SDL_PIXELFORMAT_YV12) {
- data->glBindTexture(tdata->texture_type, tdata->texture_v);
- } else {
- data->glBindTexture(tdata->texture_type, tdata->texture_u);
- }
- GLES2_TexSubImage2D(data, tdata->texture_type,
- rect->x / 2,
- rect->y / 2,
- rect->w / 2,
- rect->h / 2,
- tdata->pixel_format,
- tdata->pixel_type,
- pixels, pitch / 2, 1);
-
- /* Skip to the correct offset into the next texture */
- pixels = (const void*)((const Uint8*)pixels + (rect->h * pitch)/4);
- if (texture->format == SDL_PIXELFORMAT_YV12) {
- data->glBindTexture(tdata->texture_type, tdata->texture_u);
- } else {
- data->glBindTexture(tdata->texture_type, tdata->texture_v);
- }
- GLES2_TexSubImage2D(data, tdata->texture_type,
- rect->x / 2,
- rect->y / 2,
- rect->w / 2,
- rect->h / 2,
- tdata->pixel_format,
- tdata->pixel_type,
- pixels, pitch / 2, 1);
- }
-
- if (tdata->nv12) {
- /* Skip to the correct offset into the next texture */
- pixels = (const void*)((const Uint8*)pixels + rect->h * pitch);
- data->glBindTexture(tdata->texture_type, tdata->texture_u);
- GLES2_TexSubImage2D(data, tdata->texture_type,
- rect->x / 2,
- rect->y / 2,
- rect->w / 2,
- rect->h / 2,
- GL_LUMINANCE_ALPHA,
- GL_UNSIGNED_BYTE,
- pixels, pitch, 2);
- }
-
- return GL_CheckError("glTexSubImage2D()", renderer);
-}
-
-static int
-GLES2_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
- const SDL_Rect * rect,
- const Uint8 *Yplane, int Ypitch,
- const Uint8 *Uplane, int Upitch,
- const Uint8 *Vplane, int Vpitch)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
- GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;
-
- GLES2_ActivateRenderer(renderer);
-
- /* Bail out if we're supposed to update an empty rectangle */
- if (rect->w <= 0 || rect->h <= 0) {
- return 0;
- }
-
- data->glBindTexture(tdata->texture_type, tdata->texture_v);
- GLES2_TexSubImage2D(data, tdata->texture_type,
- rect->x / 2,
- rect->y / 2,
- rect->w / 2,
- rect->h / 2,
- tdata->pixel_format,
- tdata->pixel_type,
- Vplane, Vpitch, 1);
-
- data->glBindTexture(tdata->texture_type, tdata->texture_u);
- GLES2_TexSubImage2D(data, tdata->texture_type,
- rect->x / 2,
- rect->y / 2,
- rect->w / 2,
- rect->h / 2,
- tdata->pixel_format,
- tdata->pixel_type,
- Uplane, Upitch, 1);
-
- data->glBindTexture(tdata->texture_type, tdata->texture);
- GLES2_TexSubImage2D(data, tdata->texture_type,
- rect->x,
- rect->y,
- rect->w,
- rect->h,
- tdata->pixel_format,
- tdata->pixel_type,
- Yplane, Ypitch, 1);
-
- return GL_CheckError("glTexSubImage2D()", renderer);
-}
-
-static int
-GLES2_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect,
- void **pixels, int *pitch)
-{
- GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;
-
- /* Retrieve the buffer/pitch for the specified region */
- *pixels = (Uint8 *)tdata->pixel_data +
- (tdata->pitch * rect->y) +
- (rect->x * SDL_BYTESPERPIXEL(texture->format));
- *pitch = tdata->pitch;
-
- return 0;
-}
-
-static void
-GLES2_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
-{
- GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;
- SDL_Rect rect;
-
- /* We do whole texture updates, at least for now */
- rect.x = 0;
- rect.y = 0;
- rect.w = texture->w;
- rect.h = texture->h;
- GLES2_UpdateTexture(renderer, texture, &rect, tdata->pixel_data, tdata->pitch);
-}
-
-static int
-GLES2_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *) renderer->driverdata;
- GLES2_TextureData *texturedata = NULL;
- GLenum status;
-
- if (texture == NULL) {
- data->glBindFramebuffer(GL_FRAMEBUFFER, data->window_framebuffer);
- } else {
- texturedata = (GLES2_TextureData *) texture->driverdata;
- data->glBindFramebuffer(GL_FRAMEBUFFER, texturedata->fbo->FBO);
- /* TODO: check if texture pixel format allows this operation */
- data->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texturedata->texture_type, texturedata->texture, 0);
- /* Check FBO status */
- status = data->glCheckFramebufferStatus(GL_FRAMEBUFFER);
- if (status != GL_FRAMEBUFFER_COMPLETE) {
- return SDL_SetError("glFramebufferTexture2D() failed");
- }
- }
- return 0;
-}
-
-static void
-GLES2_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
- GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;
-
- GLES2_ActivateRenderer(renderer);
-
- /* Destroy the texture */
- if (tdata) {
- data->glDeleteTextures(1, &tdata->texture);
- if (tdata->texture_v) {
- data->glDeleteTextures(1, &tdata->texture_v);
- }
- if (tdata->texture_u) {
- data->glDeleteTextures(1, &tdata->texture_u);
- }
- SDL_free(tdata->pixel_data);
- SDL_free(tdata);
- texture->driverdata = NULL;
- }
-}
-
-/*************************************************************************************************
- * Shader management functions *
- *************************************************************************************************/
-
-static GLES2_ShaderCacheEntry *GLES2_CacheShader(SDL_Renderer *renderer, GLES2_ShaderType type,
- SDL_BlendMode blendMode);
-static void GLES2_EvictShader(SDL_Renderer *renderer, GLES2_ShaderCacheEntry *entry);
-static GLES2_ProgramCacheEntry *GLES2_CacheProgram(SDL_Renderer *renderer,
- GLES2_ShaderCacheEntry *vertex,
- GLES2_ShaderCacheEntry *fragment,
- SDL_BlendMode blendMode);
-static int GLES2_SelectProgram(SDL_Renderer *renderer, GLES2_ImageSource source,
- SDL_BlendMode blendMode);
-
-static GLES2_ProgramCacheEntry *
-GLES2_CacheProgram(SDL_Renderer *renderer, GLES2_ShaderCacheEntry *vertex,
- GLES2_ShaderCacheEntry *fragment, SDL_BlendMode blendMode)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
- GLES2_ProgramCacheEntry *entry;
- GLES2_ShaderCacheEntry *shaderEntry;
- GLint linkSuccessful;
-
- /* Check if we've already cached this program */
- entry = data->program_cache.head;
- while (entry) {
- if (entry->vertex_shader == vertex && entry->fragment_shader == fragment) {
- break;
- }
- entry = entry->next;
- }
- if (entry) {
- if (data->program_cache.head != entry) {
- if (entry->next) {
- entry->next->prev = entry->prev;
- }
- if (entry->prev) {
- entry->prev->next = entry->next;
- }
- entry->prev = NULL;
- entry->next = data->program_cache.head;
- data->program_cache.head->prev = entry;
- data->program_cache.head = entry;
- }
- return entry;
- }
-
- /* Create a program cache entry */
- entry = (GLES2_ProgramCacheEntry *)SDL_calloc(1, sizeof(GLES2_ProgramCacheEntry));
- if (!entry) {
- SDL_OutOfMemory();
- return NULL;
- }
- entry->vertex_shader = vertex;
- entry->fragment_shader = fragment;
- entry->blend_mode = blendMode;
-
- /* Create the program and link it */
- entry->id = data->glCreateProgram();
- data->glAttachShader(entry->id, vertex->id);
- data->glAttachShader(entry->id, fragment->id);
- data->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_POSITION, "a_position");
- data->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_TEXCOORD, "a_texCoord");
- data->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_ANGLE, "a_angle");
- data->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_CENTER, "a_center");
- data->glLinkProgram(entry->id);
- data->glGetProgramiv(entry->id, GL_LINK_STATUS, &linkSuccessful);
- if (!linkSuccessful) {
- data->glDeleteProgram(entry->id);
- SDL_free(entry);
- SDL_SetError("Failed to link shader program");
- return NULL;
- }
-
- /* Predetermine locations of uniform variables */
- entry->uniform_locations[GLES2_UNIFORM_PROJECTION] =
- data->glGetUniformLocation(entry->id, "u_projection");
- entry->uniform_locations[GLES2_UNIFORM_TEXTURE_V] =
- data->glGetUniformLocation(entry->id, "u_texture_v");
- entry->uniform_locations[GLES2_UNIFORM_TEXTURE_U] =
- data->glGetUniformLocation(entry->id, "u_texture_u");
- entry->uniform_locations[GLES2_UNIFORM_TEXTURE] =
- data->glGetUniformLocation(entry->id, "u_texture");
- entry->uniform_locations[GLES2_UNIFORM_MODULATION] =
- data->glGetUniformLocation(entry->id, "u_modulation");
- entry->uniform_locations[GLES2_UNIFORM_COLOR] =
- data->glGetUniformLocation(entry->id, "u_color");
-
- entry->modulation_r = entry->modulation_g = entry->modulation_b = entry->modulation_a = 255;
- entry->color_r = entry->color_g = entry->color_b = entry->color_a = 255;
-
- data->glUseProgram(entry->id);
- data->glUniform1i(entry->uniform_locations[GLES2_UNIFORM_TEXTURE_V], 2); /* always texture unit 2. */
- data->glUniform1i(entry->uniform_locations[GLES2_UNIFORM_TEXTURE_U], 1); /* always texture unit 1. */
- data->glUniform1i(entry->uniform_locations[GLES2_UNIFORM_TEXTURE], 0); /* always texture unit 0. */
- data->glUniformMatrix4fv(entry->uniform_locations[GLES2_UNIFORM_PROJECTION], 1, GL_FALSE, (GLfloat *)entry->projection);
- data->glUniform4f(entry->uniform_locations[GLES2_UNIFORM_MODULATION], 1.0f, 1.0f, 1.0f, 1.0f);
- data->glUniform4f(entry->uniform_locations[GLES2_UNIFORM_COLOR], 1.0f, 1.0f, 1.0f, 1.0f);
-
- /* Cache the linked program */
- if (data->program_cache.head) {
- entry->next = data->program_cache.head;
- data->program_cache.head->prev = entry;
- } else {
- data->program_cache.tail = entry;
- }
- data->program_cache.head = entry;
- ++data->program_cache.count;
-
- /* Increment the refcount of the shaders we're using */
- ++vertex->references;
- ++fragment->references;
-
- /* Evict the last entry from the cache if we exceed the limit */
- if (data->program_cache.count > GLES2_MAX_CACHED_PROGRAMS) {
- shaderEntry = data->program_cache.tail->vertex_shader;
- if (--shaderEntry->references <= 0) {
- GLES2_EvictShader(renderer, shaderEntry);
- }
- shaderEntry = data->program_cache.tail->fragment_shader;
- if (--shaderEntry->references <= 0) {
- GLES2_EvictShader(renderer, shaderEntry);
- }
- data->glDeleteProgram(data->program_cache.tail->id);
- data->program_cache.tail = data->program_cache.tail->prev;
- SDL_free(data->program_cache.tail->next);
- data->program_cache.tail->next = NULL;
- --data->program_cache.count;
- }
- return entry;
-}
-
-static GLES2_ShaderCacheEntry *
-GLES2_CacheShader(SDL_Renderer *renderer, GLES2_ShaderType type, SDL_BlendMode blendMode)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
- const GLES2_Shader *shader;
- const GLES2_ShaderInstance *instance = NULL;
- GLES2_ShaderCacheEntry *entry = NULL;
- GLint compileSuccessful = GL_FALSE;
- int i, j;
-
- /* Find the corresponding shader */
- shader = GLES2_GetShader(type, blendMode);
- if (!shader) {
- SDL_SetError("No shader matching the requested characteristics was found");
- return NULL;
- }
-
- /* Find a matching shader instance that's supported on this hardware */
- for (i = 0; i < shader->instance_count && !instance; ++i) {
- for (j = 0; j < data->shader_format_count && !instance; ++j) {
- if (!shader->instances[i]) {
- continue;
- }
- if (shader->instances[i]->format != data->shader_formats[j]) {
- continue;
- }
- instance = shader->instances[i];
- }
- }
- if (!instance) {
- SDL_SetError("The specified shader cannot be loaded on the current platform");
- return NULL;
- }
-
- /* Check if we've already cached this shader */
- entry = data->shader_cache.head;
- while (entry) {
- if (entry->instance == instance) {
- break;
- }
- entry = entry->next;
- }
- if (entry) {
- return entry;
- }
-
- /* Create a shader cache entry */
- entry = (GLES2_ShaderCacheEntry *)SDL_calloc(1, sizeof(GLES2_ShaderCacheEntry));
- if (!entry) {
- SDL_OutOfMemory();
- return NULL;
- }
- entry->type = type;
- entry->instance = instance;
-
- /* Compile or load the selected shader instance */
- entry->id = data->glCreateShader(instance->type);
- if (instance->format == (GLenum)-1) {
- data->glShaderSource(entry->id, 1, (const char **)&instance->data, NULL);
- data->glCompileShader(entry->id);
- data->glGetShaderiv(entry->id, GL_COMPILE_STATUS, &compileSuccessful);
- } else {
- data->glShaderBinary(1, &entry->id, instance->format, instance->data, instance->length);
- compileSuccessful = GL_TRUE;
- }
- if (!compileSuccessful) {
- char *info = NULL;
- int length = 0;
-
- data->glGetShaderiv(entry->id, GL_INFO_LOG_LENGTH, &length);
- if (length > 0) {
- info = SDL_stack_alloc(char, length);
- if (info) {
- data->glGetShaderInfoLog(entry->id, length, &length, info);
- }
- }
- if (info) {
- SDL_SetError("Failed to load the shader: %s", info);
- SDL_stack_free(info);
- } else {
- SDL_SetError("Failed to load the shader");
- }
- data->glDeleteShader(entry->id);
- SDL_free(entry);
- return NULL;
- }
-
- /* Link the shader entry in at the front of the cache */
- if (data->shader_cache.head) {
- entry->next = data->shader_cache.head;
- data->shader_cache.head->prev = entry;
- }
- data->shader_cache.head = entry;
- ++data->shader_cache.count;
- return entry;
-}
-
-static void
-GLES2_EvictShader(SDL_Renderer *renderer, GLES2_ShaderCacheEntry *entry)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
-
- /* Unlink the shader from the cache */
- if (entry->next) {
- entry->next->prev = entry->prev;
- }
- if (entry->prev) {
- entry->prev->next = entry->next;
- }
- if (data->shader_cache.head == entry) {
- data->shader_cache.head = entry->next;
- }
- --data->shader_cache.count;
-
- /* Deallocate the shader */
- data->glDeleteShader(entry->id);
- SDL_free(entry);
-}
-
-static int
-GLES2_SelectProgram(SDL_Renderer *renderer, GLES2_ImageSource source, SDL_BlendMode blendMode)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
- GLES2_ShaderCacheEntry *vertex = NULL;
- GLES2_ShaderCacheEntry *fragment = NULL;
- GLES2_ShaderType vtype, ftype;
- GLES2_ProgramCacheEntry *program;
-
- /* Select an appropriate shader pair for the specified modes */
- vtype = GLES2_SHADER_VERTEX_DEFAULT;
- switch (source) {
- case GLES2_IMAGESOURCE_SOLID:
- ftype = GLES2_SHADER_FRAGMENT_SOLID_SRC;
- break;
- case GLES2_IMAGESOURCE_TEXTURE_ABGR:
- ftype = GLES2_SHADER_FRAGMENT_TEXTURE_ABGR_SRC;
- break;
- case GLES2_IMAGESOURCE_TEXTURE_ARGB:
- ftype = GLES2_SHADER_FRAGMENT_TEXTURE_ARGB_SRC;
- break;
- case GLES2_IMAGESOURCE_TEXTURE_RGB:
- ftype = GLES2_SHADER_FRAGMENT_TEXTURE_RGB_SRC;
- break;
- case GLES2_IMAGESOURCE_TEXTURE_BGR:
- ftype = GLES2_SHADER_FRAGMENT_TEXTURE_BGR_SRC;
- break;
- case GLES2_IMAGESOURCE_TEXTURE_YUV:
- ftype = GLES2_SHADER_FRAGMENT_TEXTURE_YUV_SRC;
- break;
- case GLES2_IMAGESOURCE_TEXTURE_NV12:
- ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_SRC;
- break;
- case GLES2_IMAGESOURCE_TEXTURE_NV21:
- ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_SRC;
- break;
- default:
- goto fault;
- }
-
- /* Load the requested shaders */
- vertex = GLES2_CacheShader(renderer, vtype, blendMode);
- if (!vertex) {
- goto fault;
- }
- fragment = GLES2_CacheShader(renderer, ftype, blendMode);
- if (!fragment) {
- goto fault;
- }
-
- /* Check if we need to change programs at all */
- if (data->current_program &&
- data->current_program->vertex_shader == vertex &&
- data->current_program->fragment_shader == fragment) {
- return 0;
- }
-
- /* Generate a matching program */
- program = GLES2_CacheProgram(renderer, vertex, fragment, blendMode);
- if (!program) {
- goto fault;
- }
-
- /* Select that program in OpenGL */
- data->glUseProgram(program->id);
-
- /* Set the current program */
- data->current_program = program;
-
- /* Activate an orthographic projection */
- if (GLES2_SetOrthographicProjection(renderer) < 0) {
- goto fault;
- }
-
- /* Clean up and return */
- return 0;
-fault:
- if (vertex && vertex->references <= 0) {
- GLES2_EvictShader(renderer, vertex);
- }
- if (fragment && fragment->references <= 0) {
- GLES2_EvictShader(renderer, fragment);
- }
- data->current_program = NULL;
- return -1;
-}
-
-static int
-GLES2_SetOrthographicProjection(SDL_Renderer *renderer)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
- GLfloat projection[4][4];
-
- if (!renderer->viewport.w || !renderer->viewport.h) {
- return 0;
- }
-
- /* Prepare an orthographic projection */
- projection[0][0] = 2.0f / renderer->viewport.w;
- projection[0][1] = 0.0f;
- projection[0][2] = 0.0f;
- projection[0][3] = 0.0f;
- projection[1][0] = 0.0f;
- if (renderer->target) {
- projection[1][1] = 2.0f / renderer->viewport.h;
- } else {
- projection[1][1] = -2.0f / renderer->viewport.h;
- }
- projection[1][2] = 0.0f;
- projection[1][3] = 0.0f;
- projection[2][0] = 0.0f;
- projection[2][1] = 0.0f;
- projection[2][2] = 0.0f;
- projection[2][3] = 0.0f;
- projection[3][0] = -1.0f;
- if (renderer->target) {
- projection[3][1] = -1.0f;
- } else {
- projection[3][1] = 1.0f;
- }
- projection[3][2] = 0.0f;
- projection[3][3] = 1.0f;
-
- /* Set the projection matrix */
- if (SDL_memcmp(data->current_program->projection, projection, sizeof (projection)) != 0) {
- const GLuint locProjection = data->current_program->uniform_locations[GLES2_UNIFORM_PROJECTION];
- data->glUniformMatrix4fv(locProjection, 1, GL_FALSE, (GLfloat *)projection);
- SDL_memcpy(data->current_program->projection, projection, sizeof (projection));
- }
-
- return 0;
-}
-
-/*************************************************************************************************
- * Rendering functions *
- *************************************************************************************************/
-
-static const float inv255f = 1.0f / 255.0f;
-
-static int GLES2_RenderClear(SDL_Renderer *renderer);
-static int GLES2_RenderDrawPoints(SDL_Renderer *renderer, const SDL_FPoint *points, int count);
-static int GLES2_RenderDrawLines(SDL_Renderer *renderer, const SDL_FPoint *points, int count);
-static int GLES2_RenderFillRects(SDL_Renderer *renderer, const SDL_FRect *rects, int count);
-static int GLES2_RenderCopy(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect,
- const SDL_FRect *dstrect);
-static int GLES2_RenderCopyEx(SDL_Renderer * renderer, SDL_Texture * texture,
- const SDL_Rect * srcrect, const SDL_FRect * dstrect,
- const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip);
-static int GLES2_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
- Uint32 pixel_format, void * pixels, int pitch);
-static void GLES2_RenderPresent(SDL_Renderer *renderer);
-
-static SDL_bool
-CompareColors(Uint8 r1, Uint8 g1, Uint8 b1, Uint8 a1,
- Uint8 r2, Uint8 g2, Uint8 b2, Uint8 a2)
-{
- Uint32 Pixel1, Pixel2;
- RGBA8888_FROM_RGBA(Pixel1, r1, g1, b1, a1);
- RGBA8888_FROM_RGBA(Pixel2, r2, g2, b2, a2);
- return (Pixel1 == Pixel2);
-}
-
-static int
-GLES2_RenderClear(SDL_Renderer * renderer)
-{
- Uint8 r, g, b, a;
-
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
-
- GLES2_ActivateRenderer(renderer);
-
- if (!CompareColors(data->clear_r, data->clear_g, data->clear_b, data->clear_a,
- renderer->r, renderer->g, renderer->b, renderer->a)) {
-
- /* Select the color to clear with */
- g = renderer->g;
- a = renderer->a;
-
- if (renderer->target &&
- (renderer->target->format == SDL_PIXELFORMAT_ARGB8888 ||
- renderer->target->format == SDL_PIXELFORMAT_RGB888)) {
- r = renderer->b;
- b = renderer->r;
- } else {
- r = renderer->r;
- b = renderer->b;
- }
-
- data->glClearColor((GLfloat) r * inv255f,
- (GLfloat) g * inv255f,
- (GLfloat) b * inv255f,
- (GLfloat) a * inv255f);
- data->clear_r = renderer->r;
- data->clear_g = renderer->g;
- data->clear_b = renderer->b;
- data->clear_a = renderer->a;
- }
-
- if (renderer->clipping_enabled) {
- data->glDisable(GL_SCISSOR_TEST);
- }
-
- data->glClear(GL_COLOR_BUFFER_BIT);
-
- if (renderer->clipping_enabled) {
- data->glEnable(GL_SCISSOR_TEST);
- }
-
- return 0;
-}
-
-static void
-GLES2_SetBlendMode(GLES2_DriverContext *data, int blendMode)
-{
- if (blendMode != data->current.blendMode) {
- switch (blendMode) {
- default:
- case SDL_BLENDMODE_NONE:
- data->glDisable(GL_BLEND);
- break;
- case SDL_BLENDMODE_BLEND:
- data->glEnable(GL_BLEND);
- data->glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
- break;
- case SDL_BLENDMODE_ADD:
- data->glEnable(GL_BLEND);
- data->glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE, GL_ZERO, GL_ONE);
- break;
- case SDL_BLENDMODE_MOD:
- data->glEnable(GL_BLEND);
- data->glBlendFuncSeparate(GL_ZERO, GL_SRC_COLOR, GL_ZERO, GL_ONE);
- break;
- }
- data->current.blendMode = blendMode;
- }
-}
-
-static void
-GLES2_SetTexCoords(GLES2_DriverContext * data, SDL_bool enabled)
-{
- if (enabled != data->current.tex_coords) {
- if (enabled) {
- data->glEnableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD);
- } else {
- data->glDisableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD);
- }
- data->current.tex_coords = enabled;
- }
-}
-
-static int
-GLES2_SetDrawingState(SDL_Renderer * renderer)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
- const int blendMode = renderer->blendMode;
- GLES2_ProgramCacheEntry *program;
- Uint8 r, g, b, a;
-
- GLES2_ActivateRenderer(renderer);
-
- GLES2_SetBlendMode(data, blendMode);
-
- GLES2_SetTexCoords(data, SDL_FALSE);
-
- /* Activate an appropriate shader and set the projection matrix */
- if (GLES2_SelectProgram(renderer, GLES2_IMAGESOURCE_SOLID, blendMode) < 0) {
- return -1;
- }
-
- /* Select the color to draw with */
- g = renderer->g;
- a = renderer->a;
-
- if (renderer->target &&
- (renderer->target->format == SDL_PIXELFORMAT_ARGB8888 ||
- renderer->target->format == SDL_PIXELFORMAT_RGB888)) {
- r = renderer->b;
- b = renderer->r;
- } else {
- r = renderer->r;
- b = renderer->b;
- }
-
- program = data->current_program;
- if (!CompareColors(program->color_r, program->color_g, program->color_b, program->color_a, r, g, b, a)) {
- /* Select the color to draw with */
- data->glUniform4f(program->uniform_locations[GLES2_UNIFORM_COLOR], r * inv255f, g * inv255f, b * inv255f, a * inv255f);
- program->color_r = r;
- program->color_g = g;
- program->color_b = b;
- program->color_a = a;
- }
-
- return 0;
-}
-
-static int
-GLES2_UpdateVertexBuffer(SDL_Renderer *renderer, GLES2_Attribute attr,
- const void *vertexData, size_t dataSizeInBytes)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
-
-#if !SDL_GLES2_USE_VBOS
- data->glVertexAttribPointer(attr, attr == GLES2_ATTRIBUTE_ANGLE ? 1 : 2, GL_FLOAT, GL_FALSE, 0, vertexData);
-#else
- if (!data->vertex_buffers[attr]) {
- data->glGenBuffers(1, &data->vertex_buffers[attr]);
- }
-
- data->glBindBuffer(GL_ARRAY_BUFFER, data->vertex_buffers[attr]);
-
- if (data->vertex_buffer_size[attr] < dataSizeInBytes) {
- data->glBufferData(GL_ARRAY_BUFFER, dataSizeInBytes, vertexData, GL_STREAM_DRAW);
- data->vertex_buffer_size[attr] = dataSizeInBytes;
- } else {
- data->glBufferSubData(GL_ARRAY_BUFFER, 0, dataSizeInBytes, vertexData);
- }
-
- data->glVertexAttribPointer(attr, attr == GLES2_ATTRIBUTE_ANGLE ? 1 : 2, GL_FLOAT, GL_FALSE, 0, 0);
-#endif
-
- return 0;
-}
-
-static int
-GLES2_RenderDrawPoints(SDL_Renderer *renderer, const SDL_FPoint *points, int count)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
- GLfloat *vertices;
- int idx;
-
- if (GLES2_SetDrawingState(renderer) < 0) {
- return -1;
- }
-
- /* Emit the specified vertices as points */
- vertices = SDL_stack_alloc(GLfloat, count * 2);
- for (idx = 0; idx < count; ++idx) {
- GLfloat x = points[idx].x + 0.5f;
- GLfloat y = points[idx].y + 0.5f;
-
- vertices[idx * 2] = x;
- vertices[(idx * 2) + 1] = y;
- }
- /*data->glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);*/
- GLES2_UpdateVertexBuffer(renderer, GLES2_ATTRIBUTE_POSITION, vertices, count * 2 * sizeof(GLfloat));
- data->glDrawArrays(GL_POINTS, 0, count);
- SDL_stack_free(vertices);
- return 0;
-}
-
-static int
-GLES2_RenderDrawLines(SDL_Renderer *renderer, const SDL_FPoint *points, int count)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
- GLfloat *vertices;
- int idx;
-
- if (GLES2_SetDrawingState(renderer) < 0) {
- return -1;
- }
-
- /* Emit a line strip including the specified vertices */
- vertices = SDL_stack_alloc(GLfloat, count * 2);
- for (idx = 0; idx < count; ++idx) {
- GLfloat x = points[idx].x + 0.5f;
- GLfloat y = points[idx].y + 0.5f;
-
- vertices[idx * 2] = x;
- vertices[(idx * 2) + 1] = y;
- }
- /*data->glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);*/
- GLES2_UpdateVertexBuffer(renderer, GLES2_ATTRIBUTE_POSITION, vertices, count * 2 * sizeof(GLfloat));
- data->glDrawArrays(GL_LINE_STRIP, 0, count);
-
- /* We need to close the endpoint of the line */
- if (count == 2 ||
- points[0].x != points[count-1].x || points[0].y != points[count-1].y) {
- data->glDrawArrays(GL_POINTS, count-1, 1);
- }
- SDL_stack_free(vertices);
-
- return GL_CheckError("", renderer);
-}
-
-static int
-GLES2_RenderFillRects(SDL_Renderer *renderer, const SDL_FRect *rects, int count)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
- GLfloat vertices[8];
- int idx;
-
- if (GLES2_SetDrawingState(renderer) < 0) {
- return -1;
- }
-
- /* Emit a line loop for each rectangle */
- for (idx = 0; idx < count; ++idx) {
- const SDL_FRect *rect = &rects[idx];
-
- GLfloat xMin = rect->x;
- GLfloat xMax = (rect->x + rect->w);
- GLfloat yMin = rect->y;
- GLfloat yMax = (rect->y + rect->h);
-
- vertices[0] = xMin;
- vertices[1] = yMin;
- vertices[2] = xMax;
- vertices[3] = yMin;
- vertices[4] = xMin;
- vertices[5] = yMax;
- vertices[6] = xMax;
- vertices[7] = yMax;
- /*data->glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);*/
- GLES2_UpdateVertexBuffer(renderer, GLES2_ATTRIBUTE_POSITION, vertices, 8 * sizeof(GLfloat));
- data->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
- }
- return GL_CheckError("", renderer);
-}
-
-static int
-GLES2_SetupCopy(SDL_Renderer *renderer, SDL_Texture *texture)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
- GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata;
- GLES2_ImageSource sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
- SDL_BlendMode blendMode;
- GLES2_ProgramCacheEntry *program;
- Uint8 r, g, b, a;
-
- /* Activate an appropriate shader and set the projection matrix */
- blendMode = texture->blendMode;
- if (renderer->target) {
- /* Check if we need to do color mapping between the source and render target textures */
- if (renderer->target->format != texture->format) {
- switch (texture->format) {
- case SDL_PIXELFORMAT_ARGB8888:
- switch (renderer->target->format) {
- case SDL_PIXELFORMAT_ABGR8888:
- case SDL_PIXELFORMAT_BGR888:
- sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
- break;
- case SDL_PIXELFORMAT_RGB888:
- sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
- break;
- }
- break;
- case SDL_PIXELFORMAT_ABGR8888:
- switch (renderer->target->format) {
- case SDL_PIXELFORMAT_ARGB8888:
- case SDL_PIXELFORMAT_RGB888:
- sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
- break;
- case SDL_PIXELFORMAT_BGR888:
- sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
- break;
- }
- break;
- case SDL_PIXELFORMAT_RGB888:
- switch (renderer->target->format) {
- case SDL_PIXELFORMAT_ABGR8888:
- sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
- break;
- case SDL_PIXELFORMAT_ARGB8888:
- sourceType = GLES2_IMAGESOURCE_TEXTURE_BGR;
- break;
- case SDL_PIXELFORMAT_BGR888:
- sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
- break;
- }
- break;
- case SDL_PIXELFORMAT_BGR888:
- switch (renderer->target->format) {
- case SDL_PIXELFORMAT_ABGR8888:
- sourceType = GLES2_IMAGESOURCE_TEXTURE_BGR;
- break;
- case SDL_PIXELFORMAT_ARGB8888:
- sourceType = GLES2_IMAGESOURCE_TEXTURE_RGB;
- break;
- case SDL_PIXELFORMAT_RGB888:
- sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
- break;
- }
- break;
- case SDL_PIXELFORMAT_IYUV:
- case SDL_PIXELFORMAT_YV12:
- sourceType = GLES2_IMAGESOURCE_TEXTURE_YUV;
- break;
- case SDL_PIXELFORMAT_NV12:
- sourceType = GLES2_IMAGESOURCE_TEXTURE_NV12;
- break;
- case SDL_PIXELFORMAT_NV21:
- sourceType = GLES2_IMAGESOURCE_TEXTURE_NV21;
- break;
- default:
- return SDL_SetError("Unsupported texture format");
- }
- } else {
- sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR; /* Texture formats match, use the non color mapping shader (even if the formats are not ABGR) */
- }
- } else {
- switch (texture->format) {
- case SDL_PIXELFORMAT_ARGB8888:
- sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
- break;
- case SDL_PIXELFORMAT_ABGR8888:
- sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
- break;
- case SDL_PIXELFORMAT_RGB888:
- sourceType = GLES2_IMAGESOURCE_TEXTURE_RGB;
- break;
- case SDL_PIXELFORMAT_BGR888:
- sourceType = GLES2_IMAGESOURCE_TEXTURE_BGR;
- break;
- case SDL_PIXELFORMAT_IYUV:
- case SDL_PIXELFORMAT_YV12:
- sourceType = GLES2_IMAGESOURCE_TEXTURE_YUV;
- break;
- case SDL_PIXELFORMAT_NV12:
- sourceType = GLES2_IMAGESOURCE_TEXTURE_NV12;
- break;
- case SDL_PIXELFORMAT_NV21:
- sourceType = GLES2_IMAGESOURCE_TEXTURE_NV21;
- break;
- default:
- return SDL_SetError("Unsupported texture format");
- }
- }
-
- if (GLES2_SelectProgram(renderer, sourceType, blendMode) < 0) {
- return -1;
- }
-
- /* Select the target texture */
- if (tdata->yuv) {
- data->glActiveTexture(GL_TEXTURE2);
- data->glBindTexture(tdata->texture_type, tdata->texture_v);
-
- data->glActiveTexture(GL_TEXTURE1);
- data->glBindTexture(tdata->texture_type, tdata->texture_u);
-
- data->glActiveTexture(GL_TEXTURE0);
- }
- if (tdata->nv12) {
- data->glActiveTexture(GL_TEXTURE1);
- data->glBindTexture(tdata->texture_type, tdata->texture_u);
-
- data->glActiveTexture(GL_TEXTURE0);
- }
- data->glBindTexture(tdata->texture_type, tdata->texture);
-
- /* Configure color modulation */
- g = texture->g;
- a = texture->a;
-
- if (renderer->target &&
- (renderer->target->format == SDL_PIXELFORMAT_ARGB8888 ||
- renderer->target->format == SDL_PIXELFORMAT_RGB888)) {
- r = texture->b;
- b = texture->r;
- } else {
- r = texture->r;
- b = texture->b;
- }
-
- program = data->current_program;
-
- if (!CompareColors(program->modulation_r, program->modulation_g, program->modulation_b, program->modulation_a, r, g, b, a)) {
- data->glUniform4f(program->uniform_locations[GLES2_UNIFORM_MODULATION], r * inv255f, g * inv255f, b * inv255f, a * inv255f);
- program->modulation_r = r;
- program->modulation_g = g;
- program->modulation_b = b;
- program->modulation_a = a;
- }
-
- /* Configure texture blending */
- GLES2_SetBlendMode(data, blendMode);
-
- GLES2_SetTexCoords(data, SDL_TRUE);
- return 0;
-}
-
-static int
-GLES2_RenderCopy(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect,
- const SDL_FRect *dstrect)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
- GLfloat vertices[8];
- GLfloat texCoords[8];
-
- GLES2_ActivateRenderer(renderer);
-
- if (GLES2_SetupCopy(renderer, texture) < 0) {
- return -1;
- }
-
- /* Emit the textured quad */
- vertices[0] = dstrect->x;
- vertices[1] = dstrect->y;
- vertices[2] = (dstrect->x + dstrect->w);
- vertices[3] = dstrect->y;
- vertices[4] = dstrect->x;
- vertices[5] = (dstrect->y + dstrect->h);
- vertices[6] = (dstrect->x + dstrect->w);
- vertices[7] = (dstrect->y + dstrect->h);
- /*data->glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);*/
- GLES2_UpdateVertexBuffer(renderer, GLES2_ATTRIBUTE_POSITION, vertices, 8 * sizeof(GLfloat));
- texCoords[0] = srcrect->x / (GLfloat)texture->w;
- texCoords[1] = srcrect->y / (GLfloat)texture->h;
- texCoords[2] = (srcrect->x + srcrect->w) / (GLfloat)texture->w;
- texCoords[3] = srcrect->y / (GLfloat)texture->h;
- texCoords[4] = srcrect->x / (GLfloat)texture->w;
- texCoords[5] = (srcrect->y + srcrect->h) / (GLfloat)texture->h;
- texCoords[6] = (srcrect->x + srcrect->w) / (GLfloat)texture->w;
- texCoords[7] = (srcrect->y + srcrect->h) / (GLfloat)texture->h;
- /*data->glVertexAttribPointer(GLES2_ATTRIBUTE_TEXCOORD, 2, GL_FLOAT, GL_FALSE, 0, texCoords);*/
- GLES2_UpdateVertexBuffer(renderer, GLES2_ATTRIBUTE_TEXCOORD, texCoords, 8 * sizeof(GLfloat));
- data->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-
- return GL_CheckError("", renderer);
-}
-
-static int
-GLES2_RenderCopyEx(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect,
- const SDL_FRect *dstrect, const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
- GLfloat vertices[8];
- GLfloat texCoords[8];
- GLfloat translate[8];
- GLfloat fAngle[4];
- GLfloat tmp;
-
- GLES2_ActivateRenderer(renderer);
-
- if (GLES2_SetupCopy(renderer, texture) < 0) {
- return -1;
- }
-
- data->glEnableVertexAttribArray(GLES2_ATTRIBUTE_CENTER);
- data->glEnableVertexAttribArray(GLES2_ATTRIBUTE_ANGLE);
- fAngle[0] = fAngle[1] = fAngle[2] = fAngle[3] = (GLfloat)(360.0f - angle);
- /* Calculate the center of rotation */
- translate[0] = translate[2] = translate[4] = translate[6] = (center->x + dstrect->x);
- translate[1] = translate[3] = translate[5] = translate[7] = (center->y + dstrect->y);
-
- /* Emit the textured quad */
- vertices[0] = dstrect->x;
- vertices[1] = dstrect->y;
- vertices[2] = (dstrect->x + dstrect->w);
- vertices[3] = dstrect->y;
- vertices[4] = dstrect->x;
- vertices[5] = (dstrect->y + dstrect->h);
- vertices[6] = (dstrect->x + dstrect->w);
- vertices[7] = (dstrect->y + dstrect->h);
- if (flip & SDL_FLIP_HORIZONTAL) {
- tmp = vertices[0];
- vertices[0] = vertices[4] = vertices[2];
- vertices[2] = vertices[6] = tmp;
- }
- if (flip & SDL_FLIP_VERTICAL) {
- tmp = vertices[1];
- vertices[1] = vertices[3] = vertices[5];
- vertices[5] = vertices[7] = tmp;
- }
-
- /*data->glVertexAttribPointer(GLES2_ATTRIBUTE_ANGLE, 1, GL_FLOAT, GL_FALSE, 0, &fAngle);
- data->glVertexAttribPointer(GLES2_ATTRIBUTE_CENTER, 2, GL_FLOAT, GL_FALSE, 0, translate);
- data->glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);*/
-
- GLES2_UpdateVertexBuffer(renderer, GLES2_ATTRIBUTE_ANGLE, fAngle, 4 * sizeof(GLfloat));
- GLES2_UpdateVertexBuffer(renderer, GLES2_ATTRIBUTE_CENTER, translate, 8 * sizeof(GLfloat));
- GLES2_UpdateVertexBuffer(renderer, GLES2_ATTRIBUTE_POSITION, vertices, 8 * sizeof(GLfloat));
-
- texCoords[0] = srcrect->x / (GLfloat)texture->w;
- texCoords[1] = srcrect->y / (GLfloat)texture->h;
- texCoords[2] = (srcrect->x + srcrect->w) / (GLfloat)texture->w;
- texCoords[3] = srcrect->y / (GLfloat)texture->h;
- texCoords[4] = srcrect->x / (GLfloat)texture->w;
- texCoords[5] = (srcrect->y + srcrect->h) / (GLfloat)texture->h;
- texCoords[6] = (srcrect->x + srcrect->w) / (GLfloat)texture->w;
- texCoords[7] = (srcrect->y + srcrect->h) / (GLfloat)texture->h;
- /*data->glVertexAttribPointer(GLES2_ATTRIBUTE_TEXCOORD, 2, GL_FLOAT, GL_FALSE, 0, texCoords);*/
- GLES2_UpdateVertexBuffer(renderer, GLES2_ATTRIBUTE_TEXCOORD, texCoords, 8 * sizeof(GLfloat));
- data->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
- data->glDisableVertexAttribArray(GLES2_ATTRIBUTE_CENTER);
- data->glDisableVertexAttribArray(GLES2_ATTRIBUTE_ANGLE);
-
- return GL_CheckError("", renderer);
-}
-
-static int
-GLES2_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
- Uint32 pixel_format, void * pixels, int pitch)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
- Uint32 temp_format = renderer->target ? renderer->target->format : SDL_PIXELFORMAT_ABGR8888;
- void *temp_pixels;
- int temp_pitch;
- Uint8 *src, *dst, *tmp;
- int w, h, length, rows;
- int status;
-
- GLES2_ActivateRenderer(renderer);
-
- temp_pitch = rect->w * SDL_BYTESPERPIXEL(temp_format);
- temp_pixels = SDL_malloc(rect->h * temp_pitch);
- if (!temp_pixels) {
- return SDL_OutOfMemory();
- }
-
- SDL_GetRendererOutputSize(renderer, &w, &h);
-
- data->glReadPixels(rect->x, renderer->target ? rect->y : (h-rect->y)-rect->h,
- rect->w, rect->h, GL_RGBA, GL_UNSIGNED_BYTE, temp_pixels);
- if (GL_CheckError("glReadPixels()", renderer) < 0) {
- return -1;
- }
-
- /* Flip the rows to be top-down if necessary */
- if (!renderer->target) {
- length = rect->w * SDL_BYTESPERPIXEL(temp_format);
- src = (Uint8*)temp_pixels + (rect->h-1)*temp_pitch;
- dst = (Uint8*)temp_pixels;
- tmp = SDL_stack_alloc(Uint8, length);
- rows = rect->h / 2;
- while (rows--) {
- SDL_memcpy(tmp, dst, length);
- SDL_memcpy(dst, src, length);
- SDL_memcpy(src, tmp, length);
- dst += temp_pitch;
- src -= temp_pitch;
- }
- SDL_stack_free(tmp);
- }
-
- status = SDL_ConvertPixels(rect->w, rect->h,
- temp_format, temp_pixels, temp_pitch,
- pixel_format, pixels, pitch);
- SDL_free(temp_pixels);
-
- return status;
-}
-
-static void
-GLES2_RenderPresent(SDL_Renderer *renderer)
-{
- GLES2_ActivateRenderer(renderer);
-
- /* Tell the video driver to swap buffers */
- SDL_GL_SwapWindow(renderer->window);
-}
-
-
-/*************************************************************************************************
- * Bind/unbinding of textures
- *************************************************************************************************/
-static int GLES2_BindTexture (SDL_Renderer * renderer, SDL_Texture *texture, float *texw, float *texh);
-static int GLES2_UnbindTexture (SDL_Renderer * renderer, SDL_Texture *texture);
-
-static int GLES2_BindTexture (SDL_Renderer * renderer, SDL_Texture *texture, float *texw, float *texh)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
- GLES2_TextureData *texturedata = (GLES2_TextureData *)texture->driverdata;
- GLES2_ActivateRenderer(renderer);
-
- data->glBindTexture(texturedata->texture_type, texturedata->texture);
-
- if (texw) {
- *texw = 1.0;
- }
- if (texh) {
- *texh = 1.0;
- }
-
- return 0;
-}
-
-static int GLES2_UnbindTexture (SDL_Renderer * renderer, SDL_Texture *texture)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata;
- GLES2_TextureData *texturedata = (GLES2_TextureData *)texture->driverdata;
- GLES2_ActivateRenderer(renderer);
-
- data->glBindTexture(texturedata->texture_type, 0);
-
- return 0;
-}
-
-
-/*************************************************************************************************
- * Renderer instantiation *
- *************************************************************************************************/
-
-#define GL_NVIDIA_PLATFORM_BINARY_NV 0x890B
-
-static void
-GLES2_ResetState(SDL_Renderer *renderer)
-{
- GLES2_DriverContext *data = (GLES2_DriverContext *) renderer->driverdata;
-
- if (SDL_CurrentContext == data->context) {
- GLES2_UpdateViewport(renderer);
- } else {
- GLES2_ActivateRenderer(renderer);
- }
-
- data->current.blendMode = -1;
- data->current.tex_coords = SDL_FALSE;
-
- data->glActiveTexture(GL_TEXTURE0);
- data->glPixelStorei(GL_PACK_ALIGNMENT, 1);
- data->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-
- data->glClearColor((GLfloat) data->clear_r * inv255f,
- (GLfloat) data->clear_g * inv255f,
- (GLfloat) data->clear_b * inv255f,
- (GLfloat) data->clear_a * inv255f);
-
- data->glEnableVertexAttribArray(GLES2_ATTRIBUTE_POSITION);
- data->glDisableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD);
-
- GL_CheckError("", renderer);
-}
-
-static SDL_Renderer *
-GLES2_CreateRenderer(SDL_Window *window, Uint32 flags)
-{
- SDL_Renderer *renderer;
- GLES2_DriverContext *data;
- GLint nFormats;
-#ifndef ZUNE_HD
- GLboolean hasCompiler;
-#endif
- Uint32 window_flags;
- GLint window_framebuffer;
- GLint value;
- int profile_mask = 0, major = 0, minor = 0;
- SDL_bool changed_window = SDL_FALSE;
-
- if (SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &profile_mask) < 0) {
- goto error;
- }
- if (SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &major) < 0) {
- goto error;
- }
- if (SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &minor) < 0) {
- goto error;
- }
-
- window_flags = SDL_GetWindowFlags(window);
- if (!(window_flags & SDL_WINDOW_OPENGL) ||
- profile_mask != SDL_GL_CONTEXT_PROFILE_ES || major != RENDERER_CONTEXT_MAJOR || minor != RENDERER_CONTEXT_MINOR) {
-
- changed_window = SDL_TRUE;
- SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
- SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, RENDERER_CONTEXT_MAJOR);
- SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, RENDERER_CONTEXT_MINOR);
-
- if (SDL_RecreateWindow(window, window_flags | SDL_WINDOW_OPENGL) < 0) {
- goto error;
- }
- }
-
- /* Create the renderer struct */
- renderer = (SDL_Renderer *)SDL_calloc(1, sizeof(SDL_Renderer));
- if (!renderer) {
- SDL_OutOfMemory();
- goto error;
- }
-
- data = (GLES2_DriverContext *)SDL_calloc(1, sizeof(GLES2_DriverContext));
- if (!data) {
- GLES2_DestroyRenderer(renderer);
- SDL_OutOfMemory();
- goto error;
- }
- renderer->info = GLES2_RenderDriver.info;
- renderer->info.flags = (SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE);
- renderer->driverdata = data;
- renderer->window = window;
-
- /* Create an OpenGL ES 2.0 context */
- data->context = SDL_GL_CreateContext(window);
- if (!data->context) {
- GLES2_DestroyRenderer(renderer);
- goto error;
- }
- if (SDL_GL_MakeCurrent(window, data->context) < 0) {
- GLES2_DestroyRenderer(renderer);
- goto error;
- }
-
- if (GLES2_LoadFunctions(data) < 0) {
- GLES2_DestroyRenderer(renderer);
- goto error;
- }
-
-#if __WINRT__
- /* DLudwig, 2013-11-29: ANGLE for WinRT doesn't seem to work unless VSync
- * is turned on. Not doing so will freeze the screen's contents to that
- * of the first drawn frame.
- */
- flags |= SDL_RENDERER_PRESENTVSYNC;
-#endif
-
- if (flags & SDL_RENDERER_PRESENTVSYNC) {
- SDL_GL_SetSwapInterval(1);
- } else {
- SDL_GL_SetSwapInterval(0);
- }
- if (SDL_GL_GetSwapInterval() > 0) {
- renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
- }
-
- /* Check for debug output support */
- if (SDL_GL_GetAttribute(SDL_GL_CONTEXT_FLAGS, &value) == 0 &&
- (value & SDL_GL_CONTEXT_DEBUG_FLAG)) {
- data->debug_enabled = SDL_TRUE;
- }
-
- value = 0;
- data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
- renderer->info.max_texture_width = value;
- value = 0;
- data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
- renderer->info.max_texture_height = value;
-
- /* Determine supported shader formats */
- /* HACK: glGetInteger is broken on the Zune HD's compositor, so we just hardcode this */
-#ifdef ZUNE_HD
- nFormats = 1;
-#else /* !ZUNE_HD */
- data->glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &nFormats);
- data->glGetBooleanv(GL_SHADER_COMPILER, &hasCompiler);
- if (hasCompiler) {
- ++nFormats;
- }
-#endif /* ZUNE_HD */
- data->shader_formats = (GLenum *)SDL_calloc(nFormats, sizeof(GLenum));
- if (!data->shader_formats) {
- GLES2_DestroyRenderer(renderer);
- SDL_OutOfMemory();
- goto error;
- }
- data->shader_format_count = nFormats;
-#ifdef ZUNE_HD
- data->shader_formats[0] = GL_NVIDIA_PLATFORM_BINARY_NV;
-#else /* !ZUNE_HD */
- data->glGetIntegerv(GL_SHADER_BINARY_FORMATS, (GLint *)data->shader_formats);
- if (hasCompiler) {
- data->shader_formats[nFormats - 1] = (GLenum)-1;
- }
-#endif /* ZUNE_HD */
-
- data->framebuffers = NULL;
- data->glGetIntegerv(GL_FRAMEBUFFER_BINDING, &window_framebuffer);
- data->window_framebuffer = (GLuint)window_framebuffer;
-
- /* Populate the function pointers for the module */
- renderer->WindowEvent = &GLES2_WindowEvent;
- renderer->GetOutputSize = &GLES2_GetOutputSize;
- renderer->CreateTexture = &GLES2_CreateTexture;
- renderer->UpdateTexture = &GLES2_UpdateTexture;
- renderer->UpdateTextureYUV = &GLES2_UpdateTextureYUV;
- renderer->LockTexture = &GLES2_LockTexture;
- renderer->UnlockTexture = &GLES2_UnlockTexture;
- renderer->SetRenderTarget = &GLES2_SetRenderTarget;
- renderer->UpdateViewport = &GLES2_UpdateViewport;
- renderer->UpdateClipRect = &GLES2_UpdateClipRect;
- renderer->RenderClear = &GLES2_RenderClear;
- renderer->RenderDrawPoints = &GLES2_RenderDrawPoints;
- renderer->RenderDrawLines = &GLES2_RenderDrawLines;
- renderer->RenderFillRects = &GLES2_RenderFillRects;
- renderer->RenderCopy = &GLES2_RenderCopy;
- renderer->RenderCopyEx = &GLES2_RenderCopyEx;
- renderer->RenderReadPixels = &GLES2_RenderReadPixels;
- renderer->RenderPresent = &GLES2_RenderPresent;
- renderer->DestroyTexture = &GLES2_DestroyTexture;
- renderer->DestroyRenderer = &GLES2_DestroyRenderer;
- renderer->GL_BindTexture = &GLES2_BindTexture;
- renderer->GL_UnbindTexture = &GLES2_UnbindTexture;
-
- renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_YV12;
- renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_IYUV;
- renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_NV12;
- renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_NV21;
-
- GLES2_ResetState(renderer);
-
- return renderer;
-
-error:
- if (changed_window) {
- /* Uh oh, better try to put it back... */
- SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, profile_mask);
- SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, major);
- SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, minor);
- SDL_RecreateWindow(window, window_flags);
- }
- return NULL;
-}
-
-#endif /* SDL_VIDEO_RENDER_OGL_ES2 && !SDL_RENDER_DISABLED */
-
-/* vi: set ts=4 sw=4 expandtab: */