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" 40 #define SDL_GLES2_USE_VBOS 1 42 #define SDL_GLES2_USE_VBOS 0 48 #define RENDERER_CONTEXT_MAJOR 2 49 #define RENDERER_CONTEXT_MINOR 0 81 typedef struct GLES2_FBOList GLES2_FBOList;
90 typedef struct GLES2_TextureData
106 typedef struct GLES2_ShaderCacheEntry
109 GLES2_ShaderType
type;
110 const GLES2_ShaderInstance *instance;
112 Uint8 modulation_r, modulation_g, modulation_b, modulation_a;
113 struct GLES2_ShaderCacheEntry *prev;
114 struct GLES2_ShaderCacheEntry *next;
115 } GLES2_ShaderCacheEntry;
117 typedef struct GLES2_ShaderCache
120 GLES2_ShaderCacheEntry *
head;
123 typedef struct GLES2_ProgramCacheEntry
126 GLES2_ShaderCacheEntry *vertex_shader;
127 GLES2_ShaderCacheEntry *fragment_shader;
128 GLuint uniform_locations[16];
129 Uint8 color_r, color_g, color_b, color_a;
130 Uint8 modulation_r, modulation_g, modulation_b, modulation_a;
132 struct GLES2_ProgramCacheEntry *prev;
133 struct GLES2_ProgramCacheEntry *next;
134 } GLES2_ProgramCacheEntry;
136 typedef struct GLES2_ProgramCache
139 GLES2_ProgramCacheEntry *
head;
140 GLES2_ProgramCacheEntry *
tail;
141 } GLES2_ProgramCache;
145 GLES2_ATTRIBUTE_POSITION = 0,
146 GLES2_ATTRIBUTE_TEXCOORD = 1,
147 GLES2_ATTRIBUTE_ANGLE = 2,
148 GLES2_ATTRIBUTE_CENTER = 3,
153 GLES2_UNIFORM_PROJECTION,
154 GLES2_UNIFORM_TEXTURE,
155 GLES2_UNIFORM_MODULATION,
157 GLES2_UNIFORM_TEXTURE_U,
158 GLES2_UNIFORM_TEXTURE_V
163 GLES2_IMAGESOURCE_SOLID,
164 GLES2_IMAGESOURCE_TEXTURE_ABGR,
165 GLES2_IMAGESOURCE_TEXTURE_ARGB,
166 GLES2_IMAGESOURCE_TEXTURE_RGB,
167 GLES2_IMAGESOURCE_TEXTURE_BGR,
168 GLES2_IMAGESOURCE_TEXTURE_YUV,
169 GLES2_IMAGESOURCE_TEXTURE_NV12,
170 GLES2_IMAGESOURCE_TEXTURE_NV21,
171 GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES
174 typedef struct GLES2_DriverContext
185 #define SDL_PROC(ret,func,params) ret (APIENTRY *func) params; 189 GLuint window_framebuffer;
191 int shader_format_count;
193 GLES2_ShaderCache shader_cache;
194 GLES2_ProgramCache program_cache;
195 GLES2_ProgramCacheEntry *current_program;
196 Uint8 clear_r, clear_g, clear_b, clear_a;
198 #if SDL_GLES2_USE_VBOS 202 } GLES2_DriverContext;
204 #define GLES2_MAX_CACHED_PROGRAMS 8 208 GL_TranslateError (
GLenum error)
210 #define GL_ERROR_TRANSLATE(e) case e: return #e; 220 #undef GL_ERROR_TRANSLATE 226 GLES2_DriverContext *
data = (GLES2_DriverContext *) renderer->
driverdata;
228 if (!data->debug_enabled) {
237 GL_CheckAllErrors (
const char *prefix,
SDL_Renderer *renderer,
const char *file,
int line,
const char *
function)
239 GLES2_DriverContext *data = (GLES2_DriverContext *) renderer->
driverdata;
242 if (!data->debug_enabled) {
247 GLenum error = data->glGetError();
249 if (prefix ==
NULL || prefix[0] ==
'\0') {
252 SDL_SetError(
"%s: %s (%d): %s %s (0x%X)", prefix, file, line,
function, GL_TranslateError(error), error);
262 #define GL_CheckError(prefix, renderer) 264 #define GL_CheckError(prefix, renderer) GL_CheckAllErrors(prefix, renderer, SDL_FILE, SDL_LINE, SDL_FUNCTION) 272 static int GLES2_ActivateRenderer(
SDL_Renderer *renderer);
275 static int GLES2_UpdateViewport(
SDL_Renderer * renderer);
276 static void GLES2_DestroyRenderer(
SDL_Renderer *renderer);
277 static int GLES2_SetOrthographicProjection(
SDL_Renderer *renderer);
282 static int GLES2_LoadFunctions(GLES2_DriverContext * data)
284 #if SDL_VIDEO_DRIVER_UIKIT 285 #define __SDL_NOGETPROCADDR__ 286 #elif SDL_VIDEO_DRIVER_ANDROID 287 #define __SDL_NOGETPROCADDR__ 288 #elif SDL_VIDEO_DRIVER_PANDORA 289 #define __SDL_NOGETPROCADDR__ 292 #if defined __SDL_NOGETPROCADDR__ 293 #define SDL_PROC(ret,func,params) data->func=func; 295 #define SDL_PROC(ret,func,params) \ 297 data->func = SDL_GL_GetProcAddress(#func); \ 298 if ( ! data->func ) { \ 299 return SDL_SetError("Couldn't load GLES2 function %s: %s", #func, SDL_GetError()); \ 309 static GLES2_FBOList *
312 GLES2_FBOList *
result = data->framebuffers;
313 while ((result) && ((result->w != w) || (result->h != h)) ) {
314 result = result->next;
316 if (result ==
NULL) {
320 data->glGenFramebuffers(1, &result->FBO);
321 result->next = data->framebuffers;
322 data->framebuffers =
result;
330 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
332 if (SDL_CurrentContext != data->context) {
334 data->current_program =
NULL;
339 SDL_CurrentContext = data->context;
341 GLES2_UpdateViewport(renderer);
344 GL_ClearErrors(renderer);
352 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
358 SDL_CurrentContext =
NULL;
368 GLES2_GetOutputSize(
SDL_Renderer * renderer,
int *w,
int *h)
440 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
442 if (SDL_CurrentContext != data->context) {
458 if (data->current_program) {
459 GLES2_SetOrthographicProjection(renderer);
461 return GL_CheckError(
"", renderer);
467 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
469 if (SDL_CurrentContext != data->context) {
483 data->glScissor(renderer->
viewport.
x + rect->
x, h - renderer->
viewport.
y - rect->
y - rect->
h, rect->
w, rect->
h);
494 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
498 GLES2_ActivateRenderer(renderer);
501 GLES2_ShaderCacheEntry *entry;
502 GLES2_ShaderCacheEntry *next;
503 entry = data->shader_cache.head;
505 data->glDeleteShader(entry->id);
512 GLES2_ProgramCacheEntry *entry;
513 GLES2_ProgramCacheEntry *next;
514 entry = data->program_cache.head;
516 data->glDeleteProgram(entry->id);
523 while (data->framebuffers) {
524 GLES2_FBOList *nextnode = data->framebuffers->next;
525 data->glDeleteFramebuffers(1, &data->framebuffers->FBO);
526 GL_CheckError(
"", renderer);
528 data->framebuffers = nextnode;
544 const void *
pixels,
int pitch);
547 const Uint8 *Yplane,
int Ypitch,
548 const Uint8 *Uplane,
int Upitch,
549 const Uint8 *Vplane,
int Vpitch);
551 void **
pixels,
int *pitch);
561 if (!hint || *hint ==
'0' ||
SDL_strcasecmp(hint,
"nearest") == 0) {
571 GLES2_DriverContext *renderdata = (GLES2_DriverContext *)renderer->
driverdata;
572 GLES2_TextureData *data;
577 GLES2_ActivateRenderer(renderer);
596 #ifdef GL_TEXTURE_EXTERNAL_OES 608 return SDL_SetError(
"Unsupported texture access for SDL_PIXELFORMAT_EXTERNAL_OES");
612 data = (GLES2_TextureData *)
SDL_calloc(1,
sizeof(GLES2_TextureData));
617 #ifdef GL_TEXTURE_EXTERNAL_OES 622 data->pixel_format =
format;
623 data->pixel_type =
type;
634 size = texture->
h * data->pitch;
637 size += 2 * ((texture->
h + 1) / 2) * ((data->pitch + 1) / 2);
641 size += 2 * ((texture->
h + 1) / 2) * ((data->pitch + 1) / 2);
644 if (!data->pixel_data) {
651 GL_CheckError(
"", renderer);
654 renderdata->glGenTextures(1, &data->texture_v);
655 if (GL_CheckError(
"glGenTexures()", renderer) < 0) {
659 renderdata->glBindTexture(data->texture_type, data->texture_v);
664 renderdata->glTexImage2D(data->texture_type, 0,
format, (texture->
w + 1) / 2, (texture->
h + 1) / 2, 0,
format,
type,
NULL);
666 renderdata->glGenTextures(1, &data->texture_u);
667 if (GL_CheckError(
"glGenTexures()", renderer) < 0) {
671 renderdata->glBindTexture(data->texture_type, data->texture_u);
676 renderdata->glTexImage2D(data->texture_type, 0,
format, (texture->
w + 1) / 2, (texture->
h + 1) / 2, 0,
format,
type,
NULL);
677 if (GL_CheckError(
"glTexImage2D()", renderer) < 0) {
683 renderdata->glGenTextures(1, &data->texture_u);
684 if (GL_CheckError(
"glGenTexures()", renderer) < 0) {
688 renderdata->glBindTexture(data->texture_type, data->texture_u);
694 if (GL_CheckError(
"glTexImage2D()", renderer) < 0) {
699 renderdata->glGenTextures(1, &data->texture);
700 if (GL_CheckError(
"glGenTexures()", renderer) < 0) {
705 renderdata->glBindTexture(data->texture_type, data->texture);
712 if (GL_CheckError(
"glTexImage2D()", renderer) < 0) {
718 data->fbo = GLES2_GetFBO(renderer->
driverdata, texture->
w, texture->
h);
723 return GL_CheckError(
"", renderer);
727 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)
735 src_pitch = width * bpp;
736 src = (
Uint8 *)pixels;
737 if (pitch != src_pitch) {
747 pixels = (
Uint8 *)pixels + pitch;
752 data->glTexSubImage2D(target, 0, xoffset, yoffset, width, height, format, type, src);
761 const void *pixels,
int pitch)
763 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
764 GLES2_TextureData *tdata = (GLES2_TextureData *)texture->
driverdata;
766 GLES2_ActivateRenderer(renderer);
769 if (rect->
w <= 0 || rect->
h <= 0) {
774 data->glBindTexture(tdata->texture_type, tdata->texture);
775 GLES2_TexSubImage2D(data, tdata->texture_type,
786 pixels = (
const void*)((
const Uint8*)pixels + rect->
h * pitch);
788 data->glBindTexture(tdata->texture_type, tdata->texture_v);
790 data->glBindTexture(tdata->texture_type, tdata->texture_u);
792 GLES2_TexSubImage2D(data, tdata->texture_type,
799 pixels, (pitch + 1) / 2, 1);
803 pixels = (
const void*)((
const Uint8*)pixels + ((rect->
h + 1) / 2) * ((pitch + 1)/2));
805 data->glBindTexture(tdata->texture_type, tdata->texture_u);
807 data->glBindTexture(tdata->texture_type, tdata->texture_v);
809 GLES2_TexSubImage2D(data, tdata->texture_type,
816 pixels, (pitch + 1) / 2, 1);
821 pixels = (
const void*)((
const Uint8*)pixels + rect->
h * pitch);
822 data->glBindTexture(tdata->texture_type, tdata->texture_u);
823 GLES2_TexSubImage2D(data, tdata->texture_type,
830 pixels, 2 * ((pitch + 1) / 2), 2);
833 return GL_CheckError(
"glTexSubImage2D()", renderer);
839 const Uint8 *Yplane,
int Ypitch,
840 const Uint8 *Uplane,
int Upitch,
841 const Uint8 *Vplane,
int Vpitch)
843 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
844 GLES2_TextureData *tdata = (GLES2_TextureData *)texture->
driverdata;
846 GLES2_ActivateRenderer(renderer);
849 if (rect->
w <= 0 || rect->
h <= 0) {
853 data->glBindTexture(tdata->texture_type, tdata->texture_v);
854 GLES2_TexSubImage2D(data, tdata->texture_type,
863 data->glBindTexture(tdata->texture_type, tdata->texture_u);
864 GLES2_TexSubImage2D(data, tdata->texture_type,
873 data->glBindTexture(tdata->texture_type, tdata->texture);
874 GLES2_TexSubImage2D(data, tdata->texture_type,
883 return GL_CheckError(
"glTexSubImage2D()", renderer);
888 void **pixels,
int *pitch)
890 GLES2_TextureData *tdata = (GLES2_TextureData *)texture->
driverdata;
893 *pixels = (
Uint8 *)tdata->pixel_data +
894 (tdata->pitch * rect->
y) +
896 *pitch = tdata->pitch;
904 GLES2_TextureData *tdata = (GLES2_TextureData *)texture->
driverdata;
912 GLES2_UpdateTexture(renderer, texture, &rect, tdata->pixel_data, tdata->pitch);
918 GLES2_DriverContext *data = (GLES2_DriverContext *) renderer->
driverdata;
919 GLES2_TextureData *texturedata =
NULL;
922 if (texture ==
NULL) {
923 data->glBindFramebuffer(
GL_FRAMEBUFFER, data->window_framebuffer);
925 texturedata = (GLES2_TextureData *) texture->
driverdata;
941 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
942 GLES2_TextureData *tdata = (GLES2_TextureData *)texture->
driverdata;
944 GLES2_ActivateRenderer(renderer);
948 data->glDeleteTextures(1, &tdata->texture);
949 if (tdata->texture_v) {
950 data->glDeleteTextures(1, &tdata->texture_v);
952 if (tdata->texture_u) {
953 data->glDeleteTextures(1, &tdata->texture_u);
965 static GLES2_ShaderCacheEntry *GLES2_CacheShader(
SDL_Renderer *renderer, GLES2_ShaderType type);
966 static void GLES2_EvictShader(
SDL_Renderer *renderer, GLES2_ShaderCacheEntry *entry);
967 static GLES2_ProgramCacheEntry *GLES2_CacheProgram(
SDL_Renderer *renderer,
968 GLES2_ShaderCacheEntry *vertex,
969 GLES2_ShaderCacheEntry *fragment);
970 static int GLES2_SelectProgram(
SDL_Renderer *renderer, GLES2_ImageSource
source,
int w,
int h);
972 static GLES2_ProgramCacheEntry *
973 GLES2_CacheProgram(
SDL_Renderer *renderer, GLES2_ShaderCacheEntry *vertex,
974 GLES2_ShaderCacheEntry *fragment)
976 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
977 GLES2_ProgramCacheEntry *entry;
978 GLES2_ShaderCacheEntry *shaderEntry;
979 GLint linkSuccessful;
982 entry = data->program_cache.head;
984 if (entry->vertex_shader == vertex && entry->fragment_shader == fragment) {
990 if (data->program_cache.head != entry) {
992 entry->next->prev = entry->prev;
995 entry->prev->next = entry->next;
998 entry->next = data->program_cache.head;
999 data->program_cache.head->prev = entry;
1000 data->program_cache.head = entry;
1006 entry = (GLES2_ProgramCacheEntry *)
SDL_calloc(1,
sizeof(GLES2_ProgramCacheEntry));
1011 entry->vertex_shader = vertex;
1012 entry->fragment_shader = fragment;
1015 entry->id = data->glCreateProgram();
1016 data->glAttachShader(entry->id, vertex->id);
1017 data->glAttachShader(entry->id, fragment->id);
1018 data->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_POSITION,
"a_position");
1019 data->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_TEXCOORD,
"a_texCoord");
1020 data->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_ANGLE,
"a_angle");
1021 data->glBindAttribLocation(entry->id, GLES2_ATTRIBUTE_CENTER,
"a_center");
1022 data->glLinkProgram(entry->id);
1023 data->glGetProgramiv(entry->id,
GL_LINK_STATUS, &linkSuccessful);
1024 if (!linkSuccessful) {
1025 data->glDeleteProgram(entry->id);
1032 entry->uniform_locations[GLES2_UNIFORM_PROJECTION] =
1033 data->glGetUniformLocation(entry->id,
"u_projection");
1034 entry->uniform_locations[GLES2_UNIFORM_TEXTURE_V] =
1035 data->glGetUniformLocation(entry->id,
"u_texture_v");
1036 entry->uniform_locations[GLES2_UNIFORM_TEXTURE_U] =
1037 data->glGetUniformLocation(entry->id,
"u_texture_u");
1038 entry->uniform_locations[GLES2_UNIFORM_TEXTURE] =
1039 data->glGetUniformLocation(entry->id,
"u_texture");
1040 entry->uniform_locations[GLES2_UNIFORM_MODULATION] =
1041 data->glGetUniformLocation(entry->id,
"u_modulation");
1042 entry->uniform_locations[GLES2_UNIFORM_COLOR] =
1043 data->glGetUniformLocation(entry->id,
"u_color");
1045 entry->modulation_r = entry->modulation_g = entry->modulation_b = entry->modulation_a = 255;
1046 entry->color_r = entry->color_g = entry->color_b = entry->color_a = 255;
1048 data->glUseProgram(entry->id);
1049 data->glUniform1i(entry->uniform_locations[GLES2_UNIFORM_TEXTURE_V], 2);
1050 data->glUniform1i(entry->uniform_locations[GLES2_UNIFORM_TEXTURE_U], 1);
1051 data->glUniform1i(entry->uniform_locations[GLES2_UNIFORM_TEXTURE], 0);
1052 data->glUniformMatrix4fv(entry->uniform_locations[GLES2_UNIFORM_PROJECTION], 1,
GL_FALSE, (
GLfloat *)entry->projection);
1053 data->glUniform4f(entry->uniform_locations[GLES2_UNIFORM_MODULATION], 1.0f, 1.0f, 1.0f, 1.0f);
1054 data->glUniform4f(entry->uniform_locations[GLES2_UNIFORM_COLOR], 1.0f, 1.0f, 1.0f, 1.0f);
1057 if (data->program_cache.head) {
1058 entry->next = data->program_cache.head;
1059 data->program_cache.head->prev = entry;
1061 data->program_cache.tail = entry;
1063 data->program_cache.head = entry;
1064 ++data->program_cache.count;
1067 ++vertex->references;
1068 ++fragment->references;
1071 if (data->program_cache.count > GLES2_MAX_CACHED_PROGRAMS) {
1072 shaderEntry = data->program_cache.tail->vertex_shader;
1073 if (--shaderEntry->references <= 0) {
1074 GLES2_EvictShader(renderer, shaderEntry);
1076 shaderEntry = data->program_cache.tail->fragment_shader;
1077 if (--shaderEntry->references <= 0) {
1078 GLES2_EvictShader(renderer, shaderEntry);
1080 data->glDeleteProgram(data->program_cache.tail->id);
1081 data->program_cache.tail = data->program_cache.tail->prev;
1082 SDL_free(data->program_cache.tail->next);
1083 data->program_cache.tail->next =
NULL;
1084 --data->program_cache.count;
1089 static GLES2_ShaderCacheEntry *
1090 GLES2_CacheShader(
SDL_Renderer *renderer, GLES2_ShaderType type)
1092 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
1093 const GLES2_Shader *
shader;
1094 const GLES2_ShaderInstance *instance =
NULL;
1095 GLES2_ShaderCacheEntry *entry =
NULL;
1100 shader = GLES2_GetShader(type);
1102 SDL_SetError(
"No shader matching the requested characteristics was found");
1107 for (i = 0; i <
shader->instance_count && !instance; ++
i) {
1108 for (
j = 0;
j < data->shader_format_count && !instance; ++
j) {
1109 if (!
shader->instances[i]) {
1112 if (
shader->instances[i]->format != data->shader_formats[
j]) {
1115 instance =
shader->instances[
i];
1119 SDL_SetError(
"The specified shader cannot be loaded on the current platform");
1124 entry = data->shader_cache.head;
1126 if (entry->instance == instance) {
1129 entry = entry->next;
1136 entry = (GLES2_ShaderCacheEntry *)
SDL_calloc(1,
sizeof(GLES2_ShaderCacheEntry));
1142 entry->instance = instance;
1145 entry->id = data->glCreateShader(instance->type);
1146 if (instance->format == (
GLenum)-1) {
1147 data->glShaderSource(entry->id, 1, (
const char **)(
char *)&instance->data,
NULL);
1148 data->glCompileShader(entry->id);
1151 data->glShaderBinary(1, &entry->id, instance->format, instance->data, instance->length);
1154 if (!compileSuccessful) {
1162 data->glGetShaderInfoLog(entry->id, length, &length, info);
1171 data->glDeleteShader(entry->id);
1177 if (data->shader_cache.head) {
1178 entry->next = data->shader_cache.head;
1179 data->shader_cache.head->prev = entry;
1181 data->shader_cache.head = entry;
1182 ++data->shader_cache.count;
1187 GLES2_EvictShader(
SDL_Renderer *renderer, GLES2_ShaderCacheEntry *entry)
1189 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
1193 entry->next->prev = entry->prev;
1196 entry->prev->next = entry->next;
1198 if (data->shader_cache.head == entry) {
1199 data->shader_cache.head = entry->next;
1201 --data->shader_cache.count;
1204 data->glDeleteShader(entry->id);
1211 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
1212 GLES2_ShaderCacheEntry *vertex =
NULL;
1213 GLES2_ShaderCacheEntry *fragment =
NULL;
1214 GLES2_ShaderType vtype, ftype;
1215 GLES2_ProgramCacheEntry *
program;
1218 vtype = GLES2_SHADER_VERTEX_DEFAULT;
1220 case GLES2_IMAGESOURCE_SOLID:
1221 ftype = GLES2_SHADER_FRAGMENT_SOLID_SRC;
1223 case GLES2_IMAGESOURCE_TEXTURE_ABGR:
1224 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_ABGR_SRC;
1226 case GLES2_IMAGESOURCE_TEXTURE_ARGB:
1227 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_ARGB_SRC;
1229 case GLES2_IMAGESOURCE_TEXTURE_RGB:
1230 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_RGB_SRC;
1232 case GLES2_IMAGESOURCE_TEXTURE_BGR:
1233 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_BGR_SRC;
1235 case GLES2_IMAGESOURCE_TEXTURE_YUV:
1238 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_YUV_JPEG_SRC;
1241 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT601_SRC;
1244 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT709_SRC;
1251 case GLES2_IMAGESOURCE_TEXTURE_NV12:
1254 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_JPEG_SRC;
1257 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_BT601_SRC;
1260 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV12_BT709_SRC;
1267 case GLES2_IMAGESOURCE_TEXTURE_NV21:
1270 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_JPEG_SRC;
1273 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT601_SRC;
1276 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT709_SRC;
1283 case GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES:
1284 ftype = GLES2_SHADER_FRAGMENT_TEXTURE_EXTERNAL_OES_SRC;
1291 vertex = GLES2_CacheShader(renderer, vtype);
1295 fragment = GLES2_CacheShader(renderer, ftype);
1301 if (data->current_program &&
1302 data->current_program->vertex_shader == vertex &&
1303 data->current_program->fragment_shader == fragment) {
1308 program = GLES2_CacheProgram(renderer, vertex, fragment);
1314 data->glUseProgram(
program->id);
1317 data->current_program =
program;
1320 if (GLES2_SetOrthographicProjection(renderer) < 0) {
1327 if (vertex && vertex->references <= 0) {
1328 GLES2_EvictShader(renderer, vertex);
1330 if (fragment && fragment->references <= 0) {
1331 GLES2_EvictShader(renderer, fragment);
1333 data->current_program =
NULL;
1338 GLES2_SetOrthographicProjection(
SDL_Renderer *renderer)
1340 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
1348 projection[0][0] = 2.0f / renderer->
viewport.
w;
1349 projection[0][1] = 0.0f;
1350 projection[0][2] = 0.0f;
1351 projection[0][3] = 0.0f;
1352 projection[1][0] = 0.0f;
1354 projection[1][1] = 2.0f / renderer->
viewport.
h;
1356 projection[1][1] = -2.0f / renderer->
viewport.
h;
1358 projection[1][2] = 0.0f;
1359 projection[1][3] = 0.0f;
1360 projection[2][0] = 0.0f;
1361 projection[2][1] = 0.0f;
1362 projection[2][2] = 0.0f;
1363 projection[2][3] = 0.0f;
1364 projection[3][0] = -1.0f;
1366 projection[3][1] = -1.0f;
1368 projection[3][1] = 1.0f;
1370 projection[3][2] = 0.0f;
1371 projection[3][3] = 1.0f;
1374 if (
SDL_memcmp(data->current_program->projection, projection, sizeof (projection)) != 0) {
1375 const GLuint locProjection = data->current_program->uniform_locations[GLES2_UNIFORM_PROJECTION];
1376 data->glUniformMatrix4fv(locProjection, 1,
GL_FALSE, (
GLfloat *)projection);
1377 SDL_memcpy(data->current_program->projection, projection, sizeof (projection));
1387 static const float inv255f = 1.0f / 255.0f;
1399 Uint32 pixel_format,
void * pixels,
int pitch);
1400 static void GLES2_RenderPresent(
SDL_Renderer *renderer);
1409 return (Pixel1 == Pixel2);
1417 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
1419 GLES2_ActivateRenderer(renderer);
1421 if (!CompareColors(data->clear_r, data->clear_g, data->clear_b, data->clear_a,
1422 renderer->
r, renderer->
g, renderer->
b, renderer->
a)) {
1438 data->glClearColor((
GLfloat) r * inv255f,
1442 data->clear_r = renderer->
r;
1443 data->clear_g = renderer->
g;
1444 data->clear_b = renderer->
b;
1445 data->clear_a = renderer->
a;
1462 GLES2_SetBlendMode(GLES2_DriverContext *data,
SDL_BlendMode blendMode)
1464 if (blendMode != data->current.blendMode) {
1483 if (enabled != data->current.tex_coords) {
1485 data->glEnableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD);
1487 data->glDisableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD);
1489 data->current.tex_coords =
enabled;
1496 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
1497 GLES2_ProgramCacheEntry *
program;
1500 GLES2_ActivateRenderer(renderer);
1502 GLES2_SetBlendMode(data, renderer->
blendMode);
1507 if (GLES2_SelectProgram(renderer, GLES2_IMAGESOURCE_SOLID, 0, 0) < 0) {
1525 program = data->current_program;
1528 data->glUniform4f(
program->uniform_locations[GLES2_UNIFORM_COLOR], r * inv255f, g * inv255f, b * inv255f, a * inv255f);
1539 GLES2_UpdateVertexBuffer(
SDL_Renderer *renderer, GLES2_Attribute attr,
1540 const void *vertexData,
size_t dataSizeInBytes)
1542 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
1544 #
if !SDL_GLES2_USE_VBOS
1545 data->glVertexAttribPointer(attr, attr == GLES2_ATTRIBUTE_ANGLE ? 1 : 2,
GL_FLOAT,
GL_FALSE, 0, vertexData);
1547 if (!data->vertex_buffers[attr]) {
1548 data->glGenBuffers(1, &data->vertex_buffers[attr]);
1553 if (data->vertex_buffer_size[attr] < dataSizeInBytes) {
1555 data->vertex_buffer_size[attr] = dataSizeInBytes;
1557 data->glBufferSubData(
GL_ARRAY_BUFFER, 0, dataSizeInBytes, vertexData);
1560 data->glVertexAttribPointer(attr, attr == GLES2_ATTRIBUTE_ANGLE ? 1 : 2,
GL_FLOAT,
GL_FALSE, 0, 0);
1569 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
1573 if (GLES2_SetDrawingState(renderer) < 0) {
1579 for (idx = 0; idx <
count; ++idx) {
1583 vertices[idx * 2] =
x;
1584 vertices[(idx * 2) + 1] = y;
1587 GLES2_UpdateVertexBuffer(renderer, GLES2_ATTRIBUTE_POSITION, vertices, count * 2 *
sizeof(
GLfloat));
1588 data->glDrawArrays(
GL_POINTS, 0, count);
1596 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
1600 if (GLES2_SetDrawingState(renderer) < 0) {
1606 for (idx = 0; idx <
count; ++idx) {
1610 vertices[idx * 2] =
x;
1611 vertices[(idx * 2) + 1] = y;
1614 GLES2_UpdateVertexBuffer(renderer, GLES2_ATTRIBUTE_POSITION, vertices, count * 2 *
sizeof(
GLfloat));
1619 points[0].
x != points[count-1].
x || points[0].y != points[count-1].y) {
1620 data->glDrawArrays(
GL_POINTS, count-1, 1);
1624 return GL_CheckError(
"", renderer);
1630 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
1634 if (GLES2_SetDrawingState(renderer) < 0) {
1639 for (idx = 0; idx <
count; ++idx) {
1656 GLES2_UpdateVertexBuffer(renderer, GLES2_ATTRIBUTE_POSITION, vertices, 8 *
sizeof(
GLfloat));
1659 return GL_CheckError(
"", renderer);
1665 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
1666 GLES2_TextureData *tdata = (GLES2_TextureData *)texture->
driverdata;
1667 GLES2_ImageSource sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
1668 GLES2_ProgramCacheEntry *
program;
1675 switch (texture->
format) {
1680 sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
1683 sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
1691 sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
1694 sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
1701 sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
1704 sourceType = GLES2_IMAGESOURCE_TEXTURE_BGR;
1707 sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
1714 sourceType = GLES2_IMAGESOURCE_TEXTURE_BGR;
1717 sourceType = GLES2_IMAGESOURCE_TEXTURE_RGB;
1720 sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
1726 sourceType = GLES2_IMAGESOURCE_TEXTURE_YUV;
1729 sourceType = GLES2_IMAGESOURCE_TEXTURE_NV12;
1732 sourceType = GLES2_IMAGESOURCE_TEXTURE_NV21;
1735 sourceType = GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES;
1741 sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
1744 switch (texture->
format) {
1746 sourceType = GLES2_IMAGESOURCE_TEXTURE_ARGB;
1749 sourceType = GLES2_IMAGESOURCE_TEXTURE_ABGR;
1752 sourceType = GLES2_IMAGESOURCE_TEXTURE_RGB;
1755 sourceType = GLES2_IMAGESOURCE_TEXTURE_BGR;
1759 sourceType = GLES2_IMAGESOURCE_TEXTURE_YUV;
1762 sourceType = GLES2_IMAGESOURCE_TEXTURE_NV12;
1765 sourceType = GLES2_IMAGESOURCE_TEXTURE_NV21;
1768 sourceType = GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES;
1775 if (GLES2_SelectProgram(renderer, sourceType, texture->
w, texture->
h) < 0) {
1782 data->glBindTexture(tdata->texture_type, tdata->texture_v);
1785 data->glBindTexture(tdata->texture_type, tdata->texture_u);
1791 data->glBindTexture(tdata->texture_type, tdata->texture_u);
1795 data->glBindTexture(tdata->texture_type, tdata->texture);
1811 program = data->current_program;
1813 if (!CompareColors(program->modulation_r, program->modulation_g, program->modulation_b, program->modulation_a, r, g, b, a)) {
1814 data->glUniform4f(program->uniform_locations[GLES2_UNIFORM_MODULATION], r * inv255f, g * inv255f, b * inv255f, a * inv255f);
1815 program->modulation_r =
r;
1816 program->modulation_g =
g;
1817 program->modulation_b =
b;
1818 program->modulation_a =
a;
1822 GLES2_SetBlendMode(data, texture->
blendMode);
1824 GLES2_SetTexCoords(data,
SDL_TRUE);
1832 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
1836 GLES2_ActivateRenderer(renderer);
1838 if (GLES2_SetupCopy(renderer, texture) < 0) {
1843 vertices[0] = dstrect->
x;
1844 vertices[1] = dstrect->
y;
1845 vertices[2] = (dstrect->
x + dstrect->
w);
1846 vertices[3] = dstrect->
y;
1847 vertices[4] = dstrect->
x;
1848 vertices[5] = (dstrect->
y + dstrect->
h);
1849 vertices[6] = (dstrect->
x + dstrect->
w);
1850 vertices[7] = (dstrect->
y + dstrect->
h);
1852 GLES2_UpdateVertexBuffer(renderer, GLES2_ATTRIBUTE_POSITION, vertices, 8 *
sizeof(
GLfloat));
1853 texCoords[0] = srcrect->
x / (
GLfloat)texture->
w;
1854 texCoords[1] = srcrect->
y / (
GLfloat)texture->
h;
1855 texCoords[2] = (srcrect->
x + srcrect->
w) / (
GLfloat)texture->
w;
1856 texCoords[3] = srcrect->
y / (
GLfloat)texture->
h;
1857 texCoords[4] = srcrect->
x / (
GLfloat)texture->
w;
1858 texCoords[5] = (srcrect->
y + srcrect->
h) / (
GLfloat)texture->
h;
1859 texCoords[6] = (srcrect->
x + srcrect->
w) / (
GLfloat)texture->
w;
1860 texCoords[7] = (srcrect->
y + srcrect->
h) / (
GLfloat)texture->
h;
1862 GLES2_UpdateVertexBuffer(renderer, GLES2_ATTRIBUTE_TEXCOORD, texCoords, 8 *
sizeof(
GLfloat));
1865 return GL_CheckError(
"", renderer);
1872 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
1879 GLES2_ActivateRenderer(renderer);
1881 if (GLES2_SetupCopy(renderer, texture) < 0) {
1885 data->glEnableVertexAttribArray(GLES2_ATTRIBUTE_CENTER);
1886 data->glEnableVertexAttribArray(GLES2_ATTRIBUTE_ANGLE);
1887 fAngle[0] = fAngle[1] = fAngle[2] = fAngle[3] = (
GLfloat)(360.0
f - angle);
1889 translate[0] = translate[2] = translate[4] = translate[6] = (center->
x + dstrect->
x);
1890 translate[1] = translate[3] = translate[5] = translate[7] = (center->
y + dstrect->
y);
1893 vertices[0] = dstrect->
x;
1894 vertices[1] = dstrect->
y;
1895 vertices[2] = (dstrect->
x + dstrect->
w);
1896 vertices[3] = dstrect->
y;
1897 vertices[4] = dstrect->
x;
1898 vertices[5] = (dstrect->
y + dstrect->
h);
1899 vertices[6] = (dstrect->
x + dstrect->
w);
1900 vertices[7] = (dstrect->
y + dstrect->
h);
1903 vertices[0] = vertices[4] = vertices[2];
1904 vertices[2] = vertices[6] = tmp;
1908 vertices[1] = vertices[3] = vertices[5];
1909 vertices[5] = vertices[7] = tmp;
1916 GLES2_UpdateVertexBuffer(renderer, GLES2_ATTRIBUTE_ANGLE, fAngle, 4 *
sizeof(
GLfloat));
1917 GLES2_UpdateVertexBuffer(renderer, GLES2_ATTRIBUTE_CENTER, translate, 8 *
sizeof(
GLfloat));
1918 GLES2_UpdateVertexBuffer(renderer, GLES2_ATTRIBUTE_POSITION, vertices, 8 *
sizeof(
GLfloat));
1920 texCoords[0] = srcrect->
x / (
GLfloat)texture->
w;
1921 texCoords[1] = srcrect->
y / (
GLfloat)texture->
h;
1922 texCoords[2] = (srcrect->
x + srcrect->
w) / (
GLfloat)texture->
w;
1923 texCoords[3] = srcrect->
y / (
GLfloat)texture->
h;
1924 texCoords[4] = srcrect->
x / (
GLfloat)texture->
w;
1925 texCoords[5] = (srcrect->
y + srcrect->
h) / (
GLfloat)texture->
h;
1926 texCoords[6] = (srcrect->
x + srcrect->
w) / (
GLfloat)texture->
w;
1927 texCoords[7] = (srcrect->
y + srcrect->
h) / (
GLfloat)texture->
h;
1929 GLES2_UpdateVertexBuffer(renderer, GLES2_ATTRIBUTE_TEXCOORD, texCoords, 8 *
sizeof(
GLfloat));
1931 data->glDisableVertexAttribArray(GLES2_ATTRIBUTE_CENTER);
1932 data->glDisableVertexAttribArray(GLES2_ATTRIBUTE_ANGLE);
1934 return GL_CheckError(
"", renderer);
1939 Uint32 pixel_format,
void * pixels,
int pitch)
1941 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
1946 int w, h, length, rows;
1949 GLES2_ActivateRenderer(renderer);
1959 data->glReadPixels(rect->
x, renderer->
target ? rect->
y : (h-rect->
y)-rect->
h,
1961 if (GL_CheckError(
"glReadPixels()", renderer) < 0) {
1968 src = (
Uint8*)temp_pixels + (rect->
h-1)*temp_pitch;
1983 temp_format, temp_pixels, temp_pitch,
1984 pixel_format, pixels, pitch);
1993 GLES2_ActivateRenderer(renderer);
2008 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
2009 GLES2_TextureData *texturedata = (GLES2_TextureData *)texture->
driverdata;
2010 GLES2_ActivateRenderer(renderer);
2012 data->glBindTexture(texturedata->texture_type, texturedata->texture);
2026 GLES2_DriverContext *data = (GLES2_DriverContext *)renderer->
driverdata;
2027 GLES2_TextureData *texturedata = (GLES2_TextureData *)texture->
driverdata;
2028 GLES2_ActivateRenderer(renderer);
2030 data->glBindTexture(texturedata->texture_type, 0);
2041 #define GL_NVIDIA_PLATFORM_BINARY_NV 0x890B 2047 GLES2_DriverContext *data = (GLES2_DriverContext *) renderer->
driverdata;
2049 if (SDL_CurrentContext == data->context) {
2050 GLES2_UpdateViewport(renderer);
2052 GLES2_ActivateRenderer(renderer);
2062 data->glClearColor((
GLfloat) data->clear_r * inv255f,
2063 (
GLfloat) data->clear_g * inv255f,
2064 (
GLfloat) data->clear_b * inv255f,
2065 (
GLfloat) data->clear_a * inv255f);
2067 data->glEnableVertexAttribArray(GLES2_ATTRIBUTE_POSITION);
2068 data->glDisableVertexAttribArray(GLES2_ATTRIBUTE_TEXCOORD);
2070 GL_CheckError(
"", renderer);
2077 GLES2_DriverContext *
data;
2083 GLint window_framebuffer;
2085 int profile_mask = 0, major = 0, minor = 0;
2120 data = (GLES2_DriverContext *)
SDL_calloc(1,
sizeof(GLES2_DriverContext));
2122 GLES2_DestroyRenderer(renderer);
2126 renderer->
info = GLES2_RenderDriver.
info;
2133 if (!data->context) {
2134 GLES2_DestroyRenderer(renderer);
2138 GLES2_DestroyRenderer(renderer);
2142 if (GLES2_LoadFunctions(data) < 0) {
2143 GLES2_DestroyRenderer(renderer);
2189 if (!data->shader_formats) {
2190 GLES2_DestroyRenderer(renderer);
2194 data->shader_format_count = nFormats;
2196 data->shader_formats[0] = GL_NVIDIA_PLATFORM_BINARY_NV;
2200 data->shader_formats[nFormats - 1] = (
GLenum)-1;
2204 data->framebuffers =
NULL;
2206 data->window_framebuffer = (
GLuint)window_framebuffer;
2237 #ifdef GL_TEXTURE_EXTERNAL_OES 2241 GLES2_ResetState(renderer);
2246 if (changed_window) {
SDL_BlendFactor SDL_GetBlendModeSrcColorFactor(SDL_BlendMode blendMode)
SDL_BlendFactor
The normalized factor used to multiply pixel components.
int(* RenderDrawLines)(SDL_Renderer *renderer, const SDL_FPoint *points, int count)
#define GL_TEXTURE_EXTERNAL_OES
GLdouble GLdouble GLdouble r
int(* RenderDrawPoints)(SDL_Renderer *renderer, const SDL_FPoint *points, int count)
int(* LockTexture)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
#define GL_INVALID_OPERATION
#define SDL_GL_CreateContext
int(* RenderReadPixels)(SDL_Renderer *renderer, const SDL_Rect *rect, Uint32 format, void *pixels, int pitch)
const GLuint * framebuffers
#define GL_COLOR_ATTACHMENT0
GLint GLint GLint GLint GLint x
SDL_BlendMode
The blend mode used in SDL_RenderCopy() and drawing operations.
#define GL_COMPILE_STATUS
SDL_bool(* SupportsBlendMode)(SDL_Renderer *renderer, SDL_BlendMode blendMode)
GLuint GLuint GLsizei count
#define SDL_HINT_RENDER_SCALE_QUALITY
A variable controlling the scaling quality.
GLfloat GLfloat GLfloat GLfloat h
#define GL_SHADER_COMPILER
Uint32 texture_formats[16]
static screen_context_t context
SDL_BlendFactor SDL_GetBlendModeDstAlphaFactor(SDL_BlendMode blendMode)
#define SDL_GetWindowFlags
SDL_BlendOperation SDL_GetBlendModeColorOperation(SDL_BlendMode blendMode)
#define SDL_BYTESPERPIXEL(X)
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
#define GL_TEXTURE_MAG_FILTER
int(* RenderFillRects)(SDL_Renderer *renderer, const SDL_FRect *rects, int count)
#define GL_TRIANGLE_STRIP
#define GL_FRAMEBUFFER_COMPLETE
#define GL_ONE_MINUS_SRC_ALPHA
SDL_BlendOperation
The blend operation used when combining source and destination pixel components.
#define GL_ONE_MINUS_SRC_COLOR
int(* RenderClear)(SDL_Renderer *renderer)
void(* DestroyRenderer)(SDL_Renderer *renderer)
GLint GLint GLsizei width
GLfixed GLfixed GLint GLint GLfixed points
int(* GetOutputSize)(SDL_Renderer *renderer, int *w, int *h)
#define GL_PACK_ALIGNMENT
#define GL_MAX_TEXTURE_SIZE
static SDL_BlendMode blendMode
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
int(* UpdateTexture)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch)
int(* 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)
#define SDL_GL_SetAttribute
#define SDL_GL_GetDrawableSize
#define GL_ONE_MINUS_DST_ALPHA
SDL_RenderDriver GLES2_RenderDriver
GLenum GLenum GLuint texture
SDL_BlendOperation SDL_GetBlendModeAlphaOperation(SDL_BlendMode blendMode)
void * SDL_GLContext
An opaque handle to an OpenGL context.
#define SDL_GL_GetSwapInterval
int SDL_RecreateWindow(SDL_Window *window, Uint32 flags)
static int GetScaleQuality(void)
static SDL_Renderer * renderer
#define SDL_stack_alloc(type, count)
#define SDL_GL_SetSwapInterval
#define GL_TEXTURE_WRAP_T
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int int in j)
#define GL_LUMINANCE_ALPHA
int(* GL_BindTexture)(SDL_Renderer *renderer, SDL_Texture *texture, float *texw, float *texh)
GLubyte GLubyte GLubyte GLubyte w
GLsizei const GLfloat * value
void(* UnlockTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
GLsizei GLsizei GLchar * source
GLint GLint GLint GLint GLint GLint y
#define RGBA8888_FROM_RGBA(Pixel, r, g, b, a)
int(* SetRenderTarget)(SDL_Renderer *renderer, SDL_Texture *texture)
int(* UpdateViewport)(SDL_Renderer *renderer)
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
#define GL_COLOR_BUFFER_BIT
int(* GL_UnbindTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
SDL_RendererFlip
Flip constants for SDL_RenderCopyEx.
GLenum GLenum GLsizei const GLuint GLboolean enabled
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
int(* RenderCopy)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_FRect *dstrect)
Window state change event data (event.window.*)
#define GL_FRAMEBUFFER_BINDING
#define SDL_OutOfMemory()
SDL_BlendFactor SDL_GetBlendModeSrcAlphaFactor(SDL_BlendMode blendMode)
GLint GLint GLsizei GLsizei height
int(* RenderCopyEx)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcquad, const SDL_FRect *dstrect, const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
#define SDL_GL_MakeCurrent
EGLSurface EGLNativeWindowType * window
#define SDL_GetRendererOutputSize
#define GL_FUNC_REVERSE_SUBTRACT
GLint GLint GLint yoffset
The type used to identify a window.
#define GL_ONE_MINUS_DST_COLOR
SDL_BlendFactor SDL_GetBlendModeDstColorFactor(SDL_BlendMode blendMode)
void(* WindowEvent)(SDL_Renderer *renderer, const SDL_WindowEvent *event)
#define GL_SHADER_BINARY_FORMATS
Uint32 num_texture_formats
GLuint GLuint GLsizei GLenum type
#define GL_NUM_SHADER_BINARY_FORMATS
#define SDL_GL_GetAttribute
GLbitfield GLuint program
#define SDL_ConvertPixels
void(* DestroyTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
int(* CreateTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
void(* RenderPresent)(SDL_Renderer *renderer)
#define SDL_GL_DeleteContext
EGLSurface EGLint * rects
#define SDL_stack_free(data)
#define SDL_GetYUVConversionModeForResolution
#define GL_TEXTURE_WRAP_S
GLuint GLsizei GLsizei * length
#define GL_TEXTURE_MIN_FILTER
GLboolean GLboolean GLboolean GLboolean a
#define GL_UNPACK_ALIGNMENT
int(* UpdateClipRect)(SDL_Renderer *renderer)
GLboolean GLboolean GLboolean b
#define SDL_GL_SwapWindow
SDL_bool clipping_enabled
A rectangle, with the origin at the upper left.
#define GL_INFO_LOG_LENGTH