From c20a858da53f39307176e61463d96e14e40ce5ff Mon Sep 17 00:00:00 2001 From: "Ryan C. Gordon" Date: Fri, 28 Sep 2018 19:47:44 -0400 Subject: [PATCH] render: moved opengles2 over to new interface. --- src/render/SDL_render.c | 2 + src/render/opengles2/SDL_render_gles2.c | 2795 ++++++++++------------- 2 files changed, 1236 insertions(+), 1561 deletions(-) diff --git a/src/render/SDL_render.c b/src/render/SDL_render.c index 17348b312d107..9a8c2f7f642b4 100644 --- a/src/render/SDL_render.c +++ b/src/render/SDL_render.c @@ -497,6 +497,7 @@ PrepQueueCmdDraw(SDL_Renderer *renderer, const Uint8 r, const Uint8 g, const Uin static SDL_RenderCommand * PrepQueueCmdDrawSolid(SDL_Renderer *renderer, const SDL_RenderCommandType cmdtype) { + /* !!! FIXME: drop this draw if viewport w or h is zero. */ SDL_RenderCommand *cmd = NULL; if (PrepQueueCmdDraw(renderer, renderer->r, renderer->g, renderer->b, renderer->a) == 0) { cmd = AllocateRenderCommand(renderer); @@ -560,6 +561,7 @@ QueueCmdFillRects(SDL_Renderer *renderer, const SDL_FRect * rects, const int cou static SDL_RenderCommand * PrepQueueCmdDrawTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_RenderCommandType cmdtype) { + /* !!! FIXME: drop this draw if viewport w or h is zero. */ SDL_RenderCommand *cmd = NULL; if (PrepQueueCmdDraw(renderer, texture->r, texture->g, texture->b, texture->a) == 0) { cmd = AllocateRenderCommand(renderer); diff --git a/src/render/opengles2/SDL_render_gles2.c b/src/render/opengles2/SDL_render_gles2.c index 282f4baa8c063..052a27758e282 100644 --- a/src/render/opengles2/SDL_render_gles2.c +++ b/src/render/opengles2/SDL_render_gles2.c @@ -38,29 +38,6 @@ /* 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 * *************************************************************************************************/ @@ -88,7 +65,6 @@ typedef struct GLES2_TextureData GLenum texture_v; GLenum texture_u; GLES2_FBOList *fbo; - Uint32 last_cmd_generation; /* last command queue generation this texture was in. */ } GLES2_TextureData; typedef struct GLES2_ShaderCacheEntry @@ -97,7 +73,6 @@ typedef struct GLES2_ShaderCacheEntry 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; @@ -114,8 +89,7 @@ typedef struct GLES2_ProgramCacheEntry 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; + Uint32 color; GLfloat projection[4][4]; struct GLES2_ProgramCacheEntry *prev; struct GLES2_ProgramCacheEntry *next; @@ -159,47 +133,22 @@ typedef enum GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES } GLES2_ImageSource; -typedef enum +typedef struct { - GLES2_RENDERCMD_VIEWPORT, - GLES2_RENDERCMD_CLIPRECT, - GLES2_RENDERCMD_CLEAR, - GLES2_RENDERCMD_ATTR, - GLES2_RENDERCMD_DRAW -} GLES2_RenderCommandType; - -typedef struct GLES2_RenderCommand -{ - GLES2_RenderCommandType cmd; - union { - SDL_Rect viewport; - struct { - SDL_bool enabled; - SDL_Rect rect; - } cliprect; - struct { - Uint8 r, g, b, a; - } clear; - struct { - GLES2_Attribute attr; - GLsizei offset; - GLsizei count; - } attr; - struct { - GLenum mode; - GLint first; - GLsizei count; - Uint8 attrs; - Uint8 r, g, b, a; - SDL_BlendMode blend; - GLES2_ImageSource imgsrc; - SDL_Texture *texture; - } draw; - } data; - struct GLES2_RenderCommand *next; -} GLES2_RenderCommand; - -typedef struct GLES2_DriverContext + SDL_Rect viewport; + SDL_Texture *texture; + SDL_BlendMode blend; + SDL_bool cliprect_enabled; + SDL_Rect cliprect; + SDL_bool texturing; + SDL_bool is_copy_ex; + Uint32 color; + Uint32 clear_color; + GLES2_ProgramCacheEntry *program; + GLfloat projection[4][4]; +} GLES2_DrawStateCache; + +typedef struct GLES2_RenderData { SDL_GLContext *context; @@ -215,65 +164,18 @@ typedef struct GLES2_DriverContext GLenum *shader_formats; GLES2_ShaderCache shader_cache; GLES2_ProgramCache program_cache; - GLES2_ProgramCacheEntry *current_program; Uint8 clear_r, clear_g, clear_b, clear_a; - GLuint vertex_buffers[4]; - GLsizeiptr vertex_buffer_size[4]; + GLuint vertex_buffers[8]; + GLsizeiptr vertex_buffer_size[8]; int current_vertex_buffer; - GLES2_RenderCommand *render_commands; - GLES2_RenderCommand *render_commands_tail; - GLES2_RenderCommand *render_commands_pool; - int current_vertex_data; - Uint32 command_generation; - GLfloat *vertex_data; - GLsizeiptr vertex_data_allocation; -} GLES2_DriverContext; + GLES2_DrawStateCache drawstate; +} GLES2_RenderData; #define GLES2_MAX_CACHED_PROGRAMS 8 static const float inv255f = 1.0f / 255.0f; -static GLES2_RenderCommand * -GLES2_AllocateRenderCommand(SDL_Renderer *renderer) -{ - GLES2_DriverContext *data = (GLES2_DriverContext *) renderer->driverdata; - GLES2_RenderCommand *retval = NULL; - - /* !!! FIXME: are there threading limitations in SDL's render API? */ - retval = data->render_commands_pool; - if (retval != NULL) { - data->render_commands_pool = retval->next; - retval->next = NULL; - } else { - retval = SDL_calloc(1, sizeof (*retval)); - if (!retval) { - SDL_OutOfMemory(); - return NULL; - } - } - - SDL_assert((data->render_commands == NULL) == (data->render_commands_tail == NULL)); - if (data->render_commands_tail != NULL) { - data->render_commands_tail->next = retval; - } else { - data->render_commands = retval; - } - data->render_commands_tail = retval; - - return retval; -} - -static SDL_bool -CompareColors(const Uint8 r1, const Uint8 g1, const Uint8 b1, const Uint8 a1, - const Uint8 r2, const Uint8 g2, const Uint8 b2, const Uint8 a2) -{ - Uint32 Pixel1, Pixel2; - RGBA8888_FROM_RGBA(Pixel1, r1, g1, b1, a1); - RGBA8888_FROM_RGBA(Pixel2, r2, g2, b2, a2); - return (Pixel1 == Pixel2); -} - SDL_FORCE_INLINE const char* GL_TranslateError (GLenum error) @@ -294,7 +196,7 @@ GL_TranslateError (GLenum error) SDL_FORCE_INLINE void GL_ClearErrors(SDL_Renderer *renderer) { - GLES2_DriverContext *data = (GLES2_DriverContext *) renderer->driverdata; + GLES2_RenderData *data = (GLES2_RenderData *) renderer->driverdata; if (!data->debug_enabled) { return; @@ -307,7 +209,7 @@ GL_ClearErrors(SDL_Renderer *renderer) 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; + GLES2_RenderData *data = (GLES2_RenderData *) renderer->driverdata; int ret = 0; if (!data->debug_enabled) { @@ -340,16 +242,7 @@ GL_CheckAllErrors (const char *prefix, SDL_Renderer *renderer, const char *file, * 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 SDL_GLContext SDL_CurrentContext = NULL; - -static int GLES2_LoadFunctions(GLES2_DriverContext * data) +static int GLES2_LoadFunctions(GLES2_RenderData * data) { #if SDL_VIDEO_DRIVER_UIKIT #define __SDL_NOGETPROCADDR__ @@ -377,7 +270,7 @@ static int GLES2_LoadFunctions(GLES2_DriverContext * data) } static GLES2_FBOList * -GLES2_GetFBO(GLES2_DriverContext *data, Uint32 w, Uint32 h) +GLES2_GetFBO(GLES2_RenderData *data, Uint32 w, Uint32 h) { GLES2_FBOList *result = data->framebuffers; while ((result) && ((result->w != w) || (result->h != h)) ) { @@ -397,18 +290,15 @@ GLES2_GetFBO(GLES2_DriverContext *data, Uint32 w, Uint32 h) static int GLES2_ActivateRenderer(SDL_Renderer * renderer) { - GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata; + GLES2_RenderData *data = (GLES2_RenderData *)renderer->driverdata; - if (SDL_CurrentContext != data->context) { + if (SDL_GL_GetCurrentContext() != data->context) { /* Null out the current program to ensure we set it again */ - data->current_program = NULL; + data->drawstate.program = NULL; if (SDL_GL_MakeCurrent(renderer->window, data->context) < 0) { return -1; } - SDL_CurrentContext = data->context; - - GLES2_UpdateViewport(renderer); } GL_ClearErrors(renderer); @@ -419,14 +309,7 @@ GLES2_ActivateRenderer(SDL_Renderer * renderer) 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; - } + GLES2_RenderData *data = (GLES2_RenderData *)renderer->driverdata; if (event->event == SDL_WINDOWEVENT_MINIMIZED) { /* According to Apple documentation, we need to finish drawing NOW! */ @@ -504,1582 +387,1379 @@ GLES2_SupportsBlendMode(SDL_Renderer * renderer, SDL_BlendMode blendMode) return SDL_TRUE; } -static int GLES2_SelectProgram(SDL_Renderer *renderer, GLES2_ImageSource source, int w, int h); -static int -GLES2_FlushCommands(SDL_Renderer *renderer) +static void +GLES2_EvictShader(GLES2_RenderData *data, GLES2_ShaderCacheEntry *entry) { - GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata; - const SDL_bool colorswap = (renderer->target && (renderer->target->format == SDL_PIXELFORMAT_ARGB8888 || renderer->target->format == SDL_PIXELFORMAT_RGB888)); - const int vboidx = data->current_vertex_buffer; - const GLuint vbo = data->vertex_buffers[vboidx]; - const GLsizeiptr dataSizeInBytes = data->current_vertex_data * sizeof (float); - Uint8 enabled_attrs = (1 << GLES2_ATTRIBUTE_POSITION); - GLES2_RenderCommand *cmd; - GLES2_RenderCommand *next; - SDL_Rect viewport; - SDL_Texture *bound_texture = NULL; - SDL_BlendMode blend = SDL_BLENDMODE_INVALID; - Uint8 clear_r, clear_g, clear_b, clear_a; - int drawablew = 0, drawableh = 0; - GLfloat projection[4][4]; - SDL_bool cliprect_enabled = SDL_FALSE; - SDL_Rect cliprect; - - GLES2_ActivateRenderer(renderer); - - if (data->render_commands == NULL) { /* nothing to do! */ - SDL_assert(data->current_vertex_data == 0); - return 0; - } - - /* cycle through a few VBOs so the GL has some time with the data before we replace it. */ - data->current_vertex_buffer++; - if (data->current_vertex_buffer >= SDL_arraysize(data->vertex_buffers)) { - data->current_vertex_buffer = 0; - } - data->current_vertex_data = 0; /* start next VBO at start. */ - cmd = data->render_commands; - data->render_commands = NULL; - data->render_commands_tail = NULL; - - SDL_zero(projection); - projection[3][0] = -1.0f; - projection[3][1] = renderer->target ? -1.0f : 1.0f; - projection[3][3] = 1.0f; - - if (!renderer->target) { - SDL_GL_GetDrawableSize(renderer->window, &drawablew, &drawableh); - } - - /* upload the new VBO data for this set of commands. */ - data->glBindBuffer(GL_ARRAY_BUFFER, vbo); - if (data->vertex_buffer_size[vboidx] < dataSizeInBytes) { - data->glBufferData(GL_ARRAY_BUFFER, dataSizeInBytes, data->vertex_data, GL_STREAM_DRAW); - data->vertex_buffer_size[vboidx] = dataSizeInBytes; - } else { - data->glBufferSubData(GL_ARRAY_BUFFER, 0, dataSizeInBytes, data->vertex_data); + /* Unlink the shader from the cache */ + if (entry->next) { + entry->next->prev = entry->prev; } - - data->glEnableVertexAttribArray(GLES2_ATTRIBUTE_POSITION); - data->glDisableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD); - data->glDisableVertexAttribArray(GLES2_ATTRIBUTE_ANGLE); - data->glDisableVertexAttribArray(GLES2_ATTRIBUTE_CENTER); - - clear_r = renderer->r; - clear_g = renderer->g; - clear_b = renderer->b; - clear_a = renderer->a; - data->glClearColor(clear_r * inv255f, clear_g * inv255f, clear_b * inv255f, clear_a * inv255f); - - SDL_memcpy(&viewport, &renderer->viewport, sizeof (viewport)); - data->glViewport(viewport.x, - (renderer->target) ? viewport.y : (drawableh - viewport.y - viewport.h), - viewport.w, viewport.h); - - SDL_memcpy(&cliprect, &renderer->clip_rect, sizeof (cliprect)); - cliprect_enabled = renderer->clipping_enabled; - if (cliprect_enabled) { - data->glEnable(GL_SCISSOR_TEST); - } else { - data->glDisable(GL_SCISSOR_TEST); + if (entry->prev) { + entry->prev->next = entry->next; } - if (renderer->target) { - data->glScissor(viewport.x + cliprect.x, viewport.y + cliprect.y, cliprect.w, cliprect.h); - } else { - data->glScissor(viewport.x + cliprect.x, drawableh - viewport.y - cliprect.y - cliprect.h, cliprect.w, cliprect.h); + if (data->shader_cache.head == entry) { + data->shader_cache.head = entry->next; } + --data->shader_cache.count; - while (cmd != NULL) { - switch (cmd->cmd) { - case GLES2_RENDERCMD_VIEWPORT: - if (SDL_memcmp(&cmd->data.viewport, &viewport, sizeof (SDL_Rect)) != 0) { - SDL_memcpy(&viewport, &cmd->data.viewport, sizeof (SDL_Rect)); - data->glViewport(viewport.x, - (renderer->target) ? viewport.y : (drawableh - viewport.y - viewport.h), - viewport.w, viewport.h); - } - break; + /* Deallocate the shader */ + data->glDeleteShader(entry->id); + SDL_free(entry); +} - case GLES2_RENDERCMD_CLIPRECT: { - const SDL_Rect *rect = &cmd->data.cliprect.rect; - const SDL_bool changed = (SDL_memcmp(&cliprect, rect, sizeof (SDL_Rect)) != 0); - if (cliprect_enabled != cmd->data.cliprect.enabled) { - cliprect_enabled = cmd->data.cliprect.enabled; - if (cliprect_enabled) { - data->glEnable(GL_SCISSOR_TEST); - } else { - data->glDisable(GL_SCISSOR_TEST); - } - } +static GLES2_ProgramCacheEntry * +GLES2_CacheProgram(GLES2_RenderData *data, GLES2_ShaderCacheEntry *vertex, + GLES2_ShaderCacheEntry *fragment) +{ + GLES2_ProgramCacheEntry *entry; + GLES2_ShaderCacheEntry *shaderEntry; + GLint linkSuccessful; - if (cliprect_enabled && changed) { - SDL_memcpy(&cliprect, rect, sizeof (SDL_Rect)); - if (renderer->target) { - data->glScissor(viewport.x + rect->x, viewport.y + rect->y, rect->w, rect->h); - } else { - data->glScissor(viewport.x + rect->x, drawableh - viewport.y - rect->y - rect->h, rect->w, rect->h); - } - } - break; + /* 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; } - - case GLES2_RENDERCMD_CLEAR: - if (!CompareColors(clear_r, clear_g, clear_b, clear_a, cmd->data.clear.r, cmd->data.clear.g, cmd->data.clear.b, cmd->data.clear.a)) { - GLfloat r, g, b, a; - - clear_r = cmd->data.clear.r; - clear_g = cmd->data.clear.g; - clear_b = cmd->data.clear.b; - clear_a = cmd->data.clear.a; - - r = ((GLfloat) (colorswap ? clear_b : clear_r)) * inv255f; - g = ((GLfloat) clear_g) * inv255f; - b = ((GLfloat) (colorswap ? clear_r : clear_b)) * inv255f; - a = ((GLfloat) clear_a) * inv255f; - - data->glClearColor(r, g, b, a); - } - - if (cliprect_enabled) { - data->glDisable(GL_SCISSOR_TEST); - } - - data->glClear(GL_COLOR_BUFFER_BIT); - - if (cliprect_enabled) { - data->glEnable(GL_SCISSOR_TEST); - } - break; - - case GLES2_RENDERCMD_ATTR: - data->glVertexAttribPointer(cmd->data.attr.attr, 2, GL_FLOAT, GL_FALSE, 0, (const GLvoid *) cmd->data.attr.offset); - break; - - case GLES2_RENDERCMD_DRAW: { - const SDL_bool iscopy = (cmd->data.draw.imgsrc != GLES2_IMAGESOURCE_SOLID); - if (!viewport.w || !viewport.h) { - break; /* nothing to draw to. */ - } - - if (iscopy && (bound_texture != cmd->data.draw.texture)) { - GLES2_TextureData *tdata = (GLES2_TextureData *)cmd->data.draw.texture->driverdata; - 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); - bound_texture = cmd->data.draw.texture; - } - - if (GLES2_SelectProgram(renderer, cmd->data.draw.imgsrc, iscopy ? bound_texture->w : 0, iscopy ? bound_texture->h : 0) == 0) { - GLES2_ProgramCacheEntry *program = data->current_program; - - if (enabled_attrs != cmd->data.draw.attrs) { - const Uint8 xored = enabled_attrs ^ cmd->data.draw.attrs; - int attr; - for (attr = 0; attr < GLES2_ATTRIBUTE_CENTER; attr++) { - if ((xored & (1 << attr)) != 0) { /* if changed */ - if (cmd->data.draw.attrs & (1 << attr)) { - data->glEnableVertexAttribArray((GLenum) attr); - } else { - data->glDisableVertexAttribArray((GLenum) attr); - } - } - } - enabled_attrs = cmd->data.draw.attrs; - } - - if (blend != cmd->data.draw.blend) { - const SDL_BlendMode bm = cmd->data.draw.blend; - if (bm == SDL_BLENDMODE_NONE) { - data->glDisable(GL_BLEND); - } else { - data->glEnable(GL_BLEND); - data->glBlendFuncSeparate(GetBlendFunc(SDL_GetBlendModeSrcColorFactor(bm)), - GetBlendFunc(SDL_GetBlendModeDstColorFactor(bm)), - GetBlendFunc(SDL_GetBlendModeSrcAlphaFactor(bm)), - GetBlendFunc(SDL_GetBlendModeDstAlphaFactor(bm))); - data->glBlendEquationSeparate(GetBlendEquation(SDL_GetBlendModeColorOperation(bm)), - GetBlendEquation(SDL_GetBlendModeAlphaOperation(bm))); - } - blend = bm; - } - - if (program->uniform_locations[GLES2_UNIFORM_PROJECTION] != -1) { - projection[0][0] = 2.0f / viewport.w; - projection[1][1] = (renderer->target ? 2.0f : -2.0f) / viewport.h; - if (SDL_memcmp(program->projection, projection, sizeof (projection)) != 0) { - data->glUniformMatrix4fv(program->uniform_locations[GLES2_UNIFORM_PROJECTION], 1, GL_FALSE, (GLfloat *)projection); - SDL_memcpy(program->projection, projection, sizeof (projection)); - } - } - - if (program->uniform_locations[GLES2_UNIFORM_COLOR] != -1) { - const Uint8 r = colorswap ? cmd->data.draw.b : cmd->data.draw.r; - const Uint8 g = cmd->data.draw.g; - const Uint8 b = colorswap ? cmd->data.draw.r : cmd->data.draw.b; - const Uint8 a = cmd->data.draw.a; - if (!CompareColors(program->color_r, program->color_g, program->color_b, program->color_a, r, g, b, a)) { - 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; - } - } - - data->glDrawArrays(cmd->data.draw.mode, cmd->data.draw.first, cmd->data.draw.count); - } - break; + if (entry->prev) { + entry->prev->next = entry->next; } - - default: SDL_assert(!"Unknown rendering command"); break; + 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; - /* put this command in the pool for reuse, move on to next one. */ - next = cmd->next; - cmd->next = data->render_commands_pool; - data->render_commands_pool = cmd; - cmd = next; + /* 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; } - data->command_generation++; + /* 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_COLOR] = + data->glGetUniformLocation(entry->id, "u_color"); - return GL_CheckError("", renderer); -} + entry->color = 0; -static void -GLES2_FlushCommandsIfTextureNeeded(SDL_Renderer *renderer, SDL_Texture *texture) -{ - GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata; - GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata; - if (tdata->last_cmd_generation == data->command_generation) { - /* the current command queue depends on this texture, flush the queue now before it changes */ - GLES2_FlushCommands(renderer); + data->glUseProgram(entry->id); + if (entry->uniform_locations[GLES2_UNIFORM_TEXTURE_V] != -1) { + data->glUniform1i(entry->uniform_locations[GLES2_UNIFORM_TEXTURE_V], 2); /* always texture unit 2. */ } -} - -static int -GLES2_UpdateViewport(SDL_Renderer * renderer) -{ - GLES2_RenderCommand *cmd = GLES2_AllocateRenderCommand(renderer); - if (cmd == NULL) { - return -1; + if (entry->uniform_locations[GLES2_UNIFORM_TEXTURE_U] != -1) { + data->glUniform1i(entry->uniform_locations[GLES2_UNIFORM_TEXTURE_U], 1); /* always texture unit 1. */ + } + if (entry->uniform_locations[GLES2_UNIFORM_TEXTURE] != -1) { + data->glUniform1i(entry->uniform_locations[GLES2_UNIFORM_TEXTURE], 0); /* always texture unit 0. */ + } + if (entry->uniform_locations[GLES2_UNIFORM_PROJECTION] != -1) { + data->glUniformMatrix4fv(entry->uniform_locations[GLES2_UNIFORM_PROJECTION], 1, GL_FALSE, (GLfloat *)entry->projection); + } + if (entry->uniform_locations[GLES2_UNIFORM_COLOR] != -1) { + data->glUniform4f(entry->uniform_locations[GLES2_UNIFORM_COLOR], 0.0f, 0.0f, 0.0f, 0.0f); } - cmd->cmd = GLES2_RENDERCMD_VIEWPORT; - SDL_memcpy(&cmd->data.viewport, &renderer->viewport, sizeof (SDL_Rect)); - return 0; -} -static int -GLES2_UpdateClipRect(SDL_Renderer * renderer) -{ - GLES2_RenderCommand *cmd = GLES2_AllocateRenderCommand(renderer); - if (cmd == NULL) { - return -1; + /* 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; } - cmd->cmd = GLES2_RENDERCMD_CLIPRECT; - cmd->data.cliprect.enabled = renderer->clipping_enabled; - SDL_memcpy(&cmd->data.cliprect.rect, &renderer->clip_rect, sizeof (SDL_Rect)); - return 0; -} + data->program_cache.head = entry; + ++data->program_cache.count; -static void -GLES2_DestroyRenderer(SDL_Renderer *renderer) -{ - GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata; + /* Increment the refcount of the shaders we're using */ + ++vertex->references; + ++fragment->references; - /* Deallocate everything */ - if (data) { - GLES2_RenderCommand *cmd; - - GLES2_ActivateRenderer(renderer); - - if (data->render_commands_tail != NULL) { - data->render_commands_tail->next = data->render_commands_pool; - } else { - data->render_commands = data->render_commands_pool; + /* 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(data, shaderEntry); } - - cmd = data->render_commands; - while (cmd != NULL) { - GLES2_RenderCommand *next = cmd->next; - SDL_free(cmd); - cmd = next; + shaderEntry = data->program_cache.tail->fragment_shader; + if (--shaderEntry->references <= 0) { + GLES2_EvictShader(data, 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; +} - SDL_free(data->vertex_data); +static GLES2_ShaderCacheEntry * +GLES2_CacheShader(GLES2_RenderData *data, GLES2_ShaderType type) +{ + const GLES2_Shader *shader; + const GLES2_ShaderInstance *instance = NULL; + GLES2_ShaderCacheEntry *entry = NULL; + GLint compileSuccessful = GL_FALSE; + int i, j; - { - 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; + /* Find the corresponding shader */ + shader = GLES2_GetShader(type); + 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; } - } - { - 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 (shader->instances[i]->format != data->shader_formats[j]) { + continue; } + instance = shader->instances[i]; } - 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; - } - - data->glDeleteBuffers(SDL_arraysize(data->vertex_buffers), data->vertex_buffers); - GL_CheckError("", renderer); + } + if (!instance) { + SDL_SetError("The specified shader cannot be loaded on the current platform"); + return NULL; + } - SDL_GL_DeleteContext(data->context); + /* 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; + } - SDL_free(data->shader_formats); - SDL_free(data); + /* Create a shader cache entry */ + entry = (GLES2_ShaderCacheEntry *)SDL_calloc(1, sizeof(GLES2_ShaderCacheEntry)); + if (!entry) { + SDL_OutOfMemory(); + return NULL; } - SDL_free(renderer); -} + entry->type = type; + entry->instance = instance; -/************************************************************************************************* - * Texture APIs * - *************************************************************************************************/ + /* 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 **)(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; + } -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); + /* 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 int -GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture) +GLES2_SelectProgram(GLES2_RenderData *data, GLES2_ImageSource source, int w, int h) { - GLES2_DriverContext *renderdata = (GLES2_DriverContext *)renderer->driverdata; - GLES2_TextureData *data; - GLenum format; - GLenum type; - GLenum scaleMode; - - GLES2_ActivateRenderer(renderer); + GLES2_ShaderCacheEntry *vertex = NULL; + GLES2_ShaderCacheEntry *fragment = NULL; + GLES2_ShaderType vtype, ftype; + GLES2_ProgramCacheEntry *program; - /* 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; + /* 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 SDL_PIXELFORMAT_IYUV: - case SDL_PIXELFORMAT_YV12: - case SDL_PIXELFORMAT_NV12: - case SDL_PIXELFORMAT_NV21: - format = GL_LUMINANCE; - type = GL_UNSIGNED_BYTE; + case GLES2_IMAGESOURCE_TEXTURE_ABGR: + ftype = GLES2_SHADER_FRAGMENT_TEXTURE_ABGR_SRC; break; -#ifdef GL_TEXTURE_EXTERNAL_OES - case SDL_PIXELFORMAT_EXTERNAL_OES: - format = GL_NONE; - type = GL_NONE; + 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: + switch (SDL_GetYUVConversionModeForResolution(w, h)) { + case SDL_YUV_CONVERSION_JPEG: + ftype = GLES2_SHADER_FRAGMENT_TEXTURE_YUV_JPEG_SRC; + break; + case SDL_YUV_CONVERSION_BT601: + ftype = GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT601_SRC; + break; + case SDL_YUV_CONVERSION_BT709: + ftype = GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT709_SRC; + break; + default: + SDL_SetError("Unsupported YUV conversion mode: %d\n", SDL_GetYUVConversionModeForResolution(w, h)); + goto fault; + } + break; + case GLES2_IMAGESOURCE_TEXTURE_NV12: + switch (SDL_GetYUVConversionModeForResolution(w, h)) { + case SDL_YUV_CONVERSION_JPEG: + ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_JPEG_SRC; + break; + case SDL_YUV_CONVERSION_BT601: + ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_BT601_SRC; + break; + case SDL_YUV_CONVERSION_BT709: + ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_BT709_SRC; + break; + default: + SDL_SetError("Unsupported YUV conversion mode: %d\n", SDL_GetYUVConversionModeForResolution(w, h)); + goto fault; + } + break; + case GLES2_IMAGESOURCE_TEXTURE_NV21: + switch (SDL_GetYUVConversionModeForResolution(w, h)) { + case SDL_YUV_CONVERSION_JPEG: + ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_JPEG_SRC; + break; + case SDL_YUV_CONVERSION_BT601: + ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT601_SRC; + break; + case SDL_YUV_CONVERSION_BT709: + ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT709_SRC; + break; + default: + SDL_SetError("Unsupported YUV conversion mode: %d\n", SDL_GetYUVConversionModeForResolution(w, h)); + goto fault; + } + break; + case GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES: + ftype = GLES2_SHADER_FRAGMENT_TEXTURE_EXTERNAL_OES_SRC; break; -#endif default: - return SDL_SetError("Texture format not supported"); + goto fault; } - if (texture->format == SDL_PIXELFORMAT_EXTERNAL_OES && - texture->access != SDL_TEXTUREACCESS_STATIC) { - return SDL_SetError("Unsupported texture access for SDL_PIXELFORMAT_EXTERNAL_OES"); + /* Load the requested shaders */ + vertex = GLES2_CacheShader(data, vtype); + if (!vertex) { + goto fault; + } + fragment = GLES2_CacheShader(data, ftype); + if (!fragment) { + goto fault; } - /* Allocate a texture struct */ - data = (GLES2_TextureData *)SDL_calloc(1, sizeof(GLES2_TextureData)); - if (!data) { - return SDL_OutOfMemory(); + /* Check if we need to change programs at all */ + if (data->drawstate.program && + data->drawstate.program->vertex_shader == vertex && + data->drawstate.program->fragment_shader == fragment) { + return 0; } - data->texture = 0; -#ifdef GL_TEXTURE_EXTERNAL_OES - data->texture_type = (texture->format == SDL_PIXELFORMAT_EXTERNAL_OES) ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D; -#else - data->texture_type = GL_TEXTURE_2D; -#endif - 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 = (texture->scaleMode == SDL_ScaleModeNearest) ? GL_NEAREST : GL_LINEAR; - /* 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 + 1) / 2) * ((data->pitch + 1) / 2); - } - if (data->nv12) { - /* Need to add size for the U/V plane */ - size += 2 * ((texture->h + 1) / 2) * ((data->pitch + 1) / 2); - } - data->pixel_data = SDL_calloc(1, size); - if (!data->pixel_data) { - SDL_free(data); - return SDL_OutOfMemory(); - } + /* Generate a matching program */ + program = GLES2_CacheProgram(data, vertex, fragment); + if (!program) { + goto fault; } - /* Allocate the texture */ - GL_CheckError("", renderer); + /* Select that program in OpenGL */ + data->glUseProgram(program->id); - 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 + 1) / 2, (texture->h + 1) / 2, 0, format, type, NULL); + /* Set the current program */ + data->drawstate.program = program; - 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 + 1) / 2, (texture->h + 1) / 2, 0, format, type, NULL); - if (GL_CheckError("glTexImage2D()", renderer) < 0) { - return -1; - } + /* Clean up and return */ + return 0; +fault: + if (vertex && vertex->references <= 0) { + GLES2_EvictShader(data, vertex); } - - 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 + 1) / 2, (texture->h + 1) / 2, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL); - if (GL_CheckError("glTexImage2D()", renderer) < 0) { - return -1; - } + if (fragment && fragment->references <= 0) { + GLES2_EvictShader(data, fragment); } + data->drawstate.program = NULL; + return -1; +} - renderdata->glGenTextures(1, &data->texture); - if (GL_CheckError("glGenTexures()", renderer) < 0) { +static int +GLES2_QueueSetViewport(SDL_Renderer * renderer, SDL_RenderCommand *cmd) +{ + return 0; /* nothing to do in this backend. */ +} + +static int +GLES2_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count) +{ + GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, count * 2 * sizeof (GLfloat), 0, &cmd->data.draw.first); + size_t i; + + if (!verts) { 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); - if (texture->format != SDL_PIXELFORMAT_EXTERNAL_OES) { - 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; + cmd->data.draw.count = count; + for (i = 0; i < count; i++) { + *(verts++) = 0.5f + points[i].x; + *(verts++) = 0.5f + points[i].y; } - return GL_CheckError("", renderer); + return 0; } 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) +GLES2_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FRect * rects, int count) { - Uint8 *blob = NULL; - Uint8 *src; - int src_pitch; - int y; + GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, count * 8 * sizeof (GLfloat), 0, &cmd->data.draw.first); + size_t i; - if ((width == 0) || (height == 0) || (bpp == 0)) { - return 0; /* nothing to do */ + if (!verts) { + return -1; } - /* 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; + cmd->data.draw.count = count; + + for (i = 0; i < count; i++) { + const SDL_FRect *rect = &rects[i]; + const GLfloat minx = rect->x; + const GLfloat maxx = rect->x + rect->w; + const GLfloat miny = rect->y; + const GLfloat maxy = rect->y + rect->h; + *(verts++) = minx; + *(verts++) = miny; + *(verts++) = maxx; + *(verts++) = miny; + *(verts++) = minx; + *(verts++) = maxy; + *(verts++) = maxx; + *(verts++) = maxy; } - data->glTexSubImage2D(target, 0, xoffset, yoffset, width, height, format, type, src); - if (blob) { - SDL_free(blob); + return 0; +} + +static int +GLES2_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture, + const SDL_Rect * srcrect, const SDL_FRect * dstrect) +{ + GLfloat minx, miny, maxx, maxy; + GLfloat minu, maxu, minv, maxv; + GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, 16 * sizeof (GLfloat), 0, &cmd->data.draw.first); + + if (!verts) { + return -1; } + + cmd->data.draw.count = 1; + + minx = dstrect->x; + miny = dstrect->y; + maxx = dstrect->x + dstrect->w; + maxy = dstrect->y + dstrect->h; + + minu = (GLfloat) srcrect->x / texture->w; + maxu = (GLfloat) (srcrect->x + srcrect->w) / texture->w; + minv = (GLfloat) srcrect->y / texture->h; + maxv = (GLfloat) (srcrect->y + srcrect->h) / texture->h; + + *(verts++) = minx; + *(verts++) = miny; + *(verts++) = maxx; + *(verts++) = miny; + *(verts++) = minx; + *(verts++) = maxy; + *(verts++) = maxx; + *(verts++) = maxy; + + *(verts++) = minu; + *(verts++) = minv; + *(verts++) = maxu; + *(verts++) = minv; + *(verts++) = minu; + *(verts++) = maxv; + *(verts++) = maxu; + *(verts++) = maxv; + return 0; } static int -GLES2_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, - const void *pixels, int pitch) +GLES2_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture, + const SDL_Rect * srcquad, const SDL_FRect * dstrect, + const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip) { - GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata; - GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata; + /* render expects cos value - 1 (see GLES2_VertexSrc_Default_) */ + const float radian_angle = (float)(M_PI * (360.0 - angle) / 180.0); + const GLfloat s = (GLfloat) SDL_sin(radian_angle); + const GLfloat c = (GLfloat) SDL_cos(radian_angle) - 1.0f; + const GLfloat centerx = center->x + dstrect->x; + const GLfloat centery = center->y + dstrect->y; + GLfloat minx, miny, maxx, maxy; + GLfloat minu, maxu, minv, maxv; + GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, 32 * sizeof (GLfloat), 0, &cmd->data.draw.first); + + if (!verts) { + return -1; + } - GLES2_ActivateRenderer(renderer); + if (flip & SDL_FLIP_HORIZONTAL) { + minx = dstrect->x + dstrect->w; + maxx = dstrect->x; + } + else { + minx = dstrect->x; + maxx = dstrect->x + dstrect->w; + } + + if (flip & SDL_FLIP_VERTICAL) { + miny = dstrect->y + dstrect->h; + maxy = dstrect->y; + } + else { + miny = dstrect->y; + maxy = dstrect->y + dstrect->h; + } + + minu = (GLfloat) (srcquad->x / texture->w); + maxu = (GLfloat) ((srcquad->x + srcquad->w) / texture->w); + minv = (GLfloat) (srcquad->y / texture->h); + maxv = (GLfloat) ((srcquad->y + srcquad->h) / texture->h); + + cmd->data.draw.count = 1; + + *(verts++) = minx; + *(verts++) = miny; + *(verts++) = maxx; + *(verts++) = miny; + *(verts++) = minx; + *(verts++) = maxy; + *(verts++) = maxx; + *(verts++) = maxy; + + *(verts++) = minu; + *(verts++) = minv; + *(verts++) = maxu; + *(verts++) = minv; + *(verts++) = minu; + *(verts++) = maxv; + *(verts++) = maxu; + *(verts++) = maxv; + + *(verts++) = s; + *(verts++) = c; + *(verts++) = s; + *(verts++) = c; + *(verts++) = s; + *(verts++) = c; + *(verts++) = s; + *(verts++) = c; + + *(verts++) = centerx; + *(verts++) = centery; + *(verts++) = centerx; + *(verts++) = centery; + *(verts++) = centerx; + *(verts++) = centery; + *(verts++) = centerx; + *(verts++) = centery; + + return 0; +} - GLES2_FlushCommandsIfTextureNeeded(renderer, texture); +static int +SetDrawState(GLES2_RenderData *data, const SDL_RenderCommand *cmd, const GLES2_ImageSource imgsrc) +{ + const SDL_bool was_copy_ex = data->drawstate.is_copy_ex; + const SDL_bool is_copy_ex = (cmd->command == SDL_RENDERCMD_COPY_EX); + SDL_Texture *texture = cmd->data.draw.texture; + GLES2_ProgramCacheEntry *program; - /* Bail out if we're supposed to update an empty rectangle */ - if (rect->w <= 0 || rect->h <= 0) { - return 0; + SDL_assert((texture != NULL) == (imgsrc != GLES2_IMAGESOURCE_SOLID)); + + if (texture != data->drawstate.texture) { + if ((texture != NULL) != data->drawstate.texturing) { + if (texture == NULL) { + data->glDisableVertexAttribArray((GLenum) GLES2_ATTRIBUTE_TEXCOORD); + data->drawstate.texturing = SDL_FALSE; + } else { + data->glEnableVertexAttribArray((GLenum) GLES2_ATTRIBUTE_TEXCOORD); + data->glVertexAttribPointer(GLES2_ATTRIBUTE_TEXCOORD, 2, GL_FLOAT, GL_FALSE, 0, (const GLvoid *) cmd->data.draw.first + (sizeof (GLfloat) * 8)); + data->drawstate.texturing = SDL_TRUE; + } + } + + if (texture) { + GLES2_TextureData *tdata = (GLES2_TextureData *) texture->driverdata; + 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); + } else 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); + } + + data->drawstate.texture = texture; } - /* 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 (GLES2_SelectProgram(data, imgsrc, texture ? texture->w : 0, texture ? texture->h : 0) < 0) { + return -1; + } - 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); + program = data->drawstate.program; + + if (program->uniform_locations[GLES2_UNIFORM_PROJECTION] != -1) { + if (SDL_memcmp(program->projection, data->drawstate.projection, sizeof (data->drawstate.projection)) != 0) { + data->glUniformMatrix4fv(program->uniform_locations[GLES2_UNIFORM_PROJECTION], 1, GL_FALSE, (GLfloat *)data->drawstate.projection); + SDL_memcpy(program->projection, data->drawstate.projection, sizeof (data->drawstate.projection)); } - GLES2_TexSubImage2D(data, tdata->texture_type, - rect->x / 2, - rect->y / 2, - (rect->w + 1) / 2, - (rect->h + 1) / 2, - tdata->pixel_format, - tdata->pixel_type, - pixels, (pitch + 1) / 2, 1); + } + if (program->uniform_locations[GLES2_UNIFORM_COLOR] != -1) { + if (data->drawstate.color != program->color) { + const Uint8 r = (data->drawstate.color >> 16) & 0xFF; + const Uint8 g = (data->drawstate.color >> 8) & 0xFF; + const Uint8 b = (data->drawstate.color >> 0) & 0xFF; + const Uint8 a = (data->drawstate.color >> 24) & 0xFF; + data->glUniform4f(program->uniform_locations[GLES2_UNIFORM_COLOR], r * inv255f, g * inv255f, b * inv255f, a * inv255f); + program->color = data->drawstate.color; + } + } - /* Skip to the correct offset into the next texture */ - pixels = (const void*)((const Uint8*)pixels + ((rect->h + 1) / 2) * ((pitch + 1)/2)); - if (texture->format == SDL_PIXELFORMAT_YV12) { - data->glBindTexture(tdata->texture_type, tdata->texture_u); + const SDL_BlendMode blend = cmd->data.draw.blend; + if (blend != data->drawstate.blend) { + if (blend == SDL_BLENDMODE_NONE) { + data->glDisable(GL_BLEND); } else { - data->glBindTexture(tdata->texture_type, tdata->texture_v); + data->glEnable(GL_BLEND); + data->glBlendFuncSeparate(GetBlendFunc(SDL_GetBlendModeSrcColorFactor(blend)), + GetBlendFunc(SDL_GetBlendModeDstColorFactor(blend)), + GetBlendFunc(SDL_GetBlendModeSrcAlphaFactor(blend)), + GetBlendFunc(SDL_GetBlendModeDstAlphaFactor(blend))); + data->glBlendEquationSeparate(GetBlendEquation(SDL_GetBlendModeColorOperation(blend)), + GetBlendEquation(SDL_GetBlendModeAlphaOperation(blend))); } - GLES2_TexSubImage2D(data, tdata->texture_type, - rect->x / 2, - rect->y / 2, - (rect->w + 1) / 2, - (rect->h + 1) / 2, - tdata->pixel_format, - tdata->pixel_type, - pixels, (pitch + 1) / 2, 1); + data->drawstate.blend = blend; } - 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 + 1) / 2, - (rect->h + 1) / 2, - GL_LUMINANCE_ALPHA, - GL_UNSIGNED_BYTE, - pixels, 2 * ((pitch + 1) / 2), 2); + /* all drawing commands use this */ + data->glVertexAttribPointer(GLES2_ATTRIBUTE_POSITION, 2, GL_FLOAT, GL_FALSE, 0, (const GLvoid *) cmd->data.draw.first); + + if (is_copy_ex != was_copy_ex) { + if (is_copy_ex) { + data->glEnableVertexAttribArray((GLenum) GLES2_ATTRIBUTE_ANGLE); + data->glEnableVertexAttribArray((GLenum) GLES2_ATTRIBUTE_CENTER); + data->glVertexAttribPointer(GLES2_ATTRIBUTE_ANGLE, 2, GL_FLOAT, GL_FALSE, 0, (const GLvoid *) (cmd->data.draw.first + (sizeof (GLfloat) * 16))); + data->glVertexAttribPointer(GLES2_ATTRIBUTE_CENTER, 2, GL_FLOAT, GL_FALSE, 0, (const GLvoid *) (cmd->data.draw.first + (sizeof (GLfloat) * 24))); + } else { + data->glDisableVertexAttribArray((GLenum) GLES2_ATTRIBUTE_ANGLE); + data->glDisableVertexAttribArray((GLenum) GLES2_ATTRIBUTE_CENTER); + } + data->drawstate.is_copy_ex = is_copy_ex; } - return GL_CheckError("glTexSubImage2D()", renderer); + return 0; } 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) +SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd) { - GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata; - GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata; - - GLES2_ActivateRenderer(renderer); - - GLES2_FlushCommandsIfTextureNeeded(renderer, texture); - - /* Bail out if we're supposed to update an empty rectangle */ - if (rect->w <= 0 || rect->h <= 0) { - return 0; - } + GLES2_RenderData *data = (GLES2_RenderData *) renderer->driverdata; + GLES2_ImageSource sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR; + SDL_Texture *texture = cmd->data.draw.texture; - data->glBindTexture(tdata->texture_type, tdata->texture_v); - GLES2_TexSubImage2D(data, tdata->texture_type, - rect->x / 2, - rect->y / 2, - (rect->w + 1) / 2, - (rect->h + 1) / 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 + 1) / 2, - (rect->h + 1) / 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; - - GLES2_FlushCommands(renderer); /* time to send everything to the GPU! */ - - if (texture == NULL) { - data->glBindFramebuffer(GL_FRAMEBUFFER, data->window_framebuffer); + /* Pick an appropriate shader */ + 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; + case SDL_PIXELFORMAT_EXTERNAL_OES: + sourceType = GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES; + 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 { - 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"); + 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; + case SDL_PIXELFORMAT_EXTERNAL_OES: + sourceType = GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES; + break; + default: + return SDL_SetError("Unsupported texture format"); } } - 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); - - GLES2_FlushCommandsIfTextureNeeded(renderer, texture); - - /* 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; - } + return SetDrawState(data, cmd, sourceType); } -/************************************************************************************************* - * Shader management functions * - *************************************************************************************************/ - -static GLES2_ShaderCacheEntry *GLES2_CacheShader(SDL_Renderer *renderer, GLES2_ShaderType type); -static void GLES2_EvictShader(SDL_Renderer *renderer, GLES2_ShaderCacheEntry *entry); -static GLES2_ProgramCacheEntry *GLES2_CacheProgram(SDL_Renderer *renderer, - GLES2_ShaderCacheEntry *vertex, - GLES2_ShaderCacheEntry *fragment); - -static GLES2_ProgramCacheEntry * -GLES2_CacheProgram(SDL_Renderer *renderer, GLES2_ShaderCacheEntry *vertex, - GLES2_ShaderCacheEntry *fragment) +static int +GLES2_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize) { - GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata; - GLES2_ProgramCacheEntry *entry; - GLES2_ShaderCacheEntry *shaderEntry; - GLint linkSuccessful; + GLES2_RenderData *data = (GLES2_RenderData *) renderer->driverdata; + const SDL_bool colorswap = (renderer->target && (renderer->target->format == SDL_PIXELFORMAT_ARGB8888 || renderer->target->format == SDL_PIXELFORMAT_RGB888)); + const int vboidx = data->current_vertex_buffer; + const GLuint vbo = data->vertex_buffers[vboidx]; + int drawablew = 0, drawableh = 0; + const SDL_bool istarget = renderer->target != NULL; + size_t i; - /* 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; + if (GLES2_ActivateRenderer(renderer) < 0) { + return -1; } - /* Create a program cache entry */ - entry = (GLES2_ProgramCacheEntry *)SDL_calloc(1, sizeof(GLES2_ProgramCacheEntry)); - if (!entry) { - SDL_OutOfMemory(); - return NULL; + if (!istarget) { + SDL_GL_GetDrawableSize(renderer->window, &drawablew, &drawableh); } - entry->vertex_shader = vertex; - entry->fragment_shader = fragment; - /* 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; + /* upload the new VBO data for this set of commands. */ + data->glBindBuffer(GL_ARRAY_BUFFER, vbo); + if (data->vertex_buffer_size[vboidx] < vertsize) { + data->glBufferData(GL_ARRAY_BUFFER, vertsize, vertices, GL_STREAM_DRAW); + data->vertex_buffer_size[vboidx] = vertsize; + } else { + data->glBufferSubData(GL_ARRAY_BUFFER, 0, vertsize, vertices); } - /* 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_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); - if (entry->uniform_locations[GLES2_UNIFORM_TEXTURE_V] != -1) { - data->glUniform1i(entry->uniform_locations[GLES2_UNIFORM_TEXTURE_V], 2); /* always texture unit 2. */ - } - if (entry->uniform_locations[GLES2_UNIFORM_TEXTURE_U] != -1) { - data->glUniform1i(entry->uniform_locations[GLES2_UNIFORM_TEXTURE_U], 1); /* always texture unit 1. */ - } - if (entry->uniform_locations[GLES2_UNIFORM_TEXTURE] != -1) { - data->glUniform1i(entry->uniform_locations[GLES2_UNIFORM_TEXTURE], 0); /* always texture unit 0. */ - } - if (entry->uniform_locations[GLES2_UNIFORM_PROJECTION] != -1) { - data->glUniformMatrix4fv(entry->uniform_locations[GLES2_UNIFORM_PROJECTION], 1, GL_FALSE, (GLfloat *)entry->projection); - } - if (entry->uniform_locations[GLES2_UNIFORM_COLOR] != -1) { - data->glUniform4f(entry->uniform_locations[GLES2_UNIFORM_COLOR], 1.0f, 1.0f, 1.0f, 1.0f); + /* cycle through a few VBOs so the GL has some time with the data before we replace it. */ + data->current_vertex_buffer++; + if (data->current_vertex_buffer >= SDL_arraysize(data->vertex_buffers)) { + data->current_vertex_buffer = 0; } - /* 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; + while (cmd) { + switch (cmd->command) { + case SDL_RENDERCMD_SETDRAWCOLOR: { + const Uint8 r = colorswap ? cmd->data.color.b : cmd->data.color.r; + const Uint8 g = cmd->data.color.g; + const Uint8 b = colorswap ? cmd->data.color.r : cmd->data.color.b; + const Uint8 a = cmd->data.color.a; + data->drawstate.color = ((a << 24) | (r << 16) | (g << 8) | b); + break; + } - /* Increment the refcount of the shaders we're using */ - ++vertex->references; - ++fragment->references; + case SDL_RENDERCMD_SETVIEWPORT: { + SDL_Rect *viewport = &data->drawstate.viewport; + if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof (SDL_Rect)) != 0) { + SDL_memcpy(viewport, &cmd->data.viewport.rect, sizeof (SDL_Rect)); + data->glViewport(viewport->x, + istarget ? viewport->y : (drawableh - viewport->y - viewport->h), + viewport->w, viewport->h); + if (viewport->w && viewport->h) { + data->drawstate.projection[0][0] = 2.0f / viewport->w; + data->drawstate.projection[1][1] = (renderer->target ? 2.0f : -2.0f) / viewport->h; + data->drawstate.projection[3][1] = renderer->target ? -1.0f : 1.0f; + } + } + break; + } - /* 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; -} + case SDL_RENDERCMD_SETCLIPRECT: { + const SDL_Rect *rect = &cmd->data.cliprect.rect; + if (data->drawstate.cliprect_enabled != cmd->data.cliprect.enabled) { + data->drawstate.cliprect_enabled = cmd->data.cliprect.enabled; + if (!data->drawstate.cliprect_enabled) { + data->glDisable(GL_SCISSOR_TEST); + } else { + const SDL_Rect *viewport = &data->drawstate.viewport; + data->glEnable(GL_SCISSOR_TEST); + if (SDL_memcmp(&data->drawstate.cliprect, rect, sizeof (SDL_Rect)) != 0) { + data->glScissor(viewport->x + rect->x, + istarget ? viewport->y + rect->y : drawableh - viewport->y - rect->y - rect->h, + rect->w, rect->h); + SDL_memcpy(&data->drawstate.cliprect, rect, sizeof (SDL_Rect)); + } + } + } + break; + } -static GLES2_ShaderCacheEntry * -GLES2_CacheShader(SDL_Renderer *renderer, GLES2_ShaderType type) -{ - 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; + case SDL_RENDERCMD_CLEAR: { + const Uint8 r = cmd->data.color.r; + const Uint8 g = cmd->data.color.g; + const Uint8 b = cmd->data.color.b; + const Uint8 a = cmd->data.color.a; + const Uint32 color = ((a << 24) | (r << 16) | (g << 8) | b); + if (color != data->drawstate.clear_color) { + const GLfloat fr = ((GLfloat) colorswap ? b : r) * inv255f; + const GLfloat fg = ((GLfloat) g) * inv255f; + const GLfloat fb = ((GLfloat) colorswap ? r : b) * inv255f; + const GLfloat fa = ((GLfloat) a) * inv255f; + data->glClearColor(fr, fg, fb, fa); + data->drawstate.clear_color = color; + } - /* Find the corresponding shader */ - shader = GLES2_GetShader(type); - if (!shader) { - SDL_SetError("No shader matching the requested characteristics was found"); - return NULL; - } + if (data->drawstate.cliprect_enabled) { + data->glDisable(GL_SCISSOR_TEST); + } - /* 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; + data->glClear(GL_COLOR_BUFFER_BIT); + + if (data->drawstate.cliprect_enabled) { + data->glEnable(GL_SCISSOR_TEST); + } + break; } - 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; - } + case SDL_RENDERCMD_DRAW_POINTS: { + if (SetDrawState(data, cmd, GLES2_IMAGESOURCE_SOLID) == 0) { + data->glDrawArrays(GL_POINTS, 0, cmd->data.draw.count); + } + break; + } - /* 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; + case SDL_RENDERCMD_DRAW_LINES: { + const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first); + const size_t count = cmd->data.draw.count; + if (SetDrawState(data, cmd, GLES2_IMAGESOURCE_SOLID) == 0) { + if (count > 2 && (verts[0] == verts[(count-1)*2]) && (verts[1] == verts[(count*2)-1])) { + /* GL_LINE_LOOP takes care of the final segment */ + data->glDrawArrays(GL_LINE_LOOP, 0, count - 1); + } else { + data->glDrawArrays(GL_LINE_STRIP, 0, count); + /* We need to close the endpoint of the line */ + data->glDrawArrays(GL_POINTS, count - 1, 1); + } + } + break; + } - /* 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 **)(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; + case SDL_RENDERCMD_FILL_RECTS: { + const size_t count = cmd->data.draw.count; + size_t offset = 0; + if (SetDrawState(data, cmd, GLES2_IMAGESOURCE_SOLID) == 0) { + for (i = 0; i < count; ++i, offset += 4) { + data->glDrawArrays(GL_TRIANGLE_STRIP, offset, 4); + } + } + break; + } - 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); + case SDL_RENDERCMD_COPY: + case SDL_RENDERCMD_COPY_EX: { + if (SetCopyState(renderer, cmd) == 0) { + data->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); + } + break; } + + case SDL_RENDERCMD_NO_OP: + break; } - 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; + cmd = cmd->next; } - data->shader_cache.head = entry; - ++data->shader_cache.count; - return entry; + + return GL_CheckError("", renderer); } static void -GLES2_EvictShader(SDL_Renderer *renderer, GLES2_ShaderCacheEntry *entry) +GLES2_DestroyRenderer(SDL_Renderer *renderer) { - GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata; + GLES2_RenderData *data = (GLES2_RenderData *)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 everything */ + if (data) { + GLES2_ActivateRenderer(renderer); - /* Deallocate the shader */ - data->glDeleteShader(entry->id); - SDL_free(entry); + { + 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; + } + + data->glDeleteBuffers(SDL_arraysize(data->vertex_buffers), data->vertex_buffers); + GL_CheckError("", renderer); + + SDL_GL_DeleteContext(data->context); + } + + SDL_free(data->shader_formats); + SDL_free(data); + } + SDL_free(renderer); } static int -GLES2_SelectProgram(SDL_Renderer *renderer, GLES2_ImageSource source, int w, int h) +GLES2_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture) { - GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata; - GLES2_ShaderCacheEntry *vertex = NULL; - GLES2_ShaderCacheEntry *fragment = NULL; - GLES2_ShaderType vtype, ftype; - GLES2_ProgramCacheEntry *program; + GLES2_RenderData *renderdata = (GLES2_RenderData *)renderer->driverdata; + GLES2_TextureData *data; + GLenum format; + GLenum type; + GLenum scaleMode; - /* 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: - switch (SDL_GetYUVConversionModeForResolution(w, h)) { - case SDL_YUV_CONVERSION_JPEG: - ftype = GLES2_SHADER_FRAGMENT_TEXTURE_YUV_JPEG_SRC; - break; - case SDL_YUV_CONVERSION_BT601: - ftype = GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT601_SRC; - break; - case SDL_YUV_CONVERSION_BT709: - ftype = GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT709_SRC; - break; - default: - SDL_SetError("Unsupported YUV conversion mode: %d\n", SDL_GetYUVConversionModeForResolution(w, h)); - goto fault; - } - break; - case GLES2_IMAGESOURCE_TEXTURE_NV12: - switch (SDL_GetYUVConversionModeForResolution(w, h)) { - case SDL_YUV_CONVERSION_JPEG: - ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_JPEG_SRC; - break; - case SDL_YUV_CONVERSION_BT601: - ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_BT601_SRC; - break; - case SDL_YUV_CONVERSION_BT709: - ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_BT709_SRC; - break; - default: - SDL_SetError("Unsupported YUV conversion mode: %d\n", SDL_GetYUVConversionModeForResolution(w, h)); - goto fault; - } + 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 GLES2_IMAGESOURCE_TEXTURE_NV21: - switch (SDL_GetYUVConversionModeForResolution(w, h)) { - case SDL_YUV_CONVERSION_JPEG: - ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_JPEG_SRC; - break; - case SDL_YUV_CONVERSION_BT601: - ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT601_SRC; - break; - case SDL_YUV_CONVERSION_BT709: - ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT709_SRC; - break; - default: - SDL_SetError("Unsupported YUV conversion mode: %d\n", SDL_GetYUVConversionModeForResolution(w, h)); - goto fault; - } + case SDL_PIXELFORMAT_IYUV: + case SDL_PIXELFORMAT_YV12: + case SDL_PIXELFORMAT_NV12: + case SDL_PIXELFORMAT_NV21: + format = GL_LUMINANCE; + type = GL_UNSIGNED_BYTE; break; - case GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES: - ftype = GLES2_SHADER_FRAGMENT_TEXTURE_EXTERNAL_OES_SRC; +#ifdef GL_TEXTURE_EXTERNAL_OES + case SDL_PIXELFORMAT_EXTERNAL_OES: + format = GL_NONE; + type = GL_NONE; break; +#endif default: - goto fault; + return SDL_SetError("Texture format not supported"); } - /* Load the requested shaders */ - vertex = GLES2_CacheShader(renderer, vtype); - if (!vertex) { - goto fault; - } - fragment = GLES2_CacheShader(renderer, ftype); - if (!fragment) { - goto fault; + if (texture->format == SDL_PIXELFORMAT_EXTERNAL_OES && + texture->access != SDL_TEXTUREACCESS_STATIC) { + return SDL_SetError("Unsupported texture access for SDL_PIXELFORMAT_EXTERNAL_OES"); } - /* 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; + /* Allocate a texture struct */ + data = (GLES2_TextureData *)SDL_calloc(1, sizeof(GLES2_TextureData)); + if (!data) { + return SDL_OutOfMemory(); } + data->texture = 0; +#ifdef GL_TEXTURE_EXTERNAL_OES + data->texture_type = (texture->format == SDL_PIXELFORMAT_EXTERNAL_OES) ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D; +#else + data->texture_type = GL_TEXTURE_2D; +#endif + 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 = (texture->scaleMode == SDL_ScaleModeNearest) ? GL_NEAREST : GL_LINEAR; - /* Generate a matching program */ - program = GLES2_CacheProgram(renderer, vertex, fragment); - if (!program) { - goto fault; + /* 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 + 1) / 2) * ((data->pitch + 1) / 2); + } else if (data->nv12) { + /* Need to add size for the U/V plane */ + size += 2 * ((texture->h + 1) / 2) * ((data->pitch + 1) / 2); + } + data->pixel_data = SDL_calloc(1, size); + if (!data->pixel_data) { + SDL_free(data); + return SDL_OutOfMemory(); + } } - /* Select that program in OpenGL */ - data->glUseProgram(program->id); + /* Allocate the texture */ + GL_CheckError("", renderer); - /* Set the current program */ - data->current_program = program; + 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 + 1) / 2, (texture->h + 1) / 2, 0, format, type, NULL); - /* 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); + 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 + 1) / 2, (texture->h + 1) / 2, 0, format, type, NULL); + if (GL_CheckError("glTexImage2D()", renderer) < 0) { + return -1; + } + } else 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 + 1) / 2, (texture->h + 1) / 2, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL); + if (GL_CheckError("glTexImage2D()", renderer) < 0) { + return -1; + } } - data->current_program = NULL; - 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); + if (texture->format != SDL_PIXELFORMAT_EXTERNAL_OES) { + renderdata->glTexImage2D(data->texture_type, 0, format, texture->w, texture->h, 0, format, type, NULL); + if (GL_CheckError("glTexImage2D()", renderer) < 0) { + return -1; + } + } -/************************************************************************************************* - * Rendering functions * - *************************************************************************************************/ + if (texture->access == SDL_TEXTUREACCESS_TARGET) { + data->fbo = GLES2_GetFBO(renderer->driverdata, texture->w, texture->h); + } else { + data->fbo = NULL; + } -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); + return GL_CheckError("", renderer); +} static int -GLES2_RenderClear(SDL_Renderer * renderer) +GLES2_TexSubImage2D(GLES2_RenderData *data, GLenum target, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels, GLint pitch, GLint bpp) { - GLES2_RenderCommand *cmd = GLES2_AllocateRenderCommand(renderer); - if (cmd == NULL) { - return -1; + Uint8 *blob = NULL; + Uint8 *src; + int src_pitch; + int y; + + if ((width == 0) || (height == 0) || (bpp == 0)) { + return 0; /* nothing to do */ } - cmd->cmd = GLES2_RENDERCMD_CLEAR; - cmd->data.clear.r = renderer->r; - cmd->data.clear.g = renderer->g; - cmd->data.clear.b = renderer->b; - cmd->data.clear.a = renderer->a; - return 0; -} -static int -GLES2_AddVertices(SDL_Renderer *renderer, const GLES2_Attribute attr, const float *vertexData, size_t dataSizeInElements) -{ - GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata; - const GLsizeiptr needed = data->current_vertex_data + dataSizeInElements; - GLES2_RenderCommand *cmd; - GLfloat *vdata; - - if (needed > data->vertex_data_allocation) { - const GLsizeiptr newsize = data->vertex_data_allocation * 2; -printf("realloc'ing %p to %d\n", data->vertex_data, (int) newsize); - void *ptr = SDL_realloc(data->vertex_data, newsize * sizeof (GLfloat)); - if (ptr == NULL) { - SDL_OutOfMemory(); - return -1; + /* 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; } - data->vertex_data = (GLfloat *) ptr; - data->vertex_data_allocation = newsize; + src = blob; } - cmd = GLES2_AllocateRenderCommand(renderer); - if (cmd == NULL) { - return -1; + data->glTexSubImage2D(target, 0, xoffset, yoffset, width, height, format, type, src); + if (blob) { + SDL_free(blob); } - - vdata = &data->vertex_data[data->current_vertex_data]; - SDL_memcpy(vdata, vertexData, dataSizeInElements * sizeof (GLfloat)); - cmd->cmd = GLES2_RENDERCMD_ATTR; - cmd->data.attr.attr = attr; - cmd->data.attr.offset = data->current_vertex_data * sizeof (GLfloat); - cmd->data.attr.count = dataSizeInElements; - data->current_vertex_data += dataSizeInElements; return 0; } static int -GLES2_AddSolidDrawCommand(SDL_Renderer *renderer, const GLenum mode, const GLint first, const GLsizei count) +GLES2_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, + const void *pixels, int pitch) { - GLES2_RenderCommand *cmd = GLES2_AllocateRenderCommand(renderer); - if (cmd == NULL) { - return -1; + GLES2_RenderData *data = (GLES2_RenderData *)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; } - cmd->cmd = GLES2_RENDERCMD_DRAW; - cmd->data.draw.mode = mode; - cmd->data.draw.first = first; - cmd->data.draw.count = count; - cmd->data.draw.attrs = (1 << GLES2_ATTRIBUTE_POSITION); - cmd->data.draw.r = renderer->r; - cmd->data.draw.g = renderer->g; - cmd->data.draw.b = renderer->b; - cmd->data.draw.a = renderer->a; - cmd->data.draw.blend = renderer->blendMode; - cmd->data.draw.imgsrc = GLES2_IMAGESOURCE_SOLID; - cmd->data.draw.texture = NULL; - 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 + 1) / 2, + (rect->h + 1) / 2, + tdata->pixel_format, + tdata->pixel_type, + pixels, (pitch + 1) / 2, 1); + + + /* Skip to the correct offset into the next texture */ + pixels = (const void*)((const Uint8*)pixels + ((rect->h + 1) / 2) * ((pitch + 1)/2)); + 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 + 1) / 2, + (rect->h + 1) / 2, + tdata->pixel_format, + tdata->pixel_type, + pixels, (pitch + 1) / 2, 1); + } else 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 + 1) / 2, + (rect->h + 1) / 2, + GL_LUMINANCE_ALPHA, + GL_UNSIGNED_BYTE, + pixels, 2 * ((pitch + 1) / 2), 2); + } + + return GL_CheckError("glTexSubImage2D()", renderer); } static int -GLES2_RenderDrawPoints(SDL_Renderer *renderer, const SDL_FPoint *points, int count) +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) { - GLfloat *vertices = SDL_stack_alloc(GLfloat, count * 2); /* !!! FIXME: We could do this without a stack_alloc... */ - int idx; - int rc; + GLES2_RenderData *data = (GLES2_RenderData *)renderer->driverdata; + GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata; - /* Emit the specified vertices as points */ - for (idx = 0; idx < count; ++idx) { - vertices[idx * 2] = points[idx].x + 0.5f; - vertices[(idx * 2) + 1] = points[idx].y + 0.5f; + GLES2_ActivateRenderer(renderer); + + /* Bail out if we're supposed to update an empty rectangle */ + if (rect->w <= 0 || rect->h <= 0) { + return 0; } - rc = GLES2_AddVertices(renderer, GLES2_ATTRIBUTE_POSITION, vertices, count * 2); - SDL_stack_free(vertices); + data->glBindTexture(tdata->texture_type, tdata->texture_v); + GLES2_TexSubImage2D(data, tdata->texture_type, + rect->x / 2, + rect->y / 2, + (rect->w + 1) / 2, + (rect->h + 1) / 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 + 1) / 2, + (rect->h + 1) / 2, + tdata->pixel_format, + tdata->pixel_type, + Uplane, Upitch, 1); - if (rc == 0) { - rc = GLES2_AddSolidDrawCommand(renderer, GL_POINTS, 0, count); - } + 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 rc; + return GL_CheckError("glTexSubImage2D()", renderer); } static int -GLES2_RenderDrawLines(SDL_Renderer *renderer, const SDL_FPoint *points, int count) +GLES2_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, + void **pixels, int *pitch) { - GLfloat *vertices = SDL_stack_alloc(GLfloat, count * 2); /* !!! FIXME: We could do this without a stack_alloc... */ - int idx; - int rc; - - /* Emit a line strip including the specified vertices */ - for (idx = 0; idx < count; ++idx) { - vertices[idx * 2] = points[idx].x + 0.5f; - vertices[(idx * 2) + 1] = points[idx].y + 0.5f; - } - - rc = GLES2_AddVertices(renderer, GLES2_ATTRIBUTE_POSITION, vertices, count * 2); - if (rc == 0) { - rc = GLES2_AddSolidDrawCommand(renderer, GL_LINE_STRIP, 0, count); - } + GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata; -#if 0 /* !!! FIXME: ugh */ - /* 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) { - GLES2_DrawVertices(GL_POINTS, count-1, 1); - } -#endif + /* 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; - SDL_stack_free(vertices); - return rc; + return 0; } -static int -GLES2_RenderFillRects(SDL_Renderer *renderer, const SDL_FRect *rects, int count) +static void +GLES2_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture) { - GLfloat vertices[8]; - int idx; - int rc = 0; - - /* Emit a line loop for each rectangle */ - for (idx = 0; (rc == 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; - - rc = GLES2_AddVertices(renderer, GLES2_ATTRIBUTE_POSITION, vertices, 8); - if (rc == 0) { - rc = GLES2_AddSolidDrawCommand(renderer, GL_TRIANGLE_STRIP, 0, 4); - } - } + GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata; + SDL_Rect rect; - return 0; + /* 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_AddCopyDrawCommand(SDL_Renderer *renderer, SDL_Texture *texture, const Uint8 attrs) +GLES2_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture) { - GLES2_RenderCommand *cmd = NULL; - GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata; - GLES2_ImageSource sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR; + GLES2_RenderData *data = (GLES2_RenderData *) renderer->driverdata; + GLES2_TextureData *texturedata = NULL; + GLenum status; - /* Pick an appropriate shader */ - 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; - case SDL_PIXELFORMAT_EXTERNAL_OES: - sourceType = GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES; - 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) */ - } + if (texture == NULL) { + data->glBindFramebuffer(GL_FRAMEBUFFER, data->window_framebuffer); } 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; - case SDL_PIXELFORMAT_EXTERNAL_OES: - sourceType = GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES; - break; - default: - return SDL_SetError("Unsupported texture format"); + 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"); } } - - ((GLES2_TextureData *)texture->driverdata)->last_cmd_generation = data->command_generation; - - cmd = GLES2_AllocateRenderCommand(renderer); - if (cmd == NULL) { - return -1; - } - cmd->cmd = GLES2_RENDERCMD_DRAW; - cmd->data.draw.mode = GL_TRIANGLE_STRIP; - cmd->data.draw.first = 0; - cmd->data.draw.count = 4; - cmd->data.draw.attrs = attrs | (1 << GLES2_ATTRIBUTE_POSITION) | (1 << GLES2_ATTRIBUTE_TEXCOORD); - cmd->data.draw.r = texture->r; - cmd->data.draw.g = texture->g; - cmd->data.draw.b = texture->b; - cmd->data.draw.a = texture->a; - cmd->data.draw.blend = texture->blendMode; - cmd->data.draw.imgsrc = sourceType; - cmd->data.draw.texture = texture; - return 0; } -static int -GLES2_RenderCopy(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect, - const SDL_FRect *dstrect) +static void +GLES2_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture) { - GLfloat vertices[8]; - int rc; - - /* 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); - rc = GLES2_AddVertices(renderer, GLES2_ATTRIBUTE_POSITION, vertices, 8); - - if (rc == 0) { - vertices[0] = srcrect->x / (GLfloat)texture->w; - vertices[1] = srcrect->y / (GLfloat)texture->h; - vertices[2] = (srcrect->x + srcrect->w) / (GLfloat)texture->w; - vertices[3] = srcrect->y / (GLfloat)texture->h; - vertices[4] = srcrect->x / (GLfloat)texture->w; - vertices[5] = (srcrect->y + srcrect->h) / (GLfloat)texture->h; - vertices[6] = (srcrect->x + srcrect->w) / (GLfloat)texture->w; - vertices[7] = (srcrect->y + srcrect->h) / (GLfloat)texture->h; - rc = GLES2_AddVertices(renderer, GLES2_ATTRIBUTE_TEXCOORD, vertices, 8); - - if (rc == 0) { - rc = GLES2_AddCopyDrawCommand(renderer, texture, 0); - } - } - - return rc; -} + GLES2_RenderData *data = (GLES2_RenderData *)renderer->driverdata; + GLES2_TextureData *tdata = (GLES2_TextureData *)texture->driverdata; -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) -{ - const float radian_angle = (float)(M_PI * (360.0 - angle) / 180.0); - GLfloat vertices[8]; - int rc; + GLES2_ActivateRenderer(renderer); - vertices[0] = vertices[2] = vertices[4] = vertices[6] = (GLfloat)SDL_sin(radian_angle); - /* render expects cos value - 1 (see GLES2_VertexSrc_Default_) */ - vertices[1] = vertices[3] = vertices[5] = vertices[7] = (GLfloat)SDL_cos(radian_angle) - 1.0f; - rc = GLES2_AddVertices(renderer, GLES2_ATTRIBUTE_ANGLE, vertices, 8); - - /* Calculate the center of rotation */ - if (rc == 0) { - vertices[0] = vertices[2] = vertices[4] = vertices[6] = (center->x + dstrect->x); - vertices[1] = vertices[3] = vertices[5] = vertices[7] = (center->y + dstrect->y); - rc = GLES2_AddVertices(renderer, GLES2_ATTRIBUTE_CENTER, vertices, 8); - - if (rc == 0) { - /* 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) { - const GLfloat tmp = vertices[0]; - vertices[0] = vertices[4] = vertices[2]; - vertices[2] = vertices[6] = tmp; - } - if (flip & SDL_FLIP_VERTICAL) { - const GLfloat tmp = vertices[1]; - vertices[1] = vertices[3] = vertices[5]; - vertices[5] = vertices[7] = tmp; - } - rc = GLES2_AddVertices(renderer, GLES2_ATTRIBUTE_POSITION, vertices, 8); - - if (rc == 0) { - vertices[0] = srcrect->x / (GLfloat)texture->w; - vertices[1] = srcrect->y / (GLfloat)texture->h; - vertices[2] = (srcrect->x + srcrect->w) / (GLfloat)texture->w; - vertices[3] = srcrect->y / (GLfloat)texture->h; - vertices[4] = srcrect->x / (GLfloat)texture->w; - vertices[5] = (srcrect->y + srcrect->h) / (GLfloat)texture->h; - vertices[6] = (srcrect->x + srcrect->w) / (GLfloat)texture->w; - vertices[7] = (srcrect->y + srcrect->h) / (GLfloat)texture->h; - rc = GLES2_AddVertices(renderer, GLES2_ATTRIBUTE_TEXCOORD, vertices, 8); - - if (rc == 0) { - GLES2_AddCopyDrawCommand(renderer, texture, (1 << GLES2_ATTRIBUTE_CENTER) | (1 << GLES2_ATTRIBUTE_ANGLE)); - } - } + /* 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; } - - return rc; } 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; + GLES2_RenderData *data = (GLES2_RenderData *)renderer->driverdata; Uint32 temp_format = renderer->target ? renderer->target->format : SDL_PIXELFORMAT_ABGR8888; size_t buflen; void *temp_pixels; @@ -2088,8 +1768,6 @@ GLES2_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect, int w, h, length, rows; int status; - GLES2_FlushCommands(renderer); /* we need to render before we read the results. */ - temp_pitch = rect->w * SDL_BYTESPERPIXEL(temp_format); buflen = (size_t) (rect->h * temp_pitch); if (buflen == 0) { @@ -2137,8 +1815,6 @@ GLES2_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect, static void GLES2_RenderPresent(SDL_Renderer *renderer) { - GLES2_FlushCommands(renderer); /* time to send it to the GPU! */ - /* Tell the video driver to swap buffers */ SDL_GL_SwapWindow(renderer->window); } @@ -2152,7 +1828,7 @@ 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_RenderData *data = (GLES2_RenderData *)renderer->driverdata; GLES2_TextureData *texturedata = (GLES2_TextureData *)texture->driverdata; GLES2_ActivateRenderer(renderer); @@ -2170,7 +1846,7 @@ static int GLES2_BindTexture (SDL_Renderer * renderer, SDL_Texture *texture, flo static int GLES2_UnbindTexture (SDL_Renderer * renderer, SDL_Texture *texture) { - GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->driverdata; + GLES2_RenderData *data = (GLES2_RenderData *)renderer->driverdata; GLES2_TextureData *texturedata = (GLES2_TextureData *)texture->driverdata; GLES2_ActivateRenderer(renderer); @@ -2188,37 +1864,12 @@ static int GLES2_UnbindTexture (SDL_Renderer * renderer, SDL_Texture *texture) #define GL_NVIDIA_PLATFORM_BINARY_NV 0x890B #endif -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->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; + GLES2_RenderData *data; GLint nFormats; #ifndef ZUNE_HD GLboolean hasCompiler; @@ -2240,6 +1891,7 @@ GLES2_CreateRenderer(SDL_Window *window, Uint32 flags) } window_flags = SDL_GetWindowFlags(window); + /* OpenGL ES 3.0 is a superset of OpenGL ES 2.0 */ if (!(window_flags & SDL_WINDOW_OPENGL) || profile_mask != SDL_GL_CONTEXT_PROFILE_ES || major < RENDERER_CONTEXT_MAJOR) { @@ -2261,7 +1913,7 @@ GLES2_CreateRenderer(SDL_Window *window, Uint32 flags) goto error; } - data = (GLES2_DriverContext *)SDL_calloc(1, sizeof(GLES2_DriverContext)); + data = (GLES2_RenderData *)SDL_calloc(1, sizeof(GLES2_RenderData)); if (!data) { GLES2_DestroyRenderer(renderer); SDL_OutOfMemory(); @@ -2272,15 +1924,6 @@ GLES2_CreateRenderer(SDL_Window *window, Uint32 flags) renderer->driverdata = data; renderer->window = window; - data->vertex_data_allocation = 512; - data->vertex_data = (GLfloat *) SDL_malloc(data->vertex_data_allocation * sizeof (GLfloat)); - if (data->vertex_data == NULL) { - GLES2_DestroyRenderer(renderer); - SDL_OutOfMemory(); - goto error; - } -printf("malloc'd %p\n", data->vertex_data); - /* Create an OpenGL ES 2.0 context */ data->context = SDL_GL_CreateContext(window); if (!data->context) { @@ -2371,14 +2014,14 @@ printf("malloc'd %p\n", data->vertex_data); 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->QueueSetViewport = GLES2_QueueSetViewport; + renderer->QueueSetDrawColor = GLES2_QueueSetViewport; /* SetViewport and SetDrawColor are (currently) no-ops. */ + renderer->QueueDrawPoints = GLES2_QueueDrawPoints; + renderer->QueueDrawLines = GLES2_QueueDrawPoints; /* lines and points queue vertices the same way. */ + renderer->QueueFillRects = GLES2_QueueFillRects; + renderer->QueueCopy = GLES2_QueueCopy; + renderer->QueueCopyEx = GLES2_QueueCopyEx; + renderer->RunCommandQueue = GLES2_RunCommandQueue; renderer->RenderReadPixels = GLES2_RenderReadPixels; renderer->RenderPresent = GLES2_RenderPresent; renderer->DestroyTexture = GLES2_DestroyTexture; @@ -2394,7 +2037,20 @@ printf("malloc'd %p\n", data->vertex_data); renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_EXTERNAL_OES; #endif - GLES2_ResetState(renderer); + data->glActiveTexture(GL_TEXTURE0); + data->glPixelStorei(GL_PACK_ALIGNMENT, 1); + data->glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + data->glEnableVertexAttribArray(GLES2_ATTRIBUTE_POSITION); + data->glDisableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD); + + data->drawstate.blend = SDL_BLENDMODE_INVALID; + data->drawstate.color = 0xFFFFFFFF; + data->drawstate.clear_color = 0xFFFFFFFF; + data->drawstate.projection[3][0] = -1.0f; + data->drawstate.projection[3][3] = 1.0f; + + GL_CheckError("", renderer); return renderer; @@ -2409,6 +2065,23 @@ printf("malloc'd %p\n", data->vertex_data); return NULL; } +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 + } +}; + #endif /* SDL_VIDEO_RENDER_OGL_ES2 && !SDL_RENDER_DISABLED */ /* vi: set ts=4 sw=4 expandtab: */