21 #include "../../SDL_internal.h"
23 #if SDL_VIDEO_RENDER_OGL_ES2 && !SDL_RENDER_DISABLED
28 #include "../SDL_sysrender.h"
29 #include "../../video/SDL_blit.h"
35 #define RENDERER_CONTEXT_MAJOR 2
36 #define RENDERER_CONTEXT_MINOR 0
45 typedef struct GLES2_FBOList GLES2_FBOList;
54 typedef struct GLES2_TextureData
70 typedef struct GLES2_ShaderCacheEntry
73 GLES2_ShaderType
type;
74 const GLES2_ShaderInstance *instance;
76 struct GLES2_ShaderCacheEntry *prev;
77 struct GLES2_ShaderCacheEntry *next;
78 } GLES2_ShaderCacheEntry;
80 typedef struct GLES2_ShaderCache
83 GLES2_ShaderCacheEntry *
head;
86 typedef struct GLES2_ProgramCacheEntry
89 GLES2_ShaderCacheEntry *vertex_shader;
90 GLES2_ShaderCacheEntry *fragment_shader;
91 GLuint uniform_locations[16];
94 struct GLES2_ProgramCacheEntry *prev;
95 struct GLES2_ProgramCacheEntry *next;
96 } GLES2_ProgramCacheEntry;
98 typedef struct GLES2_ProgramCache
101 GLES2_ProgramCacheEntry *
head;
102 GLES2_ProgramCacheEntry *
tail;
103 } GLES2_ProgramCache;
107 GLES2_ATTRIBUTE_POSITION = 0,
108 GLES2_ATTRIBUTE_TEXCOORD = 1,
109 GLES2_ATTRIBUTE_ANGLE = 2,
110 GLES2_ATTRIBUTE_CENTER = 3,
115 GLES2_UNIFORM_PROJECTION,
116 GLES2_UNIFORM_TEXTURE,
118 GLES2_UNIFORM_TEXTURE_U,
119 GLES2_UNIFORM_TEXTURE_V
124 GLES2_IMAGESOURCE_INVALID,
125 GLES2_IMAGESOURCE_SOLID,
126 GLES2_IMAGESOURCE_TEXTURE_ABGR,
127 GLES2_IMAGESOURCE_TEXTURE_ARGB,
128 GLES2_IMAGESOURCE_TEXTURE_RGB,
129 GLES2_IMAGESOURCE_TEXTURE_BGR,
130 GLES2_IMAGESOURCE_TEXTURE_YUV,
131 GLES2_IMAGESOURCE_TEXTURE_NV12,
132 GLES2_IMAGESOURCE_TEXTURE_NV21,
133 GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES
153 GLES2_ProgramCacheEntry *
program;
155 } GLES2_DrawStateCache;
157 typedef struct GLES2_RenderData
163 #define SDL_PROC(ret,func,params) ret (APIENTRY *func) params;
167 GLuint window_framebuffer;
169 int shader_format_count;
171 GLES2_ShaderCache shader_cache;
172 GLES2_ProgramCache program_cache;
173 Uint8 clear_r, clear_g, clear_b, clear_a;
176 size_t vertex_buffer_size[8];
177 int current_vertex_buffer;
178 GLES2_DrawStateCache drawstate;
181 #define GLES2_MAX_CACHED_PROGRAMS 8
183 static const float inv255f = 1.0f / 255.0f;
187 GL_TranslateError (
GLenum error)
189 #define GL_ERROR_TRANSLATE(e) case e: return #e;
199 #undef GL_ERROR_TRANSLATE
207 if (!
data->debug_enabled) {
216 GL_CheckAllErrors (
const char *prefix,
SDL_Renderer *
renderer,
const char *file,
int line,
const char *
function)
221 if (!
data->debug_enabled) {
228 if (prefix ==
NULL || prefix[0] ==
'\0') {
231 SDL_SetError(
"%s: %s (%d): %s %s (0x%X)", prefix, file, line,
function, GL_TranslateError(error), error);
241 #define GL_CheckError(prefix, renderer)
243 #define GL_CheckError(prefix, renderer) GL_CheckAllErrors(prefix, renderer, SDL_FILE, SDL_LINE, SDL_FUNCTION)
251 static int GLES2_LoadFunctions(GLES2_RenderData *
data)
253 #if SDL_VIDEO_DRIVER_UIKIT
254 #define __SDL_NOGETPROCADDR__
255 #elif SDL_VIDEO_DRIVER_ANDROID
256 #define __SDL_NOGETPROCADDR__
257 #elif SDL_VIDEO_DRIVER_PANDORA
258 #define __SDL_NOGETPROCADDR__
261 #if defined __SDL_NOGETPROCADDR__
262 #define SDL_PROC(ret,func,params) data->func=func;
264 #define SDL_PROC(ret,func,params) \
266 data->func = SDL_GL_GetProcAddress(#func); \
267 if ( ! data->func ) { \
268 return SDL_SetError("Couldn't load GLES2 function %s: %s", #func, SDL_GetError()); \
278 static GLES2_FBOList *
398 GLES2_EvictShader(GLES2_RenderData *
data, GLES2_ShaderCacheEntry *entry)
402 entry->next->prev = entry->prev;
405 entry->prev->next = entry->next;
407 if (
data->shader_cache.head == entry) {
408 data->shader_cache.head = entry->next;
410 --
data->shader_cache.count;
413 data->glDeleteShader(entry->id);
417 static GLES2_ProgramCacheEntry *
418 GLES2_CacheProgram(GLES2_RenderData *
data, GLES2_ShaderCacheEntry *vertex,
419 GLES2_ShaderCacheEntry *fragment)
421 GLES2_ProgramCacheEntry *entry;
422 GLES2_ShaderCacheEntry *shaderEntry;
423 GLint linkSuccessful;
426 entry =
data->program_cache.head;
428 if (entry->vertex_shader == vertex && entry->fragment_shader == fragment) {
434 if (
data->program_cache.head != entry) {
436 entry->next->prev = entry->prev;
439 entry->prev->next = entry->next;
442 entry->next =
data->program_cache.head;
443 data->program_cache.head->prev = entry;
444 data->program_cache.head = entry;
450 entry = (GLES2_ProgramCacheEntry *)
SDL_calloc(1,
sizeof(GLES2_ProgramCacheEntry));
455 entry->vertex_shader = vertex;
456 entry->fragment_shader = fragment;
459 entry->id =
data->glCreateProgram();
460 data->glAttachShader(entry->id, vertex->id);
461 data->glAttachShader(entry->id, fragment->id);
462 data->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_POSITION,
"a_position");
463 data->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_TEXCOORD,
"a_texCoord");
464 data->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_ANGLE,
"a_angle");
465 data->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_CENTER,
"a_center");
466 data->glLinkProgram(entry->id);
468 if (!linkSuccessful) {
469 data->glDeleteProgram(entry->id);
476 entry->uniform_locations[GLES2_UNIFORM_PROJECTION] =
477 data->glGetUniformLocation(entry->id,
"u_projection");
478 entry->uniform_locations[GLES2_UNIFORM_TEXTURE_V] =
479 data->glGetUniformLocation(entry->id,
"u_texture_v");
480 entry->uniform_locations[GLES2_UNIFORM_TEXTURE_U] =
481 data->glGetUniformLocation(entry->id,
"u_texture_u");
482 entry->uniform_locations[GLES2_UNIFORM_TEXTURE] =
483 data->glGetUniformLocation(entry->id,
"u_texture");
484 entry->uniform_locations[GLES2_UNIFORM_COLOR] =
485 data->glGetUniformLocation(entry->id,
"u_color");
489 data->glUseProgram(entry->id);
490 if (entry->uniform_locations[GLES2_UNIFORM_TEXTURE_V] != -1) {
491 data->glUniform1i(entry->uniform_locations[GLES2_UNIFORM_TEXTURE_V], 2);
493 if (entry->uniform_locations[GLES2_UNIFORM_TEXTURE_U] != -1) {
494 data->glUniform1i(entry->uniform_locations[GLES2_UNIFORM_TEXTURE_U], 1);
496 if (entry->uniform_locations[GLES2_UNIFORM_TEXTURE] != -1) {
497 data->glUniform1i(entry->uniform_locations[GLES2_UNIFORM_TEXTURE], 0);
499 if (entry->uniform_locations[GLES2_UNIFORM_PROJECTION] != -1) {
500 data->glUniformMatrix4fv(entry->uniform_locations[GLES2_UNIFORM_PROJECTION], 1,
GL_FALSE, (
GLfloat *)entry->projection);
502 if (entry->uniform_locations[GLES2_UNIFORM_COLOR] != -1) {
503 data->glUniform4f(entry->uniform_locations[GLES2_UNIFORM_COLOR], 0.0f, 0.0f, 0.0f, 0.0f);
507 if (
data->program_cache.head) {
508 entry->next =
data->program_cache.head;
509 data->program_cache.head->prev = entry;
511 data->program_cache.tail = entry;
513 data->program_cache.head = entry;
514 ++
data->program_cache.count;
517 ++vertex->references;
518 ++fragment->references;
521 if (
data->program_cache.count > GLES2_MAX_CACHED_PROGRAMS) {
522 shaderEntry =
data->program_cache.tail->vertex_shader;
523 if (--shaderEntry->references <= 0) {
524 GLES2_EvictShader(
data, shaderEntry);
526 shaderEntry =
data->program_cache.tail->fragment_shader;
527 if (--shaderEntry->references <= 0) {
528 GLES2_EvictShader(
data, shaderEntry);
530 data->glDeleteProgram(
data->program_cache.tail->id);
531 data->program_cache.tail =
data->program_cache.tail->prev;
532 if (
data->program_cache.tail !=
NULL) {
534 data->program_cache.tail->next =
NULL;
536 --
data->program_cache.count;
541 static GLES2_ShaderCacheEntry *
542 GLES2_CacheShader(GLES2_RenderData *
data, GLES2_ShaderType
type)
544 const GLES2_Shader *
shader;
545 const GLES2_ShaderInstance *instance =
NULL;
546 GLES2_ShaderCacheEntry *entry =
NULL;
553 SDL_SetError(
"No shader matching the requested characteristics was found");
558 for (
i = 0;
i <
shader->instance_count && !instance; ++
i) {
559 for (
j = 0;
j <
data->shader_format_count && !instance; ++
j) {
563 if (
shader->instances[
i]->format !=
data->shader_formats[
j]) {
566 instance =
shader->instances[
i];
570 SDL_SetError(
"The specified shader cannot be loaded on the current platform");
575 entry =
data->shader_cache.head;
577 if (entry->instance == instance) {
587 entry = (GLES2_ShaderCacheEntry *)
SDL_calloc(1,
sizeof(GLES2_ShaderCacheEntry));
593 entry->instance = instance;
596 entry->id =
data->glCreateShader(instance->type);
597 if (instance->format == (
GLenum)-1) {
598 data->glShaderSource(entry->id, 1, (
const char **)(
char *)&instance->data,
NULL);
599 data->glCompileShader(entry->id);
602 data->glShaderBinary(1, &entry->id, instance->format, instance->data, instance->length);
605 if (!compileSuccessful) {
623 data->glDeleteShader(entry->id);
629 if (
data->shader_cache.head) {
630 entry->next =
data->shader_cache.head;
631 data->shader_cache.head->prev = entry;
633 data->shader_cache.head = entry;
634 ++
data->shader_cache.count;
639 GLES2_SelectProgram(GLES2_RenderData *
data, GLES2_ImageSource
source,
int w,
int h)
641 GLES2_ShaderCacheEntry *vertex =
NULL;
642 GLES2_ShaderCacheEntry *fragment =
NULL;
643 GLES2_ShaderType vtype, ftype;
644 GLES2_ProgramCacheEntry *
program;
647 vtype = GLES2_SHADER_VERTEX_DEFAULT;
649 case GLES2_IMAGESOURCE_SOLID:
650 ftype = GLES2_SHADER_FRAGMENT_SOLID_SRC;
652 case GLES2_IMAGESOURCE_TEXTURE_ABGR:
653 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_ABGR_SRC;
655 case GLES2_IMAGESOURCE_TEXTURE_ARGB:
656 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_ARGB_SRC;
658 case GLES2_IMAGESOURCE_TEXTURE_RGB:
659 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_RGB_SRC;
661 case GLES2_IMAGESOURCE_TEXTURE_BGR:
662 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_BGR_SRC;
664 case GLES2_IMAGESOURCE_TEXTURE_YUV:
667 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_YUV_JPEG_SRC;
670 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT601_SRC;
673 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT709_SRC;
680 case GLES2_IMAGESOURCE_TEXTURE_NV12:
683 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_JPEG_SRC;
686 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_BT601_SRC;
689 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_BT709_SRC;
696 case GLES2_IMAGESOURCE_TEXTURE_NV21:
699 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_JPEG_SRC;
702 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT601_SRC;
705 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT709_SRC;
712 case GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES:
713 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_EXTERNAL_OES_SRC;
720 vertex = GLES2_CacheShader(
data, vtype);
724 fragment = GLES2_CacheShader(
data, ftype);
730 if (
data->drawstate.program &&
731 data->drawstate.program->vertex_shader == vertex &&
732 data->drawstate.program->fragment_shader == fragment) {
737 program = GLES2_CacheProgram(
data, vertex, fragment);
751 if (vertex && vertex->references <= 0) {
752 GLES2_EvictShader(
data, vertex);
754 if (fragment && fragment->references <= 0) {
755 GLES2_EvictShader(
data, fragment);
821 GLfloat minx, miny, maxx, maxy;
822 GLfloat minu, maxu, minv, maxv;
833 maxx = dstrect->
x + dstrect->
w;
834 maxy = dstrect->
y + dstrect->
h;
868 const float radian_angle = (float)(M_PI * (360.0 -
angle) / 180.0);
871 const GLfloat centerx = center->
x + dstrect->
x;
872 const GLfloat centery = center->
y + dstrect->
y;
873 GLfloat minx, miny, maxx, maxy;
874 GLfloat minu, maxu, minv, maxv;
882 minx = dstrect->
x + dstrect->
w;
886 maxx = dstrect->
x + dstrect->
w;
890 miny = dstrect->
y + dstrect->
h;
894 maxy = dstrect->
y + dstrect->
h;
932 *(verts++) = centerx;
933 *(verts++) = centery;
934 *(verts++) = centerx;
935 *(verts++) = centery;
936 *(verts++) = centerx;
937 *(verts++) = centery;
938 *(verts++) = centerx;
939 *(verts++) = centery;
947 const SDL_bool was_copy_ex =
data->drawstate.is_copy_ex;
951 GLES2_ProgramCacheEntry *
program;
955 if (
data->drawstate.viewport_dirty) {
962 data->drawstate.projection[1][1] = (
data->drawstate.target ? 2.0f : -2.0f) /
viewport->
h;
963 data->drawstate.projection[3][1] =
data->drawstate.target ? -1.0f : 1.0f;
968 if (
data->drawstate.cliprect_enabled_dirty) {
969 if (!
data->drawstate.cliprect_enabled) {
977 if (
data->drawstate.cliprect_enabled &&
data->drawstate.cliprect_dirty) {
989 data->glDisableVertexAttribArray((
GLenum) GLES2_ATTRIBUTE_TEXCOORD);
992 data->glEnableVertexAttribArray((
GLenum) GLES2_ATTRIBUTE_TEXCOORD);
998 GLES2_TextureData *tdata = (GLES2_TextureData *)
texture->driverdata;
1001 data->glBindTexture(tdata->texture_type, tdata->texture_v);
1004 data->glBindTexture(tdata->texture_type, tdata->texture_u);
1007 }
else if (tdata->nv12) {
1009 data->glBindTexture(tdata->texture_type, tdata->texture_u);
1013 data->glBindTexture(tdata->texture_type, tdata->texture);
1029 if (
program->uniform_locations[GLES2_UNIFORM_PROJECTION] != -1) {
1036 if (
program->uniform_locations[GLES2_UNIFORM_COLOR] != -1) {
1038 const Uint8 r = (
data->drawstate.color >> 16) & 0xFF;
1039 const Uint8 g = (
data->drawstate.color >> 8) & 0xFF;
1040 const Uint8 b = (
data->drawstate.color >> 0) & 0xFF;
1041 const Uint8 a = (
data->drawstate.color >> 24) & 0xFF;
1042 data->glUniform4f(
program->uniform_locations[GLES2_UNIFORM_COLOR],
r * inv255f,
g * inv255f,
b * inv255f,
a * inv255f);
1047 if (blend !=
data->drawstate.blend) {
1059 data->drawstate.blend = blend;
1065 if (is_copy_ex != was_copy_ex) {
1067 data->glEnableVertexAttribArray((
GLenum) GLES2_ATTRIBUTE_ANGLE);
1068 data->glEnableVertexAttribArray((
GLenum) GLES2_ATTRIBUTE_CENTER);
1070 data->glDisableVertexAttribArray((
GLenum) GLES2_ATTRIBUTE_ANGLE);
1071 data->glDisableVertexAttribArray((
GLenum) GLES2_ATTRIBUTE_CENTER);
1073 data->drawstate.is_copy_ex = is_copy_ex;
1088 GLES2_ImageSource sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
1100 sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
1103 sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
1111 sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
1114 sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
1121 sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
1124 sourceType = GLES2_IMAGESOURCE_TEXTURE_BGR;
1127 sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
1134 sourceType = GLES2_IMAGESOURCE_TEXTURE_BGR;
1137 sourceType = GLES2_IMAGESOURCE_TEXTURE_RGB;
1140 sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
1146 sourceType = GLES2_IMAGESOURCE_TEXTURE_YUV;
1149 sourceType = GLES2_IMAGESOURCE_TEXTURE_NV12;
1152 sourceType = GLES2_IMAGESOURCE_TEXTURE_NV21;
1155 sourceType = GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES;
1161 sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
1166 sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
1169 sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
1172 sourceType = GLES2_IMAGESOURCE_TEXTURE_RGB;
1175 sourceType = GLES2_IMAGESOURCE_TEXTURE_BGR;
1179 sourceType = GLES2_IMAGESOURCE_TEXTURE_YUV;
1182 sourceType = GLES2_IMAGESOURCE_TEXTURE_NV12;
1185 sourceType = GLES2_IMAGESOURCE_TEXTURE_NV21;
1188 sourceType = GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES;
1203 const int vboidx =
data->current_vertex_buffer;
1204 const GLuint vbo =
data->vertex_buffers[vboidx];
1207 if (GLES2_ActivateRenderer(
renderer) < 0) {
1212 if (!
data->drawstate.target) {
1218 if (
data->vertex_buffer_size[vboidx] < vertsize) {
1220 data->vertex_buffer_size[vboidx] = vertsize;
1226 data->current_vertex_buffer++;
1228 data->current_vertex_buffer = 0;
1238 data->drawstate.color = ((
a << 24) | (
r << 16) | (
g << 8) |
b);
1271 if (
color !=
data->drawstate.clear_color) {
1276 data->glClearColor(fr, fg, fb, fa);
1280 if (
data->drawstate.cliprect_enabled) {
1300 if (
count > 2 && (verts[0] == verts[(
count-1)*2]) && (verts[1] == verts[(
count*2)-1])) {
1325 if (SetCopyState(
renderer, cmd) == 0) {
1338 return GL_CheckError(
"",
renderer);
1351 GLES2_ShaderCacheEntry *entry;
1352 GLES2_ShaderCacheEntry *next;
1353 entry =
data->shader_cache.head;
1355 data->glDeleteShader(entry->id);
1362 GLES2_ProgramCacheEntry *entry;
1363 GLES2_ProgramCacheEntry *next;
1364 entry =
data->program_cache.head;
1366 data->glDeleteProgram(entry->id);
1373 if (
data->context) {
1374 while (
data->framebuffers) {
1375 GLES2_FBOList *nextnode =
data->framebuffers->next;
1376 data->glDeleteFramebuffers(1, &
data->framebuffers->FBO);
1379 data->framebuffers = nextnode;
1398 GLES2_TextureData *
data;
1405 renderdata->drawstate.texture =
NULL;
1424 #ifdef GL_TEXTURE_EXTERNAL_OES
1436 return SDL_SetError(
"Unsupported texture access for SDL_PIXELFORMAT_EXTERNAL_OES");
1440 data = (GLES2_TextureData *)
SDL_calloc(1,
sizeof(GLES2_TextureData));
1445 #ifdef GL_TEXTURE_EXTERNAL_OES
1454 data->texture_u = 0;
1455 data->texture_v = 0;
1466 }
else if (
data->nv12) {
1471 if (!
data->pixel_data) {
1481 renderdata->glGenTextures(1, &
data->texture_v);
1482 if (GL_CheckError(
"glGenTexures()",
renderer) < 0) {
1486 renderdata->glBindTexture(
data->texture_type,
data->texture_v);
1493 renderdata->glGenTextures(1, &
data->texture_u);
1494 if (GL_CheckError(
"glGenTexures()",
renderer) < 0) {
1498 renderdata->glBindTexture(
data->texture_type,
data->texture_u);
1504 if (GL_CheckError(
"glTexImage2D()",
renderer) < 0) {
1507 }
else if (
data->nv12) {
1508 renderdata->glGenTextures(1, &
data->texture_u);
1509 if (GL_CheckError(
"glGenTexures()",
renderer) < 0) {
1513 renderdata->glBindTexture(
data->texture_type,
data->texture_u);
1519 if (GL_CheckError(
"glTexImage2D()",
renderer) < 0) {
1524 renderdata->glGenTextures(1, &
data->texture);
1525 if (GL_CheckError(
"glGenTexures()",
renderer) < 0) {
1530 renderdata->glBindTexture(
data->texture_type,
data->texture);
1537 if (GL_CheckError(
"glTexImage2D()",
renderer) < 0) {
1548 return GL_CheckError(
"",
renderer);
1552 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)
1559 if ((
width == 0) || (
height == 0) || (bpp == 0)) {
1564 src_pitch =
width * bpp;
1566 if (pitch != src_pitch) {
1590 const void *
pixels,
int pitch)
1593 GLES2_TextureData *tdata = (GLES2_TextureData *)
texture->driverdata;
1605 data->glBindTexture(tdata->texture_type, tdata->texture);
1606 GLES2_TexSubImage2D(
data, tdata->texture_type,
1611 tdata->pixel_format,
1619 data->glBindTexture(tdata->texture_type, tdata->texture_v);
1621 data->glBindTexture(tdata->texture_type, tdata->texture_u);
1623 GLES2_TexSubImage2D(
data, tdata->texture_type,
1628 tdata->pixel_format,
1630 pixels, (pitch + 1) / 2, 1);
1636 data->glBindTexture(tdata->texture_type, tdata->texture_u);
1638 data->glBindTexture(tdata->texture_type, tdata->texture_v);
1640 GLES2_TexSubImage2D(
data, tdata->texture_type,
1645 tdata->pixel_format,
1647 pixels, (pitch + 1) / 2, 1);
1648 }
else if (tdata->nv12) {
1651 data->glBindTexture(tdata->texture_type, tdata->texture_u);
1652 GLES2_TexSubImage2D(
data, tdata->texture_type,
1659 pixels, 2 * ((pitch + 1) / 2), 2);
1662 return GL_CheckError(
"glTexSubImage2D()",
renderer);
1668 const Uint8 *Yplane,
int Ypitch,
1669 const Uint8 *Uplane,
int Upitch,
1670 const Uint8 *Vplane,
int Vpitch)
1673 GLES2_TextureData *tdata = (GLES2_TextureData *)
texture->driverdata;
1684 data->glBindTexture(tdata->texture_type, tdata->texture_v);
1685 GLES2_TexSubImage2D(
data, tdata->texture_type,
1690 tdata->pixel_format,
1694 data->glBindTexture(tdata->texture_type, tdata->texture_u);
1695 GLES2_TexSubImage2D(
data, tdata->texture_type,
1700 tdata->pixel_format,
1704 data->glBindTexture(tdata->texture_type, tdata->texture);
1705 GLES2_TexSubImage2D(
data, tdata->texture_type,
1710 tdata->pixel_format,
1714 return GL_CheckError(
"glTexSubImage2D()",
renderer);
1719 void **
pixels,
int *pitch)
1721 GLES2_TextureData *tdata = (GLES2_TextureData *)
texture->driverdata;
1725 (tdata->pitch *
rect->
y) +
1727 *pitch = tdata->pitch;
1735 GLES2_TextureData *tdata = (GLES2_TextureData *)
texture->driverdata;
1750 GLES2_TextureData *texturedata =
NULL;
1758 texturedata = (GLES2_TextureData *)
texture->driverdata;
1765 return SDL_SetError(
"glFramebufferTexture2D() failed");
1775 GLES2_TextureData *tdata = (GLES2_TextureData *)
texture->driverdata;
1788 data->glDeleteTextures(1, &tdata->texture);
1789 if (tdata->texture_v) {
1790 data->glDeleteTextures(1, &tdata->texture_v);
1792 if (tdata->texture_u) {
1793 data->glDeleteTextures(1, &tdata->texture_u);
1829 if (GL_CheckError(
"glReadPixels()",
renderer) < 0) {
1852 temp_format, temp_pixels, temp_pitch,
1853 pixel_format,
pixels, pitch);
1876 GLES2_TextureData *texturedata = (GLES2_TextureData *)
texture->driverdata;
1879 data->glBindTexture(texturedata->texture_type, texturedata->texture);
1895 GLES2_TextureData *texturedata = (GLES2_TextureData *)
texture->driverdata;
1898 data->glBindTexture(texturedata->texture_type, 0);
1910 #define GL_NVIDIA_PLATFORM_BINARY_NV 0x890B
1918 GLES2_RenderData *
data;
1924 GLint window_framebuffer;
1926 int profile_mask = 0, major = 0, minor = 0;
1962 data = (GLES2_RenderData *)
SDL_calloc(1,
sizeof(GLES2_RenderData));
1975 if (!
data->context) {
1987 if (GLES2_LoadFunctions(
data) < 0) {
2036 if (!
data->shader_formats) {
2041 data->shader_format_count = nFormats;
2043 data->shader_formats[0] = GL_NVIDIA_PLATFORM_BINARY_NV;
2047 data->shader_formats[nFormats - 1] = (
GLenum)-1;
2056 data->window_framebuffer = (
GLuint)window_framebuffer;
2087 #ifdef GL_TEXTURE_EXTERNAL_OES
2096 data->glEnableVertexAttribArray(GLES2_ATTRIBUTE_POSITION);
2097 data->glDisableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD);
2099 data->glClearColor(1.0
f, 1.0
f, 1.0
f, 1.0
f);
2102 data->drawstate.color = 0xFFFFFFFF;
2103 data->drawstate.clear_color = 0xFFFFFFFF;
2104 data->drawstate.projection[3][0] = -1.0f;
2105 data->drawstate.projection[3][3] = 1.0f;
2112 if (changed_window) {
2123 GLES2_CreateRenderer,