21 #include "../../SDL_internal.h" 23 #if SDL_VIDEO_RENDER_OGL && !SDL_RENDER_DISABLED 29 #include "../SDL_sysrender.h" 33 #include <OpenGL/OpenGL.h> 40 #define RENDERER_CONTEXT_MAJOR 2 41 #define RENDERER_CONTEXT_MINOR 1 52 static const float inv255f = 1.0f / 255.0f;
65 const Uint8 *Yplane,
int Ypitch,
66 const Uint8 *Uplane,
int Upitch,
67 const Uint8 *Vplane,
int Vpitch);
105 typedef struct GL_FBOList GL_FBOList;
119 SDL_bool GL_ARB_debug_output_supported;
121 char **error_messages;
123 GLvoid *next_error_userparam;
125 SDL_bool GL_ARB_texture_non_power_of_two_supported;
126 SDL_bool GL_ARB_texture_rectangle_supported;
133 SDL_bool GL_EXT_framebuffer_object_supported;
137 #define SDL_PROC(ret,func,params) ret (APIENTRY *func) params; 142 SDL_bool GL_ARB_multitexture_supported;
144 GLint num_texture_units;
146 PFNGLGENFRAMEBUFFERSEXTPROC glGenFramebuffersEXT;
147 PFNGLDELETEFRAMEBUFFERSEXTPROC glDeleteFramebuffersEXT;
148 PFNGLFRAMEBUFFERTEXTURE2DEXTPROC glFramebufferTexture2DEXT;
149 PFNGLBINDFRAMEBUFFEREXTPROC glBindFramebufferEXT;
150 PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glCheckFramebufferStatusEXT;
179 GL_TranslateError (
GLenum error)
181 #define GL_ERROR_TRANSLATE(e) case e: return #e; 194 #undef GL_ERROR_TRANSLATE 202 if (!data->debug_enabled)
206 if (data->GL_ARB_debug_output_supported) {
209 for (i = 0; i < data->errors; ++
i) {
215 data->error_messages =
NULL;
225 GL_CheckAllErrors (
const char *prefix,
SDL_Renderer *renderer,
const char *file,
int line,
const char *
function)
227 GL_RenderData *data = (GL_RenderData *) renderer->
driverdata;
230 if (!data->debug_enabled)
234 if (data->GL_ARB_debug_output_supported) {
237 for (i = 0; i < data->errors; ++
i) {
238 SDL_SetError(
"%s: %s (%d): %s %s", prefix, file, line,
function, data->error_messages[i]);
241 GL_ClearErrors(renderer);
246 GLenum error = data->glGetError();
248 if (prefix ==
NULL || prefix[0] ==
'\0') {
251 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) 268 GL_LoadFunctions(GL_RenderData * data)
270 #ifdef __SDL_NOGETPROCADDR__ 271 #define SDL_PROC(ret,func,params) data->func=func; 273 #define SDL_PROC(ret,func,params) \ 275 data->func = SDL_GL_GetProcAddress(#func); \ 276 if ( ! data->func ) { \ 277 return SDL_SetError("Couldn't load GL function %s: %s", #func, SDL_GetError()); \ 292 GL_RenderData *data = (GL_RenderData *) renderer->
driverdata;
294 if (SDL_CurrentContext != data->context ||
299 SDL_CurrentContext = data->context;
301 GL_UpdateViewport(renderer);
304 GL_ClearErrors(renderer);
313 GL_RenderData *data = (GL_RenderData *) renderer->
driverdata;
316 GL_UpdateViewport(renderer);
318 GL_ActivateRenderer(renderer);
322 data->current.color = 0xffffffff;
331 data->glLoadIdentity();
333 GL_CheckError(
"", renderer);
340 GL_RenderData *data = (GL_RenderData *) renderer->
driverdata;
344 int errors = data->errors + 1;
345 char **error_messages =
SDL_realloc(data->error_messages, errors *
sizeof(*data->error_messages));
346 if (error_messages) {
347 data->errors = errors;
348 data->error_messages = error_messages;
349 data->error_messages[data->errors-1] =
SDL_strdup(message);
354 if (data->next_error_callback) {
355 data->next_error_callback(source, type,
id, severity, length, message, data->next_error_userparam);
368 GL_FBOList *
result = data->framebuffers;
370 while (result && ((result->w != w) || (result->h != h))) {
371 result = result->next;
379 data->glGenFramebuffersEXT(1, &result->FBO);
380 result->next = data->framebuffers;
381 data->framebuffers =
result;
394 int profile_mask = 0, major = 0, minor = 0;
421 data = (GL_RenderData *)
SDL_calloc(1,
sizeof(*data));
423 GL_DestroyRenderer(renderer);
451 renderer->
info = GL_RenderDriver.
info;
457 if (!data->context) {
458 GL_DestroyRenderer(renderer);
462 GL_DestroyRenderer(renderer);
466 if (GL_LoadFunctions(data) < 0) {
467 GL_DestroyRenderer(renderer);
493 PFNGLDEBUGMESSAGECALLBACKARBPROC glDebugMessageCallbackARBFunc = (PFNGLDEBUGMESSAGECALLBACKARBPROC)
SDL_GL_GetProcAddress(
"glDebugMessageCallbackARB");
495 data->GL_ARB_debug_output_supported =
SDL_TRUE;
498 glDebugMessageCallbackARBFunc(GL_HandleDebugMessage, renderer);
505 data->GL_ARB_texture_non_power_of_two_supported =
SDL_TRUE;
508 data->GL_ARB_texture_rectangle_supported =
SDL_TRUE;
510 if (data->GL_ARB_texture_rectangle_supported) {
523 if (data->glActiveTextureARB) {
524 data->GL_ARB_multitexture_supported =
SDL_TRUE;
534 data->shaders ?
"ENABLED" :
"DISABLED");
537 if (data->shaders && data->num_texture_units >= 3) {
549 data->GL_EXT_framebuffer_object_supported =
SDL_TRUE;
550 data->glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)
552 data->glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)
554 data->glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)
556 data->glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)
558 data->glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)
562 data->framebuffers =
NULL;
565 GL_ResetState(renderer);
570 if (changed_window) {
587 SDL_CurrentContext =
NULL;
592 GL_GetOutputSize(
SDL_Renderer * renderer,
int *w,
int *h)
658 if (colorOperation != alphaOperation) {
665 power_of_2(
int input)
669 while (value < input) {
676 convert_format(GL_RenderData *renderdata,
Uint32 pixel_format,
679 switch (pixel_format) {
711 if (!hint || *hint ==
'0' ||
SDL_strcasecmp(hint,
"nearest") == 0) {
721 GL_RenderData *renderdata = (GL_RenderData *) renderer->
driverdata;
722 GL_TextureData *data;
723 GLint internalFormat;
725 int texture_w, texture_h;
728 GL_ActivateRenderer(renderer);
731 !renderdata->GL_EXT_framebuffer_object_supported) {
732 return SDL_SetError(
"Render targets not supported by OpenGL");
735 if (!convert_format(renderdata, texture->
format, &internalFormat,
737 return SDL_SetError(
"Texture format %s not supported by OpenGL",
741 data = (GL_TextureData *)
SDL_calloc(1,
sizeof(*data));
749 size = texture->
h * data->pitch;
753 size += 2 * ((texture->
h + 1) / 2) * ((data->pitch + 1) / 2);
758 size += 2 * ((texture->
h + 1) / 2) * ((data->pitch + 1) / 2);
768 data->fbo = GL_GetFBO(renderdata, texture->
w, texture->
h);
773 GL_CheckError(
"", renderer);
774 renderdata->glGenTextures(1, &data->texture);
775 if (GL_CheckError(
"glGenTextures()", renderer) < 0) {
784 if (renderdata->GL_ARB_texture_non_power_of_two_supported) {
786 texture_w = texture->
w;
787 texture_h = texture->
h;
790 }
else if (renderdata->GL_ARB_texture_rectangle_supported) {
792 texture_w = texture->
w;
793 texture_h = texture->
h;
794 data->texw = (
GLfloat) texture_w;
795 data->texh = (
GLfloat) texture_h;
798 texture_w = power_of_2(texture->
w);
799 texture_h = power_of_2(texture->
h);
800 data->texw = (
GLfloat) (texture->
w) / texture_w;
801 data->texh = (
GLfloat) texture->
h / texture_h;
805 data->formattype =
type;
807 renderdata->glEnable(data->type);
808 renderdata->glBindTexture(data->type, data->texture);
821 #ifndef GL_TEXTURE_STORAGE_HINT_APPLE 822 #define GL_TEXTURE_STORAGE_HINT_APPLE 0x85BC 824 #ifndef STORAGE_CACHED_APPLE 825 #define STORAGE_CACHED_APPLE 0x85BE 827 #ifndef STORAGE_SHARED_APPLE 828 #define STORAGE_SHARED_APPLE 0x85BF 839 && (texture->
w % 8) == 0) {
844 renderdata->glTexImage2D(data->type, 0, internalFormat, texture_w,
845 texture_h, 0, format, type, data->pixels);
851 renderdata->glTexImage2D(data->type, 0, internalFormat, texture_w,
852 texture_h, 0, format, type,
NULL);
854 renderdata->glDisable(data->type);
855 if (GL_CheckError(
"glTexImage2D()", renderer) < 0) {
863 renderdata->glGenTextures(1, &data->utexture);
864 renderdata->glGenTextures(1, &data->vtexture);
865 renderdata->glEnable(data->type);
867 renderdata->glBindTexture(data->type, data->utexture);
876 renderdata->glTexImage2D(data->type, 0, internalFormat, (texture_w+1)/2,
877 (texture_h+1)/2, 0, format, type,
NULL);
879 renderdata->glBindTexture(data->type, data->vtexture);
888 renderdata->glTexImage2D(data->type, 0, internalFormat, (texture_w+1)/2,
889 (texture_h+1)/2, 0, format, type,
NULL);
891 renderdata->glDisable(data->type);
898 renderdata->glGenTextures(1, &data->utexture);
899 renderdata->glEnable(data->type);
901 renderdata->glBindTexture(data->type, data->utexture);
912 renderdata->glDisable(data->type);
915 return GL_CheckError(
"", renderer);
922 GL_RenderData *renderdata = (GL_RenderData *) renderer->
driverdata;
923 GL_TextureData *data = (GL_TextureData *) texture->
driverdata;
928 GL_ActivateRenderer(renderer);
930 renderdata->glEnable(data->type);
931 renderdata->glBindTexture(data->type, data->texture);
934 renderdata->glTexSubImage2D(data->type, 0, rect->
x, rect->
y, rect->
w,
935 rect->
h, data->format, data->formattype,
941 pixels = (
const void*)((
const Uint8*)pixels + rect->
h * pitch);
943 renderdata->glBindTexture(data->type, data->vtexture);
945 renderdata->glBindTexture(data->type, data->utexture);
947 renderdata->glTexSubImage2D(data->type, 0, rect->
x/2, rect->
y/2,
948 (rect->
w+1)/2, (rect->
h+1)/2,
949 data->format, data->formattype, pixels);
952 pixels = (
const void*)((
const Uint8*)pixels + ((rect->
h + 1) / 2) * ((pitch + 1) / 2));
954 renderdata->glBindTexture(data->type, data->utexture);
956 renderdata->glBindTexture(data->type, data->vtexture);
958 renderdata->glTexSubImage2D(data->type, 0, rect->
x/2, rect->
y/2,
959 (rect->
w+1)/2, (rect->
h+1)/2,
960 data->format, data->formattype, pixels);
967 pixels = (
const void*)((
const Uint8*)pixels + rect->
h * pitch);
968 renderdata->glBindTexture(data->type, data->utexture);
969 renderdata->glTexSubImage2D(data->type, 0, rect->
x/2, rect->
y/2,
970 (rect->
w + 1)/2, (rect->
h + 1)/2,
973 renderdata->glDisable(data->type);
975 return GL_CheckError(
"glTexSubImage2D()", renderer);
981 const Uint8 *Yplane,
int Ypitch,
982 const Uint8 *Uplane,
int Upitch,
983 const Uint8 *Vplane,
int Vpitch)
985 GL_RenderData *renderdata = (GL_RenderData *) renderer->
driverdata;
986 GL_TextureData *data = (GL_TextureData *) texture->
driverdata;
988 GL_ActivateRenderer(renderer);
990 renderdata->glEnable(data->type);
991 renderdata->glBindTexture(data->type, data->texture);
994 renderdata->glTexSubImage2D(data->type, 0, rect->
x, rect->
y, rect->
w,
995 rect->
h, data->format, data->formattype,
999 renderdata->glBindTexture(data->type, data->utexture);
1000 renderdata->glTexSubImage2D(data->type, 0, rect->
x/2, rect->
y/2,
1001 (rect->
w + 1)/2, (rect->
h + 1)/2,
1002 data->format, data->formattype, Uplane);
1005 renderdata->glBindTexture(data->type, data->vtexture);
1006 renderdata->glTexSubImage2D(data->type, 0, rect->
x/2, rect->
y/2,
1007 (rect->
w + 1)/2, (rect->
h + 1)/2,
1008 data->format, data->formattype, Vplane);
1009 renderdata->glDisable(data->type);
1011 return GL_CheckError(
"glTexSubImage2D()", renderer);
1016 const SDL_Rect * rect,
void **pixels,
int *pitch)
1018 GL_TextureData *data = (GL_TextureData *) texture->
driverdata;
1020 data->locked_rect = *rect;
1022 (
void *) ((
Uint8 *) data->pixels + rect->
y * data->pitch +
1024 *pitch = data->pitch;
1031 GL_TextureData *data = (GL_TextureData *) texture->
driverdata;
1035 rect = &data->locked_rect;
1037 (
void *) ((
Uint8 *) data->pixels + rect->
y * data->pitch +
1039 GL_UpdateTexture(renderer, texture, rect, pixels, data->pitch);
1045 GL_RenderData *data = (GL_RenderData *) renderer->
driverdata;
1046 GL_TextureData *texturedata;
1049 GL_ActivateRenderer(renderer);
1051 if (!data->GL_EXT_framebuffer_object_supported) {
1052 return SDL_SetError(
"Render targets not supported by OpenGL");
1055 if (texture ==
NULL) {
1060 texturedata = (GL_TextureData *) texture->
driverdata;
1067 return SDL_SetError(
"glFramebufferTexture2DEXT() failed");
1075 GL_RenderData *data = (GL_RenderData *) renderer->
driverdata;
1077 if (SDL_CurrentContext != data->context) {
1094 data->glLoadIdentity();
1112 return GL_CheckError(
"", renderer);
1118 GL_RenderData *data = (GL_RenderData *) renderer->
driverdata;
1129 data->glScissor(renderer->
viewport.
x + rect->
x, h - renderer->
viewport.
y - rect->
y - rect->
h, rect->
w, rect->
h);
1140 if (data->shaders && shader != data->current.shader) {
1142 data->current.shader =
shader;
1149 Uint32 color = ((a << 24) | (r << 16) | (g << 8) | b);
1151 if (color != data->current.color) {
1152 data->glColor4f((
GLfloat) r * inv255f,
1156 data->current.color =
color;
1161 GL_SetBlendMode(GL_RenderData * data,
SDL_BlendMode blendMode)
1163 if (blendMode != data->current.blendMode) {
1181 GL_RenderData *data = (GL_RenderData *) renderer->
driverdata;
1183 GL_ActivateRenderer(renderer);
1185 GL_SetColor(data, renderer->
r,
1190 GL_SetBlendMode(data, renderer->
blendMode);
1198 GL_RenderData *data = (GL_RenderData *) renderer->
driverdata;
1200 GL_ActivateRenderer(renderer);
1202 data->glClearColor((
GLfloat) renderer->
r * inv255f,
1224 GL_RenderData *data = (GL_RenderData *) renderer->
driverdata;
1227 GL_SetDrawingState(renderer);
1231 data->glVertex2f(0.5
f + points[
i].
x, 0.5
f + points[
i].
y);
1242 GL_RenderData *data = (GL_RenderData *) renderer->
driverdata;
1245 GL_SetDrawingState(renderer);
1248 points[0].
x == points[count-1].
x && points[0].
y == points[count-1].
y) {
1253 data->glVertex2f(0.5
f + points[
i].
x, 0.5
f + points[
i].
y);
1257 #if defined(__MACOSX__) || defined(__WIN32__) 1264 data->glVertex2f(0.5
f + points[
i].
x, 0.5
f + points[
i].
y);
1276 #if defined(__MACOSX__) || defined(__WIN32__) 1278 data->glVertex2f(0.5
f + points[count-1].
x, 0.5
f + points[count-1].
y);
1283 x2 = points[count-1].
x;
1284 y2 = points[count-1].
y;
1287 data->glVertex2f(0.5
f + x1, 0.5
f + y1);
1288 }
else if (x2 > x1) {
1289 data->glVertex2f(0.5
f + x2, 0.5
f + y2);
1292 data->glVertex2f(0.5
f + x1, 0.5
f + y1);
1293 }
else if (y2 > y1) {
1294 data->glVertex2f(0.5
f + x2, 0.5
f + y2);
1299 return GL_CheckError(
"", renderer);
1305 GL_RenderData *data = (GL_RenderData *) renderer->
driverdata;
1308 GL_SetDrawingState(renderer);
1313 data->glRectf(rect->
x, rect->
y, rect->
x + rect->
w, rect->
y + rect->
h);
1315 return GL_CheckError(
"", renderer);
1321 GL_RenderData *data = (GL_RenderData *) renderer->
driverdata;
1322 GL_TextureData *texturedata = (GL_TextureData *) texture->
driverdata;
1324 data->glEnable(texturedata->type);
1325 if (texturedata->yuv) {
1327 data->glBindTexture(texturedata->type, texturedata->vtexture);
1330 data->glBindTexture(texturedata->type, texturedata->utexture);
1334 if (texturedata->nv12) {
1336 data->glBindTexture(texturedata->type, texturedata->utexture);
1340 data->glBindTexture(texturedata->type, texturedata->texture);
1343 GL_SetColor(data, texture->
r, texture->
g, texture->
b, texture->
a);
1345 GL_SetColor(data, 255, 255, 255, 255);
1348 GL_SetBlendMode(data, texture->
blendMode);
1350 if (texturedata->yuv || texturedata->nv12) {
1353 if (texturedata->yuv) {
1362 if (texturedata->yuv) {
1371 if (texturedata->yuv) {
1380 return SDL_SetError(
"Unsupported YUV conversion mode");
1392 GL_RenderData *data = (GL_RenderData *) renderer->
driverdata;
1393 GL_TextureData *texturedata = (GL_TextureData *) texture->
driverdata;
1394 GLfloat minx, miny, maxx, maxy;
1395 GLfloat minu, maxu, minv, maxv;
1397 GL_ActivateRenderer(renderer);
1399 if (GL_SetupCopy(renderer, texture) < 0) {
1405 maxx = dstrect->
x + dstrect->
w;
1406 maxy = dstrect->
y + dstrect->
h;
1408 minu = (
GLfloat) srcrect->
x / texture->
w;
1409 minu *= texturedata->texw;
1410 maxu = (
GLfloat) (srcrect->
x + srcrect->
w) / texture->
w;
1411 maxu *= texturedata->texw;
1412 minv = (
GLfloat) srcrect->
y / texture->
h;
1413 minv *= texturedata->texh;
1414 maxv = (
GLfloat) (srcrect->
y + srcrect->
h) / texture->
h;
1415 maxv *= texturedata->texh;
1418 data->glTexCoord2f(minu, minv);
1419 data->glVertex2f(minx, miny);
1420 data->glTexCoord2f(maxu, minv);
1421 data->glVertex2f(maxx, miny);
1422 data->glTexCoord2f(minu, maxv);
1423 data->glVertex2f(minx, maxy);
1424 data->glTexCoord2f(maxu, maxv);
1425 data->glVertex2f(maxx, maxy);
1428 data->glDisable(texturedata->type);
1430 return GL_CheckError(
"", renderer);
1438 GL_RenderData *data = (GL_RenderData *) renderer->
driverdata;
1439 GL_TextureData *texturedata = (GL_TextureData *) texture->
driverdata;
1440 GLfloat minx, miny, maxx, maxy;
1442 GLfloat minu, maxu, minv, maxv;
1444 GL_ActivateRenderer(renderer);
1446 if (GL_SetupCopy(renderer, texture) < 0) {
1450 centerx = center->
x;
1451 centery = center->
y;
1454 minx = dstrect->
w - centerx;
1459 maxx = dstrect->
w - centerx;
1463 miny = dstrect->
h - centery;
1468 maxy = dstrect->
h - centery;
1471 minu = (
GLfloat) srcrect->
x / texture->
w;
1472 minu *= texturedata->texw;
1473 maxu = (
GLfloat) (srcrect->
x + srcrect->
w) / texture->
w;
1474 maxu *= texturedata->texw;
1475 minv = (
GLfloat) srcrect->
y / texture->
h;
1476 minv *= texturedata->texh;
1477 maxv = (
GLfloat) (srcrect->
y + srcrect->
h) / texture->
h;
1478 maxv *= texturedata->texh;
1481 data->glPushMatrix();
1486 data->glTexCoord2f(minu, minv);
1487 data->glVertex2f(minx, miny);
1488 data->glTexCoord2f(maxu, minv);
1489 data->glVertex2f(maxx, miny);
1490 data->glTexCoord2f(minu, maxv);
1491 data->glVertex2f(minx, maxy);
1492 data->glTexCoord2f(maxu, maxv);
1493 data->glVertex2f(maxx, maxy);
1495 data->glPopMatrix();
1497 data->glDisable(texturedata->type);
1499 return GL_CheckError(
"", renderer);
1504 Uint32 pixel_format,
void * pixels,
int pitch)
1506 GL_RenderData *data = (GL_RenderData *) renderer->
driverdata;
1510 GLint internalFormat;
1513 int w, h, length, rows;
1516 GL_ActivateRenderer(renderer);
1518 if (!convert_format(data, temp_format, &internalFormat, &format, &type)) {
1519 return SDL_SetError(
"Texture format %s not supported by OpenGL",
1523 if (!rect->
w || !rect->
h) {
1539 data->glReadPixels(rect->
x, renderer->
target ? rect->
y : (h-rect->
y)-rect->
h,
1540 rect->
w, rect->
h, format, type, temp_pixels);
1542 if (GL_CheckError(
"glReadPixels()", renderer) < 0) {
1550 src = (
Uint8*)temp_pixels + (rect->
h-1)*temp_pitch;
1565 temp_format, temp_pixels, temp_pitch,
1566 pixel_format, pixels, pitch);
1575 GL_ActivateRenderer(renderer);
1583 GL_RenderData *renderdata = (GL_RenderData *) renderer->
driverdata;
1584 GL_TextureData *data = (GL_TextureData *) texture->
driverdata;
1586 GL_ActivateRenderer(renderer);
1591 if (data->texture) {
1592 renderdata->glDeleteTextures(1, &data->texture);
1595 renderdata->glDeleteTextures(1, &data->utexture);
1596 renderdata->glDeleteTextures(1, &data->vtexture);
1606 GL_RenderData *data = (GL_RenderData *) renderer->
driverdata;
1609 if (data->context !=
NULL) {
1611 GL_ActivateRenderer(renderer);
1614 GL_ClearErrors(renderer);
1615 if (data->GL_ARB_debug_output_supported) {
1616 PFNGLDEBUGMESSAGECALLBACKARBPROC glDebugMessageCallbackARBFunc = (PFNGLDEBUGMESSAGECALLBACKARBPROC)
SDL_GL_GetProcAddress(
"glDebugMessageCallbackARB");
1620 glDebugMessageCallbackARBFunc(data->next_error_callback, data->next_error_userparam);
1622 if (data->shaders) {
1625 if (data->context) {
1626 while (data->framebuffers) {
1627 GL_FBOList *nextnode = data->framebuffers->next;
1629 data->glDeleteFramebuffersEXT(1, &data->framebuffers->FBO);
1630 GL_CheckError(
"", renderer);
1632 data->framebuffers = nextnode;
1644 GL_RenderData *data = (GL_RenderData *) renderer->
driverdata;
1645 GL_TextureData *texturedata = (GL_TextureData *) texture->
driverdata;
1646 GL_ActivateRenderer(renderer);
1648 data->glEnable(texturedata->type);
1649 if (texturedata->yuv) {
1651 data->glBindTexture(texturedata->type, texturedata->vtexture);
1654 data->glBindTexture(texturedata->type, texturedata->utexture);
1658 data->glBindTexture(texturedata->type, texturedata->texture);
1660 if(texw) *texw = (float)texturedata->texw;
1661 if(texh) *texh = (float)texturedata->texh;
1669 GL_RenderData *data = (GL_RenderData *) renderer->
driverdata;
1670 GL_TextureData *texturedata = (GL_TextureData *) texture->
driverdata;
1671 GL_ActivateRenderer(renderer);
1673 if (texturedata->yuv) {
1675 data->glDisable(texturedata->type);
1678 data->glDisable(texturedata->type);
1683 data->glDisable(texturedata->type);
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_STACK_UNDERFLOW
#define SDL_GL_ExtensionSupported
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_STORAGE_CACHED_APPLE
#define GL_UNPACK_CLIENT_STORAGE_APPLE
GLuint GLfloat GLfloat GLfloat x1
GL_ShaderContext * GL_CreateShaderContext(void)
void(APIENTRY * GLDEBUGPROCARB)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam)
#define GL_INVALID_OPERATION
#define GL_UNSIGNED_INT_8_8_8_8_REV
#define SDL_GL_CreateContext
int(* RenderReadPixels)(SDL_Renderer *renderer, const SDL_Rect *rect, Uint32 format, void *pixels, int pitch)
const GLuint * framebuffers
GLint GLint GLint GLint GLint x
#define GL_YCBCR_422_APPLE
GLuint GLsizei const GLchar * message
#define GL_DEBUG_CALLBACK_USER_PARAM_ARB
SDL_BlendMode
The blend mode used in SDL_RenderCopy() and drawing operations.
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
GLfixed GLfixed GLfixed y2
Uint32 texture_formats[16]
static screen_context_t context
SDL_BlendFactor SDL_GetBlendModeDstAlphaFactor(SDL_BlendMode blendMode)
#define SDL_GetWindowFlags
#define SDL_HINT_RENDER_OPENGL_SHADERS
A variable controlling whether the OpenGL render driver uses shaders if they are available.
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
#define GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB
int(* RenderFillRects)(SDL_Renderer *renderer, const SDL_FRect *rects, int count)
GLsizei GLsizei GLuint * shaders
#define GL_TEXTURE_STORAGE_HINT_APPLE
SDL_RenderDriver GL_RenderDriver
#define GL_TRIANGLE_STRIP
struct GL_ShaderContext GL_ShaderContext
#define GL_MAX_TEXTURE_UNITS_ARB
#define GL_ONE_MINUS_SRC_ALPHA
SDL_BlendOperation
The blend operation used when combining source and destination pixel components.
#define GL_UNPACK_ROW_LENGTH
#define GL_ONE_MINUS_SRC_COLOR
int(* RenderClear)(SDL_Renderer *renderer)
#define GL_FRAMEBUFFER_COMPLETE_EXT
void(* DestroyRenderer)(SDL_Renderer *renderer)
GLfixed GLfixed GLint GLint GLfixed points
int(* GetOutputSize)(SDL_Renderer *renderer, int *w, int *h)
#define GL_PACK_ROW_LENGTH
#define GL_TEXTURE_RECTANGLE_ARB
#define SDL_GetHintBoolean
#define GL_PACK_ALIGNMENT
void GL_DestroyShaderContext(GL_ShaderContext *ctx)
#define GL_MAX_TEXTURE_SIZE
static SDL_BlendMode blendMode
#define GL_TABLE_TOO_LARGE
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
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
GLenum GLenum GLenum input
int SDL_RecreateWindow(SDL_Window *window, Uint32 flags)
#define GL_STACK_OVERFLOW
static int GetScaleQuality(void)
static SDL_Renderer * renderer
#define SDL_stack_alloc(type, count)
#define SDL_GL_SetSwapInterval
#define SDL_GL_GetProcAddress
#define GL_COLOR_ATTACHMENT0_EXT
#define GL_TEXTURE_WRAP_T
#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
#define GL_DEBUG_CALLBACK_FUNCTION_ARB
GLint GLint GLint GLint GLint GLint y
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)
#define GL_STORAGE_SHARED_APPLE
SDL_RendererFlip
Flip constants for SDL_RenderCopyEx.
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 SDL_assert(condition)
#define SDL_OutOfMemory()
#define SDL_GL_GetCurrentContext
SDL_BlendFactor SDL_GetBlendModeSrcAlphaFactor(SDL_BlendMode blendMode)
GLAPI void GLAPIENTRY glActiveTextureARB(GLenum texture)
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
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)
Uint32 num_texture_formats
GLuint GLuint GLsizei GLenum type
#define SDL_GL_GetAttribute
#define SDL_ConvertPixels
void(* DestroyTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
#define GL_UNSIGNED_SHORT_8_8_APPLE
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)
#define GL_DEBUG_TYPE_ERROR_ARB
GLboolean GLboolean GLboolean b
#define SDL_GL_SwapWindow
void GL_SelectShader(GL_ShaderContext *ctx, GL_Shader shader)
SDL_bool clipping_enabled
A rectangle, with the origin at the upper left.
#define GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB
#define GL_FRAMEBUFFER_EXT
#define SDL_GetPixelFormatName