SDL  2.0
SDL_render_gl.c
Go to the documentation of this file.
1 /*
2  Simple DirectMedia Layer
3  Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
4 
5  This software is provided 'as-is', without any express or implied
6  warranty. In no event will the authors be held liable for any damages
7  arising from the use of this software.
8 
9  Permission is granted to anyone to use this software for any purpose,
10  including commercial applications, and to alter it and redistribute it
11  freely, subject to the following restrictions:
12 
13  1. The origin of this software must not be misrepresented; you must not
14  claim that you wrote the original software. If you use this software
15  in a product, an acknowledgment in the product documentation would be
16  appreciated but is not required.
17  2. Altered source versions must be plainly marked as such, and must not be
18  misrepresented as being the original software.
19  3. This notice may not be removed or altered from any source distribution.
20 */
21 #include "../../SDL_internal.h"
22 
23 #if SDL_VIDEO_RENDER_OGL && !SDL_RENDER_DISABLED
24 
25 #include "SDL_hints.h"
26 #include "SDL_log.h"
27 #include "SDL_assert.h"
28 #include "SDL_opengl.h"
29 #include "../SDL_sysrender.h"
30 #include "SDL_shaders_gl.h"
31 
32 #ifdef __MACOSX__
33 #include <OpenGL/OpenGL.h>
34 #endif
35 
36 /* To prevent unnecessary window recreation,
37  * these should match the defaults selected in SDL_GL_ResetAttributes
38  */
39 
40 #define RENDERER_CONTEXT_MAJOR 2
41 #define RENDERER_CONTEXT_MINOR 1
42 
43 /* OpenGL renderer implementation */
44 
45 /* Details on optimizing the texture path on Mac OS X:
46  http://developer.apple.com/library/mac/#documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/opengl_texturedata/opengl_texturedata.html
47 */
48 
49 /* Used to re-create the window with OpenGL capability */
51 
52 static const float inv255f = 1.0f / 255.0f;
53 
54 typedef struct GL_FBOList GL_FBOList;
55 
56 struct GL_FBOList
57 {
58  Uint32 w, h;
59  GLuint FBO;
60  GL_FBOList *next;
61 };
62 
63 typedef struct
64 {
65  SDL_bool viewport_dirty;
69  int drawablew;
70  int drawableh;
71  SDL_BlendMode blend;
73  SDL_bool cliprect_enabled_dirty;
74  SDL_bool cliprect_enabled;
75  SDL_bool cliprect_dirty;
76  SDL_Rect cliprect;
77  SDL_bool texturing;
78  Uint32 color;
79  Uint32 clear_color;
80 } GL_DrawStateCache;
81 
82 typedef struct
83 {
85 
86  SDL_bool debug_enabled;
87  SDL_bool GL_ARB_debug_output_supported;
88  int errors;
89  char **error_messages;
90  GLDEBUGPROCARB next_error_callback;
91  GLvoid *next_error_userparam;
92 
93  GLenum textype;
94 
95  SDL_bool GL_ARB_texture_non_power_of_two_supported;
96  SDL_bool GL_ARB_texture_rectangle_supported;
97  SDL_bool GL_EXT_framebuffer_object_supported;
98  GL_FBOList *framebuffers;
99 
100  /* OpenGL functions */
101 #define SDL_PROC(ret,func,params) ret (APIENTRY *func) params;
102 #include "SDL_glfuncs.h"
103 #undef SDL_PROC
104 
105  /* Multitexture support */
106  SDL_bool GL_ARB_multitexture_supported;
107  PFNGLACTIVETEXTUREARBPROC glActiveTextureARB;
108  GLint num_texture_units;
109 
110  PFNGLGENFRAMEBUFFERSEXTPROC glGenFramebuffersEXT;
111  PFNGLDELETEFRAMEBUFFERSEXTPROC glDeleteFramebuffersEXT;
112  PFNGLFRAMEBUFFERTEXTURE2DEXTPROC glFramebufferTexture2DEXT;
113  PFNGLBINDFRAMEBUFFEREXTPROC glBindFramebufferEXT;
114  PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glCheckFramebufferStatusEXT;
115 
116  /* Shader support */
118 
119  GL_DrawStateCache drawstate;
120 } GL_RenderData;
121 
122 typedef struct
123 {
124  GLuint texture;
125  GLfloat texw;
126  GLfloat texh;
127  GLenum format;
128  GLenum formattype;
129  void *pixels;
130  int pitch;
131  SDL_Rect locked_rect;
132 
133  /* YUV texture support */
134  SDL_bool yuv;
135  SDL_bool nv12;
136  GLuint utexture;
137  GLuint vtexture;
138 
139  GL_FBOList *fbo;
140 } GL_TextureData;
141 
142 SDL_FORCE_INLINE const char*
143 GL_TranslateError (GLenum error)
144 {
145 #define GL_ERROR_TRANSLATE(e) case e: return #e;
146  switch (error) {
147  GL_ERROR_TRANSLATE(GL_INVALID_ENUM)
148  GL_ERROR_TRANSLATE(GL_INVALID_VALUE)
149  GL_ERROR_TRANSLATE(GL_INVALID_OPERATION)
150  GL_ERROR_TRANSLATE(GL_OUT_OF_MEMORY)
151  GL_ERROR_TRANSLATE(GL_NO_ERROR)
152  GL_ERROR_TRANSLATE(GL_STACK_OVERFLOW)
153  GL_ERROR_TRANSLATE(GL_STACK_UNDERFLOW)
154  GL_ERROR_TRANSLATE(GL_TABLE_TOO_LARGE)
155  default:
156  return "UNKNOWN";
157 }
158 #undef GL_ERROR_TRANSLATE
159 }
160 
161 SDL_FORCE_INLINE void
162 GL_ClearErrors(SDL_Renderer *renderer)
163 {
164  GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
165 
166  if (!data->debug_enabled)
167  {
168  return;
169  }
170  if (data->GL_ARB_debug_output_supported) {
171  if (data->errors) {
172  int i;
173  for (i = 0; i < data->errors; ++i) {
174  SDL_free(data->error_messages[i]);
175  }
176  SDL_free(data->error_messages);
177 
178  data->errors = 0;
179  data->error_messages = NULL;
180  }
181  } else if (data->glGetError != NULL) {
182  while (data->glGetError() != GL_NO_ERROR) {
183  /* continue; */
184  }
185  }
186 }
187 
189 GL_CheckAllErrors (const char *prefix, SDL_Renderer *renderer, const char *file, int line, const char *function)
190 {
191  GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
192  int ret = 0;
193 
194  if (!data->debug_enabled)
195  {
196  return 0;
197  }
198  if (data->GL_ARB_debug_output_supported) {
199  if (data->errors) {
200  int i;
201  for (i = 0; i < data->errors; ++i) {
202  SDL_SetError("%s: %s (%d): %s %s", prefix, file, line, function, data->error_messages[i]);
203  ret = -1;
204  }
205  GL_ClearErrors(renderer);
206  }
207  } else {
208  /* check gl errors (can return multiple errors) */
209  for (;;) {
210  GLenum error = data->glGetError();
211  if (error != GL_NO_ERROR) {
212  if (prefix == NULL || prefix[0] == '\0') {
213  prefix = "generic";
214  }
215  SDL_SetError("%s: %s (%d): %s %s (0x%X)", prefix, file, line, function, GL_TranslateError(error), error);
216  ret = -1;
217  } else {
218  break;
219  }
220  }
221  }
222  return ret;
223 }
224 
225 #if 0
226 #define GL_CheckError(prefix, renderer)
227 #else
228 #define GL_CheckError(prefix, renderer) GL_CheckAllErrors(prefix, renderer, SDL_FILE, SDL_LINE, SDL_FUNCTION)
229 #endif
230 
231 static int
232 GL_LoadFunctions(GL_RenderData * data)
233 {
234 #ifdef __SDL_NOGETPROCADDR__
235 #define SDL_PROC(ret,func,params) data->func=func;
236 #else
237  int retval = 0;
238 #define SDL_PROC(ret,func,params) \
239  do { \
240  data->func = SDL_GL_GetProcAddress(#func); \
241  if ( ! data->func ) { \
242  retval = SDL_SetError("Couldn't load GL function %s: %s", #func, SDL_GetError()); \
243  } \
244  } while ( 0 );
245 #endif /* __SDL_NOGETPROCADDR__ */
246 
247 #include "SDL_glfuncs.h"
248 #undef SDL_PROC
249  return retval;
250 }
251 
252 static int
253 GL_ActivateRenderer(SDL_Renderer * renderer)
254 {
255  GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
256 
257  if (SDL_GL_GetCurrentContext() != data->context) {
258  if (SDL_GL_MakeCurrent(renderer->window, data->context) < 0) {
259  return -1;
260  }
261  }
262 
263  GL_ClearErrors(renderer);
264 
265  return 0;
266 }
267 
268 static void APIENTRY
269 GL_HandleDebugMessage(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const char *message, const void *userParam)
270 {
272  GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
273 
275  /* Record this error */
276  int errors = data->errors + 1;
277  char **error_messages = SDL_realloc(data->error_messages, errors * sizeof(*data->error_messages));
278  if (error_messages) {
279  data->errors = errors;
280  data->error_messages = error_messages;
281  data->error_messages[data->errors-1] = SDL_strdup(message);
282  }
283  }
284 
285  /* If there's another error callback, pass it along, otherwise log it */
286  if (data->next_error_callback) {
287  data->next_error_callback(source, type, id, severity, length, message, data->next_error_userparam);
288  } else {
289  if (type == GL_DEBUG_TYPE_ERROR_ARB) {
291  } else {
293  }
294  }
295 }
296 
297 static GL_FBOList *
298 GL_GetFBO(GL_RenderData *data, Uint32 w, Uint32 h)
299 {
300  GL_FBOList *result = data->framebuffers;
301 
302  while (result && ((result->w != w) || (result->h != h))) {
303  result = result->next;
304  }
305 
306  if (!result) {
307  result = SDL_malloc(sizeof(GL_FBOList));
308  if (result) {
309  result->w = w;
310  result->h = h;
311  data->glGenFramebuffersEXT(1, &result->FBO);
312  result->next = data->framebuffers;
313  data->framebuffers = result;
314  }
315  }
316  return result;
317 }
318 
319 static int
320 GL_GetOutputSize(SDL_Renderer * renderer, int *w, int *h)
321 {
323  return 0;
324 }
325 
326 static GLenum GetBlendFunc(SDL_BlendFactor factor)
327 {
328  switch (factor) {
330  return GL_ZERO;
331  case SDL_BLENDFACTOR_ONE:
332  return GL_ONE;
334  return GL_SRC_COLOR;
336  return GL_ONE_MINUS_SRC_COLOR;
338  return GL_SRC_ALPHA;
340  return GL_ONE_MINUS_SRC_ALPHA;
342  return GL_DST_COLOR;
344  return GL_ONE_MINUS_DST_COLOR;
346  return GL_DST_ALPHA;
348  return GL_ONE_MINUS_DST_ALPHA;
349  default:
350  return GL_INVALID_ENUM;
351  }
352 }
353 
354 static GLenum GetBlendEquation(SDL_BlendOperation operation)
355 {
356  switch (operation) {
358  return GL_FUNC_ADD;
360  return GL_FUNC_SUBTRACT;
363  default:
364  return GL_INVALID_ENUM;
365  }
366 }
367 
368 static SDL_bool
369 GL_SupportsBlendMode(SDL_Renderer * renderer, SDL_BlendMode blendMode)
370 {
377 
378  if (GetBlendFunc(srcColorFactor) == GL_INVALID_ENUM ||
379  GetBlendFunc(srcAlphaFactor) == GL_INVALID_ENUM ||
380  GetBlendEquation(colorOperation) == GL_INVALID_ENUM ||
381  GetBlendFunc(dstColorFactor) == GL_INVALID_ENUM ||
382  GetBlendFunc(dstAlphaFactor) == GL_INVALID_ENUM ||
383  GetBlendEquation(alphaOperation) == GL_INVALID_ENUM) {
384  return SDL_FALSE;
385  }
386  if (colorOperation != alphaOperation) {
387  return SDL_FALSE;
388  }
389  return SDL_TRUE;
390 }
391 
393 power_of_2(int input)
394 {
395  int value = 1;
396 
397  while (value < input) {
398  value <<= 1;
399  }
400  return value;
401 }
402 
404 convert_format(GL_RenderData *renderdata, Uint32 pixel_format,
406 {
407  switch (pixel_format) {
411  *format = GL_BGRA;
413  break;
417  *format = GL_RGBA;
419  break;
425  *format = GL_LUMINANCE;
427  break;
428 #ifdef __MACOSX__
433  break;
434 #endif
435  default:
436  return SDL_FALSE;
437  }
438  return SDL_TRUE;
439 }
440 
441 static int
442 GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
443 {
444  GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
445  const GLenum textype = renderdata->textype;
446  GL_TextureData *data;
448  GLenum format, type;
449  int texture_w, texture_h;
450  GLenum scaleMode;
451 
452  GL_ActivateRenderer(renderer);
453 
454  renderdata->drawstate.texture = NULL; /* we trash this state. */
455 
456  if (texture->access == SDL_TEXTUREACCESS_TARGET &&
457  !renderdata->GL_EXT_framebuffer_object_supported) {
458  return SDL_SetError("Render targets not supported by OpenGL");
459  }
460 
461  if (!convert_format(renderdata, texture->format, &internalFormat,
462  &format, &type)) {
463  return SDL_SetError("Texture format %s not supported by OpenGL",
465  }
466 
467  data = (GL_TextureData *) SDL_calloc(1, sizeof(*data));
468  if (!data) {
469  return SDL_OutOfMemory();
470  }
471 
472  if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
473  size_t size;
474  data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
475  size = texture->h * data->pitch;
476  if (texture->format == SDL_PIXELFORMAT_YV12 ||
477  texture->format == SDL_PIXELFORMAT_IYUV) {
478  /* Need to add size for the U and V planes */
479  size += 2 * ((texture->h + 1) / 2) * ((data->pitch + 1) / 2);
480  }
481  if (texture->format == SDL_PIXELFORMAT_NV12 ||
482  texture->format == SDL_PIXELFORMAT_NV21) {
483  /* Need to add size for the U/V plane */
484  size += 2 * ((texture->h + 1) / 2) * ((data->pitch + 1) / 2);
485  }
486  data->pixels = SDL_calloc(1, size);
487  if (!data->pixels) {
488  SDL_free(data);
489  return SDL_OutOfMemory();
490  }
491  }
492 
493  if (texture->access == SDL_TEXTUREACCESS_TARGET) {
494  data->fbo = GL_GetFBO(renderdata, texture->w, texture->h);
495  } else {
496  data->fbo = NULL;
497  }
498 
499  GL_CheckError("", renderer);
500  renderdata->glGenTextures(1, &data->texture);
501  if (GL_CheckError("glGenTextures()", renderer) < 0) {
502  if (data->pixels) {
503  SDL_free(data->pixels);
504  }
505  SDL_free(data);
506  return -1;
507  }
508  texture->driverdata = data;
509 
510  if (renderdata->GL_ARB_texture_non_power_of_two_supported) {
511  texture_w = texture->w;
512  texture_h = texture->h;
513  data->texw = 1.0f;
514  data->texh = 1.0f;
515  } else if (renderdata->GL_ARB_texture_rectangle_supported) {
516  texture_w = texture->w;
517  texture_h = texture->h;
518  data->texw = (GLfloat) texture_w;
519  data->texh = (GLfloat) texture_h;
520  } else {
521  texture_w = power_of_2(texture->w);
522  texture_h = power_of_2(texture->h);
523  data->texw = (GLfloat) (texture->w) / texture_w;
524  data->texh = (GLfloat) texture->h / texture_h;
525  }
526 
527  data->format = format;
528  data->formattype = type;
529  scaleMode = (texture->scaleMode == SDL_ScaleModeNearest) ? GL_NEAREST : GL_LINEAR;
530  renderdata->glEnable(textype);
531  renderdata->glBindTexture(textype, data->texture);
532  renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, scaleMode);
533  renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, scaleMode);
534  /* According to the spec, CLAMP_TO_EDGE is the default for TEXTURE_RECTANGLE
535  and setting it causes an INVALID_ENUM error in the latest NVidia drivers.
536  */
537  if (textype != GL_TEXTURE_RECTANGLE_ARB) {
538  renderdata->glTexParameteri(textype, GL_TEXTURE_WRAP_S,
540  renderdata->glTexParameteri(textype, GL_TEXTURE_WRAP_T,
542  }
543 #ifdef __MACOSX__
544 #ifndef GL_TEXTURE_STORAGE_HINT_APPLE
545 #define GL_TEXTURE_STORAGE_HINT_APPLE 0x85BC
546 #endif
547 #ifndef STORAGE_CACHED_APPLE
548 #define STORAGE_CACHED_APPLE 0x85BE
549 #endif
550 #ifndef STORAGE_SHARED_APPLE
551 #define STORAGE_SHARED_APPLE 0x85BF
552 #endif
553  if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
554  renderdata->glTexParameteri(textype, GL_TEXTURE_STORAGE_HINT_APPLE,
556  } else {
557  renderdata->glTexParameteri(textype, GL_TEXTURE_STORAGE_HINT_APPLE,
559  }
560  if (texture->access == SDL_TEXTUREACCESS_STREAMING
561  && texture->format == SDL_PIXELFORMAT_ARGB8888
562  && (texture->w % 8) == 0) {
563  renderdata->glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
564  renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
565  renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH,
566  (data->pitch / SDL_BYTESPERPIXEL(texture->format)));
567  renderdata->glTexImage2D(textype, 0, internalFormat, texture_w,
568  texture_h, 0, format, type, data->pixels);
569  renderdata->glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
570  }
571  else
572 #endif
573  {
574  renderdata->glTexImage2D(textype, 0, internalFormat, texture_w,
575  texture_h, 0, format, type, NULL);
576  }
577  renderdata->glDisable(textype);
578  if (GL_CheckError("glTexImage2D()", renderer) < 0) {
579  return -1;
580  }
581 
582  if (texture->format == SDL_PIXELFORMAT_YV12 ||
583  texture->format == SDL_PIXELFORMAT_IYUV) {
584  data->yuv = SDL_TRUE;
585 
586  renderdata->glGenTextures(1, &data->utexture);
587  renderdata->glGenTextures(1, &data->vtexture);
588  renderdata->glEnable(textype);
589 
590  renderdata->glBindTexture(textype, data->utexture);
591  renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER,
592  scaleMode);
593  renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER,
594  scaleMode);
595  renderdata->glTexParameteri(textype, GL_TEXTURE_WRAP_S,
597  renderdata->glTexParameteri(textype, GL_TEXTURE_WRAP_T,
599  renderdata->glTexImage2D(textype, 0, internalFormat, (texture_w+1)/2,
600  (texture_h+1)/2, 0, format, type, NULL);
601 
602  renderdata->glBindTexture(textype, data->vtexture);
603  renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER,
604  scaleMode);
605  renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER,
606  scaleMode);
607  renderdata->glTexParameteri(textype, GL_TEXTURE_WRAP_S,
609  renderdata->glTexParameteri(textype, GL_TEXTURE_WRAP_T,
611  renderdata->glTexImage2D(textype, 0, internalFormat, (texture_w+1)/2,
612  (texture_h+1)/2, 0, format, type, NULL);
613 
614  renderdata->glDisable(textype);
615  }
616 
617  if (texture->format == SDL_PIXELFORMAT_NV12 ||
618  texture->format == SDL_PIXELFORMAT_NV21) {
619  data->nv12 = SDL_TRUE;
620 
621  renderdata->glGenTextures(1, &data->utexture);
622  renderdata->glEnable(textype);
623 
624  renderdata->glBindTexture(textype, data->utexture);
625  renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER,
626  scaleMode);
627  renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER,
628  scaleMode);
629  renderdata->glTexParameteri(textype, GL_TEXTURE_WRAP_S,
631  renderdata->glTexParameteri(textype, GL_TEXTURE_WRAP_T,
633  renderdata->glTexImage2D(textype, 0, GL_LUMINANCE_ALPHA, (texture_w+1)/2,
634  (texture_h+1)/2, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, NULL);
635  renderdata->glDisable(textype);
636  }
637 
638  return GL_CheckError("", renderer);
639 }
640 
641 static int
642 GL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
643  const SDL_Rect * rect, const void *pixels, int pitch)
644 {
645  GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
646  const GLenum textype = renderdata->textype;
647  GL_TextureData *data = (GL_TextureData *) texture->driverdata;
648  const int texturebpp = SDL_BYTESPERPIXEL(texture->format);
649 
650  SDL_assert(texturebpp != 0); /* otherwise, division by zero later. */
651 
652  GL_ActivateRenderer(renderer);
653 
654  renderdata->drawstate.texture = NULL; /* we trash this state. */
655 
656  renderdata->glEnable(textype);
657  renderdata->glBindTexture(textype, data->texture);
658  renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
659  renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, (pitch / texturebpp));
660  renderdata->glTexSubImage2D(textype, 0, rect->x, rect->y, rect->w,
661  rect->h, data->format, data->formattype,
662  pixels);
663  if (data->yuv) {
664  renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, ((pitch + 1) / 2));
665 
666  /* Skip to the correct offset into the next texture */
667  pixels = (const void*)((const Uint8*)pixels + rect->h * pitch);
668  if (texture->format == SDL_PIXELFORMAT_YV12) {
669  renderdata->glBindTexture(textype, data->vtexture);
670  } else {
671  renderdata->glBindTexture(textype, data->utexture);
672  }
673  renderdata->glTexSubImage2D(textype, 0, rect->x/2, rect->y/2,
674  (rect->w+1)/2, (rect->h+1)/2,
675  data->format, data->formattype, pixels);
676 
677  /* Skip to the correct offset into the next texture */
678  pixels = (const void*)((const Uint8*)pixels + ((rect->h + 1) / 2) * ((pitch + 1) / 2));
679  if (texture->format == SDL_PIXELFORMAT_YV12) {
680  renderdata->glBindTexture(textype, data->utexture);
681  } else {
682  renderdata->glBindTexture(textype, data->vtexture);
683  }
684  renderdata->glTexSubImage2D(textype, 0, rect->x/2, rect->y/2,
685  (rect->w+1)/2, (rect->h+1)/2,
686  data->format, data->formattype, pixels);
687  }
688 
689  if (data->nv12) {
690  renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, ((pitch + 1) / 2));
691 
692  /* Skip to the correct offset into the next texture */
693  pixels = (const void*)((const Uint8*)pixels + rect->h * pitch);
694  renderdata->glBindTexture(textype, data->utexture);
695  renderdata->glTexSubImage2D(textype, 0, rect->x/2, rect->y/2,
696  (rect->w + 1)/2, (rect->h + 1)/2,
698  }
699  renderdata->glDisable(textype);
700 
701  return GL_CheckError("glTexSubImage2D()", renderer);
702 }
703 
704 static int
705 GL_UpdateTextureYUV(SDL_Renderer * renderer, SDL_Texture * texture,
706  const SDL_Rect * rect,
707  const Uint8 *Yplane, int Ypitch,
708  const Uint8 *Uplane, int Upitch,
709  const Uint8 *Vplane, int Vpitch)
710 {
711  GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
712  const GLenum textype = renderdata->textype;
713  GL_TextureData *data = (GL_TextureData *) texture->driverdata;
714 
715  GL_ActivateRenderer(renderer);
716 
717  renderdata->drawstate.texture = NULL; /* we trash this state. */
718 
719  renderdata->glEnable(textype);
720  renderdata->glBindTexture(textype, data->texture);
721  renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
722  renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, Ypitch);
723  renderdata->glTexSubImage2D(textype, 0, rect->x, rect->y, rect->w,
724  rect->h, data->format, data->formattype,
725  Yplane);
726 
727  renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, Upitch);
728  renderdata->glBindTexture(textype, data->utexture);
729  renderdata->glTexSubImage2D(textype, 0, rect->x/2, rect->y/2,
730  (rect->w + 1)/2, (rect->h + 1)/2,
731  data->format, data->formattype, Uplane);
732 
733  renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, Vpitch);
734  renderdata->glBindTexture(textype, data->vtexture);
735  renderdata->glTexSubImage2D(textype, 0, rect->x/2, rect->y/2,
736  (rect->w + 1)/2, (rect->h + 1)/2,
737  data->format, data->formattype, Vplane);
738  renderdata->glDisable(textype);
739 
740  return GL_CheckError("glTexSubImage2D()", renderer);
741 }
742 
743 static int
744 GL_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
745  const SDL_Rect * rect, void **pixels, int *pitch)
746 {
747  GL_TextureData *data = (GL_TextureData *) texture->driverdata;
748 
749  data->locked_rect = *rect;
750  *pixels =
751  (void *) ((Uint8 *) data->pixels + rect->y * data->pitch +
752  rect->x * SDL_BYTESPERPIXEL(texture->format));
753  *pitch = data->pitch;
754  return 0;
755 }
756 
757 static void
758 GL_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
759 {
760  GL_TextureData *data = (GL_TextureData *) texture->driverdata;
761  const SDL_Rect *rect;
762  void *pixels;
763 
764  rect = &data->locked_rect;
765  pixels =
766  (void *) ((Uint8 *) data->pixels + rect->y * data->pitch +
767  rect->x * SDL_BYTESPERPIXEL(texture->format));
768  GL_UpdateTexture(renderer, texture, rect, pixels, data->pitch);
769 }
770 
771 static void
772 GL_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture, SDL_ScaleMode scaleMode)
773 {
774  GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
775  const GLenum textype = renderdata->textype;
776  GL_TextureData *data = (GL_TextureData *) texture->driverdata;
777  GLenum glScaleMode = (scaleMode == SDL_ScaleModeNearest) ? GL_NEAREST : GL_LINEAR;
778 
779  renderdata->glEnable(textype);
780  renderdata->glBindTexture(textype, data->texture);
781  renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode);
782  renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode);
783  renderdata->glDisable(textype);
784 
785  if (texture->format == SDL_PIXELFORMAT_YV12 ||
786  texture->format == SDL_PIXELFORMAT_IYUV) {
787  renderdata->glEnable(textype);
788  renderdata->glBindTexture(textype, data->utexture);
789  renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode);
790  renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode);
791 
792  renderdata->glBindTexture(textype, data->vtexture);
793  renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode);
794  renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode);
795  renderdata->glDisable(textype);
796  }
797 
798  if (texture->format == SDL_PIXELFORMAT_NV12 ||
799  texture->format == SDL_PIXELFORMAT_NV21) {
800  renderdata->glEnable(textype);
801  renderdata->glBindTexture(textype, data->utexture);
802  renderdata->glTexParameteri(textype, GL_TEXTURE_MIN_FILTER, glScaleMode);
803  renderdata->glTexParameteri(textype, GL_TEXTURE_MAG_FILTER, glScaleMode);
804  renderdata->glDisable(textype);
805  }
806 }
807 
808 static int
809 GL_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture)
810 {
811  GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
812  GL_TextureData *texturedata;
813  GLenum status;
814 
815  GL_ActivateRenderer(renderer);
816 
817  if (!data->GL_EXT_framebuffer_object_supported) {
818  return SDL_SetError("Render targets not supported by OpenGL");
819  }
820 
821  data->drawstate.viewport_dirty = SDL_TRUE;
822 
823  if (texture == NULL) {
824  data->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
825  return 0;
826  }
827 
828  texturedata = (GL_TextureData *) texture->driverdata;
829  data->glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, texturedata->fbo->FBO);
830  /* TODO: check if texture pixel format allows this operation */
831  data->glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, data->textype, texturedata->texture, 0);
832  /* Check FBO status */
833  status = data->glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
834  if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
835  return SDL_SetError("glFramebufferTexture2DEXT() failed");
836  }
837  return 0;
838 }
839 
840 /* !!! FIXME: all these Queue* calls set up the vertex buffer the way the immediate mode
841  !!! FIXME: renderer wants it, but this might want to operate differently if we move to
842  !!! FIXME: VBOs at some point. */
843 static int
844 GL_QueueSetViewport(SDL_Renderer * renderer, SDL_RenderCommand *cmd)
845 {
846  return 0; /* nothing to do in this backend. */
847 }
848 
849 static int
850 GL_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count)
851 {
852  GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, count * 2 * sizeof (GLfloat), 0, &cmd->data.draw.first);
853  int i;
854 
855  if (!verts) {
856  return -1;
857  }
858 
859  cmd->data.draw.count = count;
860  for (i = 0; i < count; i++) {
861  *(verts++) = 0.5f + points[i].x;
862  *(verts++) = 0.5f + points[i].y;
863  }
864 
865  return 0;
866 }
867 
868 static int
869 GL_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FRect * rects, int count)
870 {
871  GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, count * 4 * sizeof (GLfloat), 0, &cmd->data.draw.first);
872  int i;
873 
874  if (!verts) {
875  return -1;
876  }
877 
878  cmd->data.draw.count = count;
879  for (i = 0; i < count; i++) {
880  const SDL_FRect *rect = &rects[i];
881  *(verts++) = rect->x;
882  *(verts++) = rect->y;
883  *(verts++) = rect->x + rect->w;
884  *(verts++) = rect->y + rect->h;
885  }
886 
887  return 0;
888 }
889 
890 static int
892  const SDL_Rect * srcrect, const SDL_FRect * dstrect)
893 {
894  GL_TextureData *texturedata = (GL_TextureData *) texture->driverdata;
895  GLfloat minx, miny, maxx, maxy;
896  GLfloat minu, maxu, minv, maxv;
897  GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, 8 * sizeof (GLfloat), 0, &cmd->data.draw.first);
898 
899  if (!verts) {
900  return -1;
901  }
902 
903  cmd->data.draw.count = 1;
904 
905  minx = dstrect->x;
906  miny = dstrect->y;
907  maxx = dstrect->x + dstrect->w;
908  maxy = dstrect->y + dstrect->h;
909 
910  minu = (GLfloat) srcrect->x / texture->w;
911  minu *= texturedata->texw;
912  maxu = (GLfloat) (srcrect->x + srcrect->w) / texture->w;
913  maxu *= texturedata->texw;
914  minv = (GLfloat) srcrect->y / texture->h;
915  minv *= texturedata->texh;
916  maxv = (GLfloat) (srcrect->y + srcrect->h) / texture->h;
917  maxv *= texturedata->texh;
918 
919  cmd->data.draw.count = 1;
920  *(verts++) = minx;
921  *(verts++) = miny;
922  *(verts++) = maxx;
923  *(verts++) = maxy;
924  *(verts++) = minu;
925  *(verts++) = maxu;
926  *(verts++) = minv;
927  *(verts++) = maxv;
928  return 0;
929 }
930 
931 static int
932 GL_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
933  const SDL_Rect * srcrect, const SDL_FRect * dstrect,
934  const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
935 {
936  GL_TextureData *texturedata = (GL_TextureData *) texture->driverdata;
937  GLfloat minx, miny, maxx, maxy;
938  GLfloat centerx, centery;
939  GLfloat minu, maxu, minv, maxv;
940  GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, 11 * sizeof (GLfloat), 0, &cmd->data.draw.first);
941 
942  if (!verts) {
943  return -1;
944  }
945 
946  centerx = center->x;
947  centery = center->y;
948 
949  if (flip & SDL_FLIP_HORIZONTAL) {
950  minx = dstrect->w - centerx;
951  maxx = -centerx;
952  }
953  else {
954  minx = -centerx;
955  maxx = dstrect->w - centerx;
956  }
957 
958  if (flip & SDL_FLIP_VERTICAL) {
959  miny = dstrect->h - centery;
960  maxy = -centery;
961  }
962  else {
963  miny = -centery;
964  maxy = dstrect->h - centery;
965  }
966 
967  minu = (GLfloat) srcrect->x / texture->w;
968  minu *= texturedata->texw;
969  maxu = (GLfloat) (srcrect->x + srcrect->w) / texture->w;
970  maxu *= texturedata->texw;
971  minv = (GLfloat) srcrect->y / texture->h;
972  minv *= texturedata->texh;
973  maxv = (GLfloat) (srcrect->y + srcrect->h) / texture->h;
974  maxv *= texturedata->texh;
975 
976  cmd->data.draw.count = 1;
977  *(verts++) = minx;
978  *(verts++) = miny;
979  *(verts++) = maxx;
980  *(verts++) = maxy;
981  *(verts++) = minu;
982  *(verts++) = maxu;
983  *(verts++) = minv;
984  *(verts++) = maxv;
985  *(verts++) = (GLfloat) dstrect->x + centerx;
986  *(verts++) = (GLfloat) dstrect->y + centery;
987  *(verts++) = (GLfloat) angle;
988  return 0;
989 }
990 
991 static void
992 SetDrawState(GL_RenderData *data, const SDL_RenderCommand *cmd, const GL_Shader shader)
993 {
994  const SDL_BlendMode blend = cmd->data.draw.blend;
995 
996  if (data->drawstate.viewport_dirty) {
997  const SDL_bool istarget = data->drawstate.target != NULL;
998  const SDL_Rect *viewport = &data->drawstate.viewport;
999  data->glMatrixMode(GL_PROJECTION);
1000  data->glLoadIdentity();
1001  data->glViewport(viewport->x,
1002  istarget ? viewport->y : (data->drawstate.drawableh - viewport->y - viewport->h),
1003  viewport->w, viewport->h);
1004  if (viewport->w && viewport->h) {
1005  data->glOrtho((GLdouble) 0, (GLdouble) viewport->w,
1006  (GLdouble) istarget ? 0 : viewport->h,
1007  (GLdouble) istarget ? viewport->h : 0,
1008  0.0, 1.0);
1009  }
1010  data->glMatrixMode(GL_MODELVIEW);
1011  data->drawstate.viewport_dirty = SDL_FALSE;
1012  }
1013 
1014  if (data->drawstate.cliprect_enabled_dirty) {
1015  if (!data->drawstate.cliprect_enabled) {
1016  data->glDisable(GL_SCISSOR_TEST);
1017  } else {
1018  data->glEnable(GL_SCISSOR_TEST);
1019  }
1020  data->drawstate.cliprect_enabled_dirty = SDL_FALSE;
1021  }
1022 
1023  if (data->drawstate.cliprect_enabled && data->drawstate.cliprect_dirty) {
1024  const SDL_Rect *viewport = &data->drawstate.viewport;
1025  const SDL_Rect *rect = &data->drawstate.cliprect;
1026  data->glScissor(viewport->x + rect->x,
1027  data->drawstate.target ? viewport->y + rect->y : data->drawstate.drawableh - viewport->y - rect->y - rect->h,
1028  rect->w, rect->h);
1029  data->drawstate.cliprect_dirty = SDL_FALSE;
1030  }
1031 
1032  if (blend != data->drawstate.blend) {
1033  if (blend == SDL_BLENDMODE_NONE) {
1034  data->glDisable(GL_BLEND);
1035  } else {
1036  data->glEnable(GL_BLEND);
1037  data->glBlendFuncSeparate(GetBlendFunc(SDL_GetBlendModeSrcColorFactor(blend)),
1038  GetBlendFunc(SDL_GetBlendModeDstColorFactor(blend)),
1039  GetBlendFunc(SDL_GetBlendModeSrcAlphaFactor(blend)),
1040  GetBlendFunc(SDL_GetBlendModeDstAlphaFactor(blend)));
1041  data->glBlendEquation(GetBlendEquation(SDL_GetBlendModeColorOperation(blend)));
1042  }
1043  data->drawstate.blend = blend;
1044  }
1045 
1046  if (data->shaders && (shader != data->drawstate.shader)) {
1047  GL_SelectShader(data->shaders, shader);
1048  data->drawstate.shader = shader;
1049  }
1050 
1051  if ((cmd->data.draw.texture != NULL) != data->drawstate.texturing) {
1052  if (cmd->data.draw.texture == NULL) {
1053  data->glDisable(data->textype);
1054  data->drawstate.texturing = SDL_FALSE;
1055  } else {
1056  data->glEnable(data->textype);
1057  data->drawstate.texturing = SDL_TRUE;
1058  }
1059  }
1060 }
1061 
1062 static void
1063 SetCopyState(GL_RenderData *data, const SDL_RenderCommand *cmd)
1064 {
1065  SDL_Texture *texture = cmd->data.draw.texture;
1066  const GL_TextureData *texturedata = (GL_TextureData *) texture->driverdata;
1067  GL_Shader shader;
1068 
1070  shader = SHADER_RGBA;
1071  } else {
1072  shader = SHADER_RGB;
1073  }
1074 
1075  if (data->shaders) {
1076  if (texturedata->yuv || texturedata->nv12) {
1079  if (texturedata->yuv) {
1081  } else if (texture->format == SDL_PIXELFORMAT_NV12) {
1083  } else {
1085  }
1086  break;
1088  if (texturedata->yuv) {
1090  } else if (texture->format == SDL_PIXELFORMAT_NV12) {
1092  } else {
1094  }
1095  break;
1097  if (texturedata->yuv) {
1099  } else if (texture->format == SDL_PIXELFORMAT_NV12) {
1101  } else {
1103  }
1104  break;
1105  default:
1106  SDL_assert(!"unsupported YUV conversion mode");
1107  break;
1108  }
1109  }
1110  }
1111 
1112  SetDrawState(data, cmd, shader);
1113 
1114  if (texture != data->drawstate.texture) {
1115  const GLenum textype = data->textype;
1116  if (texturedata->yuv) {
1117  data->glActiveTextureARB(GL_TEXTURE2_ARB);
1118  data->glBindTexture(textype, texturedata->vtexture);
1119 
1120  data->glActiveTextureARB(GL_TEXTURE1_ARB);
1121  data->glBindTexture(textype, texturedata->utexture);
1122  }
1123  if (texturedata->nv12) {
1124  data->glActiveTextureARB(GL_TEXTURE1_ARB);
1125  data->glBindTexture(textype, texturedata->utexture);
1126  }
1127  data->glActiveTextureARB(GL_TEXTURE0_ARB);
1128  data->glBindTexture(textype, texturedata->texture);
1129 
1130  data->drawstate.texture = texture;
1131  }
1132 }
1133 
1134 static int
1135 GL_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
1136 {
1137  /* !!! FIXME: it'd be nice to use a vertex buffer instead of immediate mode... */
1138  GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
1139  size_t i;
1140 
1141  if (GL_ActivateRenderer(renderer) < 0) {
1142  return -1;
1143  }
1144 
1145  data->drawstate.target = renderer->target;
1146  if (!data->drawstate.target) {
1147  SDL_GL_GetDrawableSize(renderer->window, &data->drawstate.drawablew, &data->drawstate.drawableh);
1148  }
1149 
1150 
1151  while (cmd) {
1152  switch (cmd->command) {
1154  const Uint8 r = cmd->data.color.r;
1155  const Uint8 g = cmd->data.color.g;
1156  const Uint8 b = cmd->data.color.b;
1157  const Uint8 a = cmd->data.color.a;
1158  const Uint32 color = ((a << 24) | (r << 16) | (g << 8) | b);
1159  if (color != data->drawstate.color) {
1160  data->glColor4f((GLfloat) r * inv255f,
1161  (GLfloat) g * inv255f,
1162  (GLfloat) b * inv255f,
1163  (GLfloat) a * inv255f);
1164  data->drawstate.color = color;
1165  }
1166  break;
1167  }
1168 
1170  SDL_Rect *viewport = &data->drawstate.viewport;
1171  if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof (SDL_Rect)) != 0) {
1172  SDL_memcpy(viewport, &cmd->data.viewport.rect, sizeof (SDL_Rect));
1173  data->drawstate.viewport_dirty = SDL_TRUE;
1174  }
1175  break;
1176  }
1177 
1179  const SDL_Rect *rect = &cmd->data.cliprect.rect;
1180  if (data->drawstate.cliprect_enabled != cmd->data.cliprect.enabled) {
1181  data->drawstate.cliprect_enabled = cmd->data.cliprect.enabled;
1182  data->drawstate.cliprect_enabled_dirty = SDL_TRUE;
1183  }
1184  if (SDL_memcmp(&data->drawstate.cliprect, rect, sizeof (SDL_Rect)) != 0) {
1185  SDL_memcpy(&data->drawstate.cliprect, rect, sizeof (SDL_Rect));
1186  data->drawstate.cliprect_dirty = SDL_TRUE;
1187  }
1188  break;
1189  }
1190 
1191  case SDL_RENDERCMD_CLEAR: {
1192  const Uint8 r = cmd->data.color.r;
1193  const Uint8 g = cmd->data.color.g;
1194  const Uint8 b = cmd->data.color.b;
1195  const Uint8 a = cmd->data.color.a;
1196  const Uint32 color = ((a << 24) | (r << 16) | (g << 8) | b);
1197  if (color != data->drawstate.clear_color) {
1198  const GLfloat fr = ((GLfloat) r) * inv255f;
1199  const GLfloat fg = ((GLfloat) g) * inv255f;
1200  const GLfloat fb = ((GLfloat) b) * inv255f;
1201  const GLfloat fa = ((GLfloat) a) * inv255f;
1202  data->glClearColor(fr, fg, fb, fa);
1203  data->drawstate.clear_color = color;
1204  }
1205 
1206  if (data->drawstate.cliprect_enabled || data->drawstate.cliprect_enabled_dirty) {
1207  data->glDisable(GL_SCISSOR_TEST);
1208  data->drawstate.cliprect_enabled_dirty = data->drawstate.cliprect_enabled;
1209  }
1210 
1211  data->glClear(GL_COLOR_BUFFER_BIT);
1212 
1213  break;
1214  }
1215 
1217  const size_t count = cmd->data.draw.count;
1218  const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
1220  data->glBegin(GL_POINTS);
1221  for (i = 0; i < count; i++, verts += 2) {
1222  data->glVertex2f(verts[0], verts[1]);
1223  }
1224  data->glEnd();
1225  break;
1226  }
1227 
1228  case SDL_RENDERCMD_DRAW_LINES: {
1229  const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
1230  const size_t count = cmd->data.draw.count;
1232  if (count > 2 && (verts[0] == verts[(count-1)*2]) && (verts[1] == verts[(count*2)-1])) {
1233  data->glBegin(GL_LINE_LOOP);
1234  /* GL_LINE_LOOP takes care of the final segment */
1235  for (i = 1; i < count; ++i, verts += 2) {
1236  data->glVertex2f(verts[0], verts[1]);
1237  }
1238  data->glEnd();
1239  } else {
1240  #if defined(__MACOSX__) || defined(__WIN32__)
1241  #else
1242  int x1, y1, x2, y2;
1243  #endif
1244 
1245  data->glBegin(GL_LINE_STRIP);
1246  for (i = 0; i < count; ++i, verts += 2) {
1247  data->glVertex2f(verts[0], verts[1]);
1248  }
1249  data->glEnd();
1250  verts -= 2 * count;
1251 
1252  /* The line is half open, so we need one more point to complete it.
1253  * http://www.opengl.org/documentation/specs/version1.1/glspec1.1/node47.html
1254  * If we have to, we can use vertical line and horizontal line textures
1255  * for vertical and horizontal lines, and then create custom textures
1256  * for diagonal lines and software render those. It's terrible, but at
1257  * least it would be pixel perfect.
1258  */
1259 
1260  data->glBegin(GL_POINTS);
1261  #if defined(__MACOSX__) || defined(__WIN32__)
1262  /* Mac OS X and Windows seem to always leave the last point open */
1263  data->glVertex2f(verts[(count-1)*2], verts[(count*2)-1]);
1264  #else
1265  /* Linux seems to leave the right-most or bottom-most point open */
1266  x1 = verts[0];
1267  y1 = verts[1];
1268  x2 = verts[(count-1)*2];
1269  y2 = verts[(count*2)-1];
1270 
1271  if (x1 > x2) {
1272  data->glVertex2f(x1, y1);
1273  } else if (x2 > x1) {
1274  data->glVertex2f(x2, y2);
1275  }
1276  if (y1 > y2) {
1277  data->glVertex2f(x1, y1);
1278  } else if (y2 > y1) {
1279  data->glVertex2f(x2, y2);
1280  }
1281  #endif
1282  data->glEnd();
1283  }
1284  break;
1285  }
1286 
1287  case SDL_RENDERCMD_FILL_RECTS: {
1288  const size_t count = cmd->data.draw.count;
1289  const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
1291  for (i = 0; i < count; ++i, verts += 4) {
1292  data->glRectf(verts[0], verts[1], verts[2], verts[3]);
1293  }
1294  break;
1295  }
1296 
1297  case SDL_RENDERCMD_COPY: {
1298  const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
1299  const GLfloat minx = verts[0];
1300  const GLfloat miny = verts[1];
1301  const GLfloat maxx = verts[2];
1302  const GLfloat maxy = verts[3];
1303  const GLfloat minu = verts[4];
1304  const GLfloat maxu = verts[5];
1305  const GLfloat minv = verts[6];
1306  const GLfloat maxv = verts[7];
1307  SetCopyState(data, cmd);
1308  data->glBegin(GL_TRIANGLE_STRIP);
1309  data->glTexCoord2f(minu, minv);
1310  data->glVertex2f(minx, miny);
1311  data->glTexCoord2f(maxu, minv);
1312  data->glVertex2f(maxx, miny);
1313  data->glTexCoord2f(minu, maxv);
1314  data->glVertex2f(minx, maxy);
1315  data->glTexCoord2f(maxu, maxv);
1316  data->glVertex2f(maxx, maxy);
1317  data->glEnd();
1318  break;
1319  }
1320 
1321  case SDL_RENDERCMD_COPY_EX: {
1322  const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
1323  const GLfloat minx = verts[0];
1324  const GLfloat miny = verts[1];
1325  const GLfloat maxx = verts[2];
1326  const GLfloat maxy = verts[3];
1327  const GLfloat minu = verts[4];
1328  const GLfloat maxu = verts[5];
1329  const GLfloat minv = verts[6];
1330  const GLfloat maxv = verts[7];
1331  const GLfloat translatex = verts[8];
1332  const GLfloat translatey = verts[9];
1333  const GLdouble angle = verts[10];
1334  SetCopyState(data, cmd);
1335 
1336  /* Translate to flip, rotate, translate to position */
1337  data->glPushMatrix();
1338  data->glTranslatef(translatex, translatey, 0.0f);
1339  data->glRotated(angle, 0.0, 0.0, 1.0);
1340  data->glBegin(GL_TRIANGLE_STRIP);
1341  data->glTexCoord2f(minu, minv);
1342  data->glVertex2f(minx, miny);
1343  data->glTexCoord2f(maxu, minv);
1344  data->glVertex2f(maxx, miny);
1345  data->glTexCoord2f(minu, maxv);
1346  data->glVertex2f(minx, maxy);
1347  data->glTexCoord2f(maxu, maxv);
1348  data->glVertex2f(maxx, maxy);
1349  data->glEnd();
1350  data->glPopMatrix();
1351  break;
1352  }
1353 
1354  case SDL_RENDERCMD_NO_OP:
1355  break;
1356  }
1357 
1358  cmd = cmd->next;
1359  }
1360 
1361  return GL_CheckError("", renderer);
1362 }
1363 
1364 static int
1365 GL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
1366  Uint32 pixel_format, void * pixels, int pitch)
1367 {
1368  GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
1370  void *temp_pixels;
1371  int temp_pitch;
1373  GLenum format, type;
1374  Uint8 *src, *dst, *tmp;
1375  int w, h, length, rows;
1376  int status;
1377 
1378  GL_ActivateRenderer(renderer);
1379 
1380  if (!convert_format(data, temp_format, &internalFormat, &format, &type)) {
1381  return SDL_SetError("Texture format %s not supported by OpenGL",
1382  SDL_GetPixelFormatName(temp_format));
1383  }
1384 
1385  if (!rect->w || !rect->h) {
1386  return 0; /* nothing to do. */
1387  }
1388 
1389  temp_pitch = rect->w * SDL_BYTESPERPIXEL(temp_format);
1390  temp_pixels = SDL_malloc(rect->h * temp_pitch);
1391  if (!temp_pixels) {
1392  return SDL_OutOfMemory();
1393  }
1394 
1396 
1397  data->glPixelStorei(GL_PACK_ALIGNMENT, 1);
1398  data->glPixelStorei(GL_PACK_ROW_LENGTH,
1399  (temp_pitch / SDL_BYTESPERPIXEL(temp_format)));
1400 
1401  data->glReadPixels(rect->x, renderer->target ? rect->y : (h-rect->y)-rect->h,
1402  rect->w, rect->h, format, type, temp_pixels);
1403 
1404  if (GL_CheckError("glReadPixels()", renderer) < 0) {
1405  SDL_free(temp_pixels);
1406  return -1;
1407  }
1408 
1409  /* Flip the rows to be top-down if necessary */
1410  if (!renderer->target) {
1411  SDL_bool isstack;
1412  length = rect->w * SDL_BYTESPERPIXEL(temp_format);
1413  src = (Uint8*)temp_pixels + (rect->h-1)*temp_pitch;
1414  dst = (Uint8*)temp_pixels;
1415  tmp = SDL_small_alloc(Uint8, length, &isstack);
1416  rows = rect->h / 2;
1417  while (rows--) {
1418  SDL_memcpy(tmp, dst, length);
1419  SDL_memcpy(dst, src, length);
1420  SDL_memcpy(src, tmp, length);
1421  dst += temp_pitch;
1422  src -= temp_pitch;
1423  }
1424  SDL_small_free(tmp, isstack);
1425  }
1426 
1427  status = SDL_ConvertPixels(rect->w, rect->h,
1428  temp_format, temp_pixels, temp_pitch,
1429  pixel_format, pixels, pitch);
1430  SDL_free(temp_pixels);
1431 
1432  return status;
1433 }
1434 
1435 static void
1436 GL_RenderPresent(SDL_Renderer * renderer)
1437 {
1438  GL_ActivateRenderer(renderer);
1439 
1441 }
1442 
1443 static void
1444 GL_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
1445 {
1446  GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
1447  GL_TextureData *data = (GL_TextureData *) texture->driverdata;
1448 
1449  GL_ActivateRenderer(renderer);
1450 
1451  if (renderdata->drawstate.texture == texture) {
1452  renderdata->drawstate.texture = NULL;
1453  }
1454  if (renderdata->drawstate.target == texture) {
1455  renderdata->drawstate.target = NULL;
1456  }
1457 
1458  if (!data) {
1459  return;
1460  }
1461  if (data->texture) {
1462  renderdata->glDeleteTextures(1, &data->texture);
1463  }
1464  if (data->yuv) {
1465  renderdata->glDeleteTextures(1, &data->utexture);
1466  renderdata->glDeleteTextures(1, &data->vtexture);
1467  }
1468  SDL_free(data->pixels);
1469  SDL_free(data);
1470  texture->driverdata = NULL;
1471 }
1472 
1473 static void
1474 GL_DestroyRenderer(SDL_Renderer * renderer)
1475 {
1476  GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
1477 
1478  if (data) {
1479  if (data->context != NULL) {
1480  /* make sure we delete the right resources! */
1481  GL_ActivateRenderer(renderer);
1482  }
1483 
1484  GL_ClearErrors(renderer);
1485  if (data->GL_ARB_debug_output_supported) {
1486  PFNGLDEBUGMESSAGECALLBACKARBPROC glDebugMessageCallbackARBFunc = (PFNGLDEBUGMESSAGECALLBACKARBPROC) SDL_GL_GetProcAddress("glDebugMessageCallbackARB");
1487 
1488  /* Uh oh, we don't have a safe way of removing ourselves from the callback chain, if it changed after we set our callback. */
1489  /* For now, just always replace the callback with the original one */
1490  glDebugMessageCallbackARBFunc(data->next_error_callback, data->next_error_userparam);
1491  }
1492  if (data->shaders) {
1493  GL_DestroyShaderContext(data->shaders);
1494  }
1495  if (data->context) {
1496  while (data->framebuffers) {
1497  GL_FBOList *nextnode = data->framebuffers->next;
1498  /* delete the framebuffer object */
1499  data->glDeleteFramebuffersEXT(1, &data->framebuffers->FBO);
1500  GL_CheckError("", renderer);
1501  SDL_free(data->framebuffers);
1502  data->framebuffers = nextnode;
1503  }
1504  SDL_GL_DeleteContext(data->context);
1505  }
1506  SDL_free(data);
1507  }
1508  SDL_free(renderer);
1509 }
1510 
1511 static int
1512 GL_BindTexture (SDL_Renderer * renderer, SDL_Texture *texture, float *texw, float *texh)
1513 {
1514  GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
1515  GL_TextureData *texturedata = (GL_TextureData *) texture->driverdata;
1516  const GLenum textype = data->textype;
1517 
1518  GL_ActivateRenderer(renderer);
1519 
1520  data->glEnable(textype);
1521  if (texturedata->yuv) {
1522  data->glActiveTextureARB(GL_TEXTURE2_ARB);
1523  data->glBindTexture(textype, texturedata->vtexture);
1524 
1525  data->glActiveTextureARB(GL_TEXTURE1_ARB);
1526  data->glBindTexture(textype, texturedata->utexture);
1527 
1528  data->glActiveTextureARB(GL_TEXTURE0_ARB);
1529  }
1530  data->glBindTexture(textype, texturedata->texture);
1531 
1532  data->drawstate.texturing = SDL_TRUE;
1533  data->drawstate.texture = texture;
1534 
1535  if(texw) *texw = (float)texturedata->texw;
1536  if(texh) *texh = (float)texturedata->texh;
1537 
1538  return 0;
1539 }
1540 
1541 static int
1542 GL_UnbindTexture (SDL_Renderer * renderer, SDL_Texture *texture)
1543 {
1544  GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
1545  GL_TextureData *texturedata = (GL_TextureData *) texture->driverdata;
1546  const GLenum textype = data->textype;
1547 
1548  GL_ActivateRenderer(renderer);
1549 
1550  if (texturedata->yuv) {
1551  data->glActiveTextureARB(GL_TEXTURE2_ARB);
1552  data->glDisable(textype);
1553 
1554  data->glActiveTextureARB(GL_TEXTURE1_ARB);
1555  data->glDisable(textype);
1556 
1557  data->glActiveTextureARB(GL_TEXTURE0_ARB);
1558  }
1559 
1560  data->glDisable(textype);
1561 
1562  data->drawstate.texturing = SDL_FALSE;
1563  data->drawstate.texture = NULL;
1564 
1565  return 0;
1566 }
1567 
1568 
1569 SDL_Renderer *
1570 GL_CreateRenderer(SDL_Window * window, Uint32 flags)
1571 {
1573  GL_RenderData *data;
1574  GLint value;
1575  Uint32 window_flags;
1576  int profile_mask = 0, major = 0, minor = 0;
1577  SDL_bool changed_window = SDL_FALSE;
1578 
1582 
1583  window_flags = SDL_GetWindowFlags(window);
1584  if (!(window_flags & SDL_WINDOW_OPENGL) ||
1585  profile_mask == SDL_GL_CONTEXT_PROFILE_ES || major != RENDERER_CONTEXT_MAJOR || minor != RENDERER_CONTEXT_MINOR) {
1586 
1587  changed_window = SDL_TRUE;
1589  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, RENDERER_CONTEXT_MAJOR);
1590  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, RENDERER_CONTEXT_MINOR);
1591 
1592  if (SDL_RecreateWindow(window, window_flags | SDL_WINDOW_OPENGL) < 0) {
1593  goto error;
1594  }
1595  }
1596 
1597  renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
1598  if (!renderer) {
1599  SDL_OutOfMemory();
1600  goto error;
1601  }
1602 
1603  data = (GL_RenderData *) SDL_calloc(1, sizeof(*data));
1604  if (!data) {
1605  SDL_free(renderer);
1606  SDL_OutOfMemory();
1607  goto error;
1608  }
1609 
1610  renderer->GetOutputSize = GL_GetOutputSize;
1611  renderer->SupportsBlendMode = GL_SupportsBlendMode;
1612  renderer->CreateTexture = GL_CreateTexture;
1613  renderer->UpdateTexture = GL_UpdateTexture;
1614  renderer->UpdateTextureYUV = GL_UpdateTextureYUV;
1615  renderer->LockTexture = GL_LockTexture;
1616  renderer->UnlockTexture = GL_UnlockTexture;
1617  renderer->SetTextureScaleMode = GL_SetTextureScaleMode;
1618  renderer->SetRenderTarget = GL_SetRenderTarget;
1619  renderer->QueueSetViewport = GL_QueueSetViewport;
1620  renderer->QueueSetDrawColor = GL_QueueSetViewport; /* SetViewport and SetDrawColor are (currently) no-ops. */
1621  renderer->QueueDrawPoints = GL_QueueDrawPoints;
1622  renderer->QueueDrawLines = GL_QueueDrawPoints; /* lines and points queue vertices the same way. */
1623  renderer->QueueFillRects = GL_QueueFillRects;
1624  renderer->QueueCopy = GL_QueueCopy;
1625  renderer->QueueCopyEx = GL_QueueCopyEx;
1626  renderer->RunCommandQueue = GL_RunCommandQueue;
1627  renderer->RenderReadPixels = GL_RenderReadPixels;
1628  renderer->RenderPresent = GL_RenderPresent;
1629  renderer->DestroyTexture = GL_DestroyTexture;
1630  renderer->DestroyRenderer = GL_DestroyRenderer;
1631  renderer->GL_BindTexture = GL_BindTexture;
1632  renderer->GL_UnbindTexture = GL_UnbindTexture;
1636  renderer->window = window;
1637 
1638  data->context = SDL_GL_CreateContext(window);
1639  if (!data->context) {
1640  SDL_free(renderer);
1641  SDL_free(data);
1642  goto error;
1643  }
1644  if (SDL_GL_MakeCurrent(window, data->context) < 0) {
1645  SDL_GL_DeleteContext(data->context);
1646  SDL_free(renderer);
1647  SDL_free(data);
1648  goto error;
1649  }
1650 
1651  if (GL_LoadFunctions(data) < 0) {
1652  SDL_GL_DeleteContext(data->context);
1653  SDL_free(renderer);
1654  SDL_free(data);
1655  goto error;
1656  }
1657 
1658 #ifdef __MACOSX__
1659  /* Enable multi-threaded rendering */
1660  /* Disabled until Ryan finishes his VBO/PBO code...
1661  CGLEnable(CGLGetCurrentContext(), kCGLCEMPEngine);
1662  */
1663 #endif
1664 
1667  } else {
1669  }
1670  if (SDL_GL_GetSwapInterval() > 0) {
1672  }
1673 
1674  /* Check for debug output support */
1677  data->debug_enabled = SDL_TRUE;
1678  }
1679  if (data->debug_enabled && SDL_GL_ExtensionSupported("GL_ARB_debug_output")) {
1680  PFNGLDEBUGMESSAGECALLBACKARBPROC glDebugMessageCallbackARBFunc = (PFNGLDEBUGMESSAGECALLBACKARBPROC) SDL_GL_GetProcAddress("glDebugMessageCallbackARB");
1681 
1682  data->GL_ARB_debug_output_supported = SDL_TRUE;
1683  data->glGetPointerv(GL_DEBUG_CALLBACK_FUNCTION_ARB, (GLvoid **)(char *)&data->next_error_callback);
1684  data->glGetPointerv(GL_DEBUG_CALLBACK_USER_PARAM_ARB, &data->next_error_userparam);
1685  glDebugMessageCallbackARBFunc(GL_HandleDebugMessage, renderer);
1686 
1687  /* Make sure our callback is called when errors actually happen */
1689  }
1690 
1691  data->textype = GL_TEXTURE_2D;
1692  if (SDL_GL_ExtensionSupported("GL_ARB_texture_non_power_of_two")) {
1693  data->GL_ARB_texture_non_power_of_two_supported = SDL_TRUE;
1694  } else if (SDL_GL_ExtensionSupported("GL_ARB_texture_rectangle") ||
1695  SDL_GL_ExtensionSupported("GL_EXT_texture_rectangle")) {
1696  data->GL_ARB_texture_rectangle_supported = SDL_TRUE;
1697  data->textype = GL_TEXTURE_RECTANGLE_ARB;
1698  }
1699  if (data->GL_ARB_texture_rectangle_supported) {
1700  data->glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB, &value);
1703  } else {
1704  data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
1707  }
1708 
1709  /* Check for multitexture support */
1710  if (SDL_GL_ExtensionSupported("GL_ARB_multitexture")) {
1711  data->glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC) SDL_GL_GetProcAddress("glActiveTextureARB");
1712  if (data->glActiveTextureARB) {
1713  data->GL_ARB_multitexture_supported = SDL_TRUE;
1714  data->glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &data->num_texture_units);
1715  }
1716  }
1717 
1718  /* Check for shader support */
1720  data->shaders = GL_CreateShaderContext();
1721  }
1722  SDL_LogInfo(SDL_LOG_CATEGORY_RENDER, "OpenGL shaders: %s",
1723  data->shaders ? "ENABLED" : "DISABLED");
1724 
1725  /* We support YV12 textures using 3 textures and a shader */
1726  if (data->shaders && data->num_texture_units >= 3) {
1731  }
1732 
1733 #ifdef __MACOSX__
1735 #endif
1736 
1737  if (SDL_GL_ExtensionSupported("GL_EXT_framebuffer_object")) {
1738  data->GL_EXT_framebuffer_object_supported = SDL_TRUE;
1739  data->glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)
1740  SDL_GL_GetProcAddress("glGenFramebuffersEXT");
1741  data->glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)
1742  SDL_GL_GetProcAddress("glDeleteFramebuffersEXT");
1743  data->glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)
1744  SDL_GL_GetProcAddress("glFramebufferTexture2DEXT");
1745  data->glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)
1746  SDL_GL_GetProcAddress("glBindFramebufferEXT");
1747  data->glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)
1748  SDL_GL_GetProcAddress("glCheckFramebufferStatusEXT");
1750  }
1751  data->framebuffers = NULL;
1752 
1753  /* Set up parameters for rendering */
1754  data->glMatrixMode(GL_MODELVIEW);
1755  data->glLoadIdentity();
1756  data->glDisable(GL_DEPTH_TEST);
1757  data->glDisable(GL_CULL_FACE);
1758  data->glDisable(GL_SCISSOR_TEST);
1759  data->glDisable(data->textype);
1760  data->glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
1761  data->glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
1762  /* This ended up causing video discrepancies between OpenGL and Direct3D */
1763  /* data->glEnable(GL_LINE_SMOOTH); */
1764 
1765  data->drawstate.blend = SDL_BLENDMODE_INVALID;
1766  data->drawstate.shader = SHADER_INVALID;
1767  data->drawstate.color = 0xFFFFFFFF;
1768  data->drawstate.clear_color = 0xFFFFFFFF;
1769 
1770  return renderer;
1771 
1772 error:
1773  if (changed_window) {
1774  /* Uh oh, better try to put it back... */
1778  SDL_RecreateWindow(window, window_flags);
1779  }
1780  return NULL;
1781 }
1782 
1783 
1785  GL_CreateRenderer,
1786  {
1787  "opengl",
1789  4,
1790  {
1795  },
1796  0,
1797  0}
1798 };
1799 
1800 
1801 #endif /* SDL_VIDEO_RENDER_OGL && !SDL_RENDER_DISABLED */
1802 
1803 /* vi: set ts=4 sw=4 expandtab: */
SHADER_NV12_JPEG
@ SHADER_NV12_JPEG
Definition: SDL_shaders_d3d11.h:31
GL_TABLE_TOO_LARGE
#define GL_TABLE_TOO_LARGE
Definition: SDL_opengl.h:1648
format
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
points
GLfixed GLfixed GLint GLint GLfixed points
Definition: SDL_opengl_glext.h:4561
Uint8
uint8_t Uint8
Definition: SDL_stdinc.h:179
SDL_BLENDOPERATION_ADD
@ SDL_BLENDOPERATION_ADD
Definition: SDL_blendmode.h:67
GL_ONE
#define GL_ONE
Definition: SDL_opengl.h:401
GLdouble
double GLdouble
Definition: SDL_opengl.h:189
SDL_GetPixelFormatName
#define SDL_GetPixelFormatName
Definition: SDL_dynapi_overrides.h:277
SHADER_NV12_BT601
@ SHADER_NV12_BT601
Definition: SDL_shaders_d3d11.h:32
SDL_Renderer::GL_UnbindTexture
int(* GL_UnbindTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:152
GL_POINTS
#define GL_POINTS
Definition: SDL_opengl.h:216
SDL_small_free
#define SDL_small_free(ptr, isstack)
Definition: SDL_internal.h:40
target
GLenum target
Definition: SDL_opengl_glext.h:1554
SDL_BLENDFACTOR_DST_COLOR
@ SDL_BLENDFACTOR_DST_COLOR
Definition: SDL_blendmode.h:86
blendMode
static SDL_BlendMode blendMode
Definition: testdraw2.c:34
SDL_RecreateWindow
int SDL_RecreateWindow(SDL_Window *window, Uint32 flags)
Definition: SDL_video.c:1635
GLvoid
void GLvoid
Definition: SDL_opengl.h:179
GL_UNSIGNED_SHORT_8_8_APPLE
#define GL_UNSIGNED_SHORT_8_8_APPLE
Definition: SDL_opengl_glext.h:5228
SDL_BLENDFACTOR_SRC_COLOR
@ SDL_BLENDFACTOR_SRC_COLOR
Definition: SDL_blendmode.h:82
GL_TEXTURE_2D
#define GL_TEXTURE_2D
Definition: SDL_opengl.h:671
SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR
@ SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR
Definition: SDL_blendmode.h:83
if
set set set set set set set macro pixldst1 abits if abits op else op endif endm macro pixldst2 abits if abits op else op endif endm macro pixldst4 abits if abits op else op endif endm macro pixldst0 abits op endm macro pixldst3 mem_operand op endm macro pixldst30 mem_operand op endm macro pixldst abits if abits elseif abits elseif abits elseif abits elseif abits pixldst0 abits else pixldst0 abits pixldst0 abits pixldst0 abits pixldst0 abits endif elseif abits else pixldst0 abits pixldst0 abits endif elseif abits else error unsupported bpp *numpix else pixst endif endm macro pixld1_s mem_operand if asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl elseif asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl else error unsupported endif endm macro pixld2_s mem_operand if mov asr add asl add asl mov asr sub UNIT_X add asl mov asr add asl add asl mov asr add UNIT_X add asl else pixld1_s mem_operand pixld1_s mem_operand endif endm macro pixld0_s mem_operand if asr adds SRC_WIDTH_FIXED bpl add asl elseif asr adds SRC_WIDTH_FIXED bpl add asl endif endm macro pixld_s_internal mem_operand if mem_operand pixld2_s mem_operand pixdeinterleave basereg elseif mem_operand elseif mem_operand elseif mem_operand elseif mem_operand pixld0_s mem_operand else pixld0_s mem_operand pixld0_s mem_operand pixld0_s mem_operand pixld0_s mem_operand endif elseif mem_operand else pixld0_s mem_operand pixld0_s mem_operand endif elseif mem_operand else error unsupported mem_operand if bpp mem_operand endif endm macro vuzp8 reg2 vuzp d d &reg2 endm macro vzip8 reg2 vzip d d &reg2 endm macro pixdeinterleave basereg basereg basereg basereg basereg endif endm macro pixinterleave basereg basereg basereg basereg basereg endif endm macro PF boost_increment endif if endif PF tst PF addne PF subne PF cmp ORIG_W if endif if endif if endif PF subge ORIG_W PF subges if endif if endif if endif endif endm macro cache_preload_simple endif if dst_r_bpp pld[DST_R, #(PREFETCH_DISTANCE_SIMPLE *dst_r_bpp/8)] endif if mask_bpp pld if[MASK, #(PREFETCH_DISTANCE_SIMPLE *mask_bpp/8)] endif endif endm macro fetch_mask_pixblock pixld mask_basereg pixblock_size MASK endm macro ensure_destination_ptr_alignment process_pixblock_tail_head if beq irp skip1(dst_w_bpp<=(lowbit *8)) &&((lowbit *8)<(pixblock_size *dst_w_bpp)) .if lowbit< 16 tst DST_R
Definition: pixman-arm-neon-asm.h:469
SDL_Renderer::QueueCopyEx
int(* 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)
Definition: SDL_sysrender.h:127
SDL_PIXELFORMAT_RGB888
@ SDL_PIXELFORMAT_RGB888
Definition: SDL_pixels.h:239
SDL_AllocateRenderVertices
void * SDL_AllocateRenderVertices(SDL_Renderer *renderer, const size_t numbytes, const size_t alignment, size_t *offset)
Definition: SDL_render.c:263
GL_FALSE
#define GL_FALSE
Definition: SDL_opengl.h:199
SDL_Renderer::RunCommandQueue
int(* RunCommandQueue)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
Definition: SDL_sysrender.h:130
SDL_PIXELFORMAT_NV21
@ SDL_PIXELFORMAT_NV21
Definition: SDL_pixels.h:292
SDL_FPoint::x
float x
Definition: SDL_rect.h:62
SDL_PIXELFORMAT_UYVY
@ SDL_PIXELFORMAT_UYVY
Definition: SDL_pixels.h:286
SDL_FRect::h
float h
Definition: SDL_rect.h:92
source
GLsizei GLsizei GLchar * source
Definition: SDL_opengl_glext.h:680
NULL
#define NULL
Definition: begin_code.h:167
GL_NEAREST
#define GL_NEAREST
Definition: SDL_opengl.h:704
SDL_opengl.h
b
GLboolean GLboolean GLboolean b
Definition: SDL_opengl_glext.h:1112
SDL_Renderer::SetRenderTarget
int(* SetRenderTarget)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:143
GL_BGRA
#define GL_BGRA
Definition: SDL_opengl.h:1511
message
GLuint GLsizei const GLchar * message
Definition: SDL_opengl_glext.h:2486
GL_TEXTURE0_ARB
#define GL_TEXTURE0_ARB
Definition: SDL_opengl.h:1990
SDL_BLENDMODE_INVALID
@ SDL_BLENDMODE_INVALID
Definition: SDL_blendmode.h:56
GL_STACK_UNDERFLOW
#define GL_STACK_UNDERFLOW
Definition: SDL_opengl.h:724
g
GLboolean GLboolean g
Definition: SDL_opengl_glext.h:1112
GL_MAX_TEXTURE_SIZE
#define GL_MAX_TEXTURE_SIZE
Definition: SDL_opengl.h:536
GL_CreateShaderContext
GL_ShaderContext * GL_CreateShaderContext(void)
SDL_log.h
GL_DEBUG_CALLBACK_FUNCTION_ARB
#define GL_DEBUG_CALLBACK_FUNCTION_ARB
Definition: SDL_opengl_glext.h:2723
SDL_BLENDFACTOR_SRC_ALPHA
@ SDL_BLENDFACTOR_SRC_ALPHA
Definition: SDL_blendmode.h:84
SDL_GL_CreateContext
#define SDL_GL_CreateContext
Definition: SDL_dynapi_overrides.h:559
count
GLuint GLuint GLsizei count
Definition: SDL_opengl.h:1571
GL_FUNC_ADD
#define GL_FUNC_ADD
Definition: SDL_opengl.h:1652
SDL_GetWindowFlags
#define SDL_GetWindowFlags
Definition: SDL_dynapi_overrides.h:518
SDL_HINT_RENDER_OPENGL_SHADERS
#define SDL_HINT_RENDER_OPENGL_SHADERS
A variable controlling whether the OpenGL render driver uses shaders if they are available.
Definition: SDL_hints.h:96
SHADER_YUV_JPEG
@ SHADER_YUV_JPEG
Definition: SDL_shaders_d3d.h:26
SDL_RenderCommand::next
struct SDL_RenderCommand * next
Definition: SDL_sysrender.h:104
SDL_PIXELFORMAT_BGR888
@ SDL_PIXELFORMAT_BGR888
Definition: SDL_pixels.h:245
userParam
const void * userParam
Definition: SDL_opengl_glext.h:2484
GL_ONE_MINUS_DST_ALPHA
#define GL_ONE_MINUS_DST_ALPHA
Definition: SDL_opengl.h:407
r
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
SDL_WINDOW_OPENGL
@ SDL_WINDOW_OPENGL
Definition: SDL_video.h:100
SDL_BlendOperation
SDL_BlendOperation
The blend operation used when combining source and destination pixel components.
Definition: SDL_blendmode.h:66
SDL_realloc
#define SDL_realloc
Definition: SDL_dynapi_overrides.h:376
viewport
static SDL_Rect viewport
Definition: testviewport.c:28
GL_ShaderContext
struct GL_ShaderContext GL_ShaderContext
Definition: SDL_shaders_gl.h:47
GL_RGB8
#define GL_RGB8
Definition: SDL_opengl.h:781
SDL_RenderDriver
Definition: SDL_sysrender.h:223
SDL_GL_CONTEXT_PROFILE_MASK
@ SDL_GL_CONTEXT_PROFILE_MASK
Definition: SDL_video.h:220
SDL_FRect::x
float x
Definition: SDL_rect.h:89
GL_COLOR_BUFFER_BIT
#define GL_COLOR_BUFFER_BIT
Definition: SDL_opengl.h:742
Uint32
uint32_t Uint32
Definition: SDL_stdinc.h:203
shaders
GLsizei GLsizei GLuint * shaders
Definition: SDL_opengl_glext.h:674
input
GLenum GLenum GLenum input
Definition: SDL_opengl_glext.h:9377
SDL_BlendFactor
SDL_BlendFactor
The normalized factor used to multiply pixel components.
Definition: SDL_blendmode.h:79
GL_UNPACK_ALIGNMENT
#define GL_UNPACK_ALIGNMENT
Definition: SDL_opengl.h:658
SDL_BLENDFACTOR_DST_ALPHA
@ SDL_BLENDFACTOR_DST_ALPHA
Definition: SDL_blendmode.h:88
GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB
#define GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB
Definition: SDL_opengl_glext.h:2721
SDL_FPoint::y
float y
Definition: SDL_rect.h:63
x1
GLuint GLfloat GLfloat GLfloat x1
Definition: SDL_opengl_glext.h:8586
a
GLboolean GLboolean GLboolean GLboolean a
Definition: SDL_opengl_glext.h:1112
h
GLfloat GLfloat GLfloat GLfloat h
Definition: SDL_opengl_glext.h:1949
GL_DestroyShaderContext
void GL_DestroyShaderContext(GL_ShaderContext *ctx)
SDL_small_alloc
#define SDL_small_alloc(type, count, pisstack)
Definition: SDL_internal.h:39
length
GLuint GLsizei GLsizei * length
Definition: SDL_opengl_glext.h:672
SDL_Rect::x
int x
Definition: SDL_rect.h:79
GL_LUMINANCE_ALPHA
#define GL_LUMINANCE_ALPHA
Definition: SDL_opengl.h:511
SDL_RENDERCMD_COPY
@ SDL_RENDERCMD_COPY
Definition: SDL_sysrender.h:76
SDL_BLENDFACTOR_ZERO
@ SDL_BLENDFACTOR_ZERO
Definition: SDL_blendmode.h:80
SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA
@ SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA
Definition: SDL_blendmode.h:89
shader
GLuint shader
Definition: SDL_opengl_glext.h:662
GL_BLEND
#define GL_BLEND
Definition: SDL_opengl.h:397
SDL_RENDERCMD_SETCLIPRECT
@ SDL_RENDERCMD_SETCLIPRECT
Definition: SDL_sysrender.h:70
result
GLuint64EXT * result
Definition: SDL_opengl_glext.h:9435
SDL_LogError
#define SDL_LogError
Definition: SDL_dynapi_overrides.h:36
SDL_PIXELFORMAT_IYUV
@ SDL_PIXELFORMAT_IYUV
Definition: SDL_pixels.h:282
GL_CULL_FACE
#define GL_CULL_FACE
Definition: SDL_opengl.h:302
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: SDL_opengl.h:1974
SDL_Rect::w
int w
Definition: SDL_rect.h:80
SDL_BLENDOPERATION_SUBTRACT
@ SDL_BLENDOPERATION_SUBTRACT
Definition: SDL_blendmode.h:68
GL_TEXTURE_WRAP_T
#define GL_TEXTURE_WRAP_T
Definition: SDL_opengl.h:673
GL_ZERO
#define GL_ZERO
Definition: SDL_opengl.h:400
SDL_Window
The type used to identify a window.
Definition: SDL_sysvideo.h:75
SHADER_NV12_BT709
@ SHADER_NV12_BT709
Definition: SDL_shaders_d3d11.h:33
SDL_YUV_CONVERSION_JPEG
@ SDL_YUV_CONVERSION_JPEG
Definition: SDL_surface.h:106
dst
GLenum GLenum dst
Definition: SDL_opengl_glext.h:1740
GL_LINE_STRIP
#define GL_LINE_STRIP
Definition: SDL_opengl.h:219
SDL_GL_GetDrawableSize
#define SDL_GL_GetDrawableSize
Definition: SDL_dynapi_overrides.h:563
SDL_GLContext
void * SDL_GLContext
An opaque handle to an OpenGL context.
Definition: SDL_video.h:192
GL_INVALID_OPERATION
#define GL_INVALID_OPERATION
Definition: SDL_opengl.h:722
SDL_GL_CONTEXT_DEBUG_FLAG
@ SDL_GL_CONTEXT_DEBUG_FLAG
Definition: SDL_video.h:237
SDL_memcpy
#define SDL_memcpy
Definition: SDL_dynapi_overrides.h:387
GL_TEXTURE_MIN_FILTER
#define GL_TEXTURE_MIN_FILTER
Definition: SDL_opengl.h:675
SDL_GetHintBoolean
#define SDL_GetHintBoolean
Definition: SDL_dynapi_overrides.h:608
SDL_Renderer
Definition: SDL_sysrender.h:110
GL_PROJECTION
#define GL_PROJECTION
Definition: SDL_opengl.h:272
context
static screen_context_t context
Definition: video.c:25
SDL_Renderer::QueueSetDrawColor
int(* QueueSetDrawColor)(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
Definition: SDL_sysrender.h:118
SDL_FPoint
The structure that defines a point (floating point)
Definition: SDL_rect.h:61
SDL_Renderer::driverdata
void * driverdata
Definition: SDL_sysrender.h:218
SDL_FRect::y
float y
Definition: SDL_rect.h:90
SDL_RenderCommand::color
struct SDL_RenderCommand::@23::@27 color
GL_RGBA8
#define GL_RGBA8
Definition: SDL_opengl.h:788
SDL_FRect::w
float w
Definition: SDL_rect.h:91
GL_Shader
GL_Shader
Definition: SDL_shaders_gl.h:29
retval
SDL_bool retval
Definition: testgamecontroller.c:65
GL_PACK_ROW_LENGTH
#define GL_PACK_ROW_LENGTH
Definition: SDL_opengl.h:654
x
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
color
GLuint color
Definition: SDL_opengl_glext.h:1151
window
EGLSurface EGLNativeWindowType * window
Definition: eglext.h:1025
GL_LINE_LOOP
#define GL_LINE_LOOP
Definition: SDL_opengl.h:218
GL_UNPACK_CLIENT_STORAGE_APPLE
#define GL_UNPACK_CLIENT_STORAGE_APPLE
Definition: SDL_opengl_glext.h:5131
SDL_GL_GetProcAddress
#define SDL_GL_GetProcAddress
Definition: SDL_dynapi_overrides.h:554
SDL_Renderer::SetTextureScaleMode
void(* SetTextureScaleMode)(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ScaleMode scaleMode)
Definition: SDL_sysrender.h:142
SDL_RendererInfo::flags
Uint32 flags
Definition: SDL_render.h:81
SDL_GL_SetAttribute
#define SDL_GL_SetAttribute
Definition: SDL_dynapi_overrides.h:557
SDL_Rect::y
int y
Definition: SDL_rect.h:79
GL_ONE_MINUS_SRC_COLOR
#define GL_ONE_MINUS_SRC_COLOR
Definition: SDL_opengl.h:403
GL_NO_ERROR
#define GL_NO_ERROR
Definition: SDL_opengl.h:719
SDL_memcmp
#define SDL_memcmp
Definition: SDL_dynapi_overrides.h:389
SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR
@ SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR
Definition: SDL_blendmode.h:87
SDL_Rect::h
int h
Definition: SDL_rect.h:80
SDL_free
#define SDL_free
Definition: SDL_dynapi_overrides.h:377
f
GLfloat f
Definition: SDL_opengl_glext.h:1873
SDL_BLENDMODE_NONE
@ SDL_BLENDMODE_NONE
Definition: SDL_blendmode.h:42
SDL_Renderer::SupportsBlendMode
SDL_bool(* SupportsBlendMode)(SDL_Renderer *renderer, SDL_BlendMode blendMode)
Definition: SDL_sysrender.h:115
GL_UNSIGNED_INT_8_8_8_8_REV
#define GL_UNSIGNED_INT_8_8_8_8_REV
Definition: SDL_opengl.h:1521
SDL_RENDERCMD_SETVIEWPORT
@ SDL_RENDERCMD_SETVIEWPORT
Definition: SDL_sysrender.h:69
SDL_Renderer::QueueDrawLines
int(* QueueDrawLines)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
Definition: SDL_sysrender.h:121
SDL_LogDebug
#define SDL_LogDebug
Definition: SDL_dynapi_overrides.h:33
SDL_RENDERER_PRESENTVSYNC
@ SDL_RENDERER_PRESENTVSYNC
Definition: SDL_render.h:69
SDL_ScaleMode
SDL_ScaleMode
The scaling mode for a texture.
Definition: SDL_render.h:92
SDL_RENDERCMD_DRAW_POINTS
@ SDL_RENDERCMD_DRAW_POINTS
Definition: SDL_sysrender.h:73
rect
SDL_Rect rect
Definition: testrelative.c:27
GL_DEPTH_TEST
#define GL_DEPTH_TEST
Definition: SDL_opengl.h:327
SDL_GL_CONTEXT_PROFILE_ES
@ SDL_GL_CONTEXT_PROFILE_ES
Definition: SDL_video.h:232
SDL_GL_GetSwapInterval
#define SDL_GL_GetSwapInterval
Definition: SDL_dynapi_overrides.h:565
SDL_assert.h
GL_UNPACK_ROW_LENGTH
#define GL_UNPACK_ROW_LENGTH
Definition: SDL_opengl.h:660
GL_TRUE
#define GL_TRUE
Definition: SDL_opengl.h:200
SHADER_RGBA
@ SHADER_RGBA
Definition: SDL_shaders_gl.h:34
SetDrawState
static void SetDrawState(SDL_Surface *surface, SW_DrawStateCache *drawstate)
Definition: SDL_render_sw.c:589
SDL_GL_SetSwapInterval
#define SDL_GL_SetSwapInterval
Definition: SDL_dynapi_overrides.h:564
GLDEBUGPROCARB
void(APIENTRY * GLDEBUGPROCARB)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam)
Definition: SDL_opengl_glext.h:2720
SHADER_SOLID
@ SHADER_SOLID
Definition: SDL_shaders_d3d11.h:26
GL_TEXTURE2_ARB
#define GL_TEXTURE2_ARB
Definition: SDL_opengl.h:1992
SHADER_NV21_BT709
@ SHADER_NV21_BT709
Definition: SDL_shaders_d3d11.h:36
SDL_GetBlendModeDstAlphaFactor
SDL_BlendFactor SDL_GetBlendModeDstAlphaFactor(SDL_BlendMode blendMode)
Definition: SDL_render.c:3391
GL_TEXTURE_MAG_FILTER
#define GL_TEXTURE_MAG_FILTER
Definition: SDL_opengl.h:674
SDL_Renderer::GL_BindTexture
int(* GL_BindTexture)(SDL_Renderer *renderer, SDL_Texture *texture, float *texw, float *texh)
Definition: SDL_sysrender.h:151
SDL_RenderCommand::command
SDL_RenderCommandType command
Definition: SDL_sysrender.h:82
SDL_TRUE
@ SDL_TRUE
Definition: SDL_stdinc.h:164
SDL_RENDERCMD_NO_OP
@ SDL_RENDERCMD_NO_OP
Definition: SDL_sysrender.h:68
SDL_Renderer::QueueSetViewport
int(* QueueSetViewport)(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
Definition: SDL_sysrender.h:117
SDL_PIXELFORMAT_ARGB8888
@ SDL_PIXELFORMAT_ARGB8888
Definition: SDL_pixels.h:251
SDL_assert
#define SDL_assert(condition)
Definition: SDL_assert.h:169
SDL_GL_GetCurrentContext
#define SDL_GL_GetCurrentContext
Definition: SDL_dynapi_overrides.h:562
GL_TEXTURE_WRAP_S
#define GL_TEXTURE_WRAP_S
Definition: SDL_opengl.h:672
GL_TEXTURE1_ARB
#define GL_TEXTURE1_ARB
Definition: SDL_opengl.h:1991
SDL_RENDERCMD_DRAW_LINES
@ SDL_RENDERCMD_DRAW_LINES
Definition: SDL_sysrender.h:74
pixels
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: SDL_opengl.h:1572
SDL_Renderer::GetOutputSize
int(* GetOutputSize)(SDL_Renderer *renderer, int *w, int *h)
Definition: SDL_sysrender.h:114
APIENTRY
#define APIENTRY
Definition: SDL_opengl.h:139
GL_YCBCR_422_APPLE
#define GL_YCBCR_422_APPLE
Definition: SDL_opengl_glext.h:5329
SDL_OutOfMemory
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_FLIP_VERTICAL
@ SDL_FLIP_VERTICAL
Definition: SDL_render.h:125
GL_TEXTURE_RECTANGLE_ARB
#define GL_TEXTURE_RECTANGLE_ARB
Definition: SDL_opengl_glext.h:3988
SDL_Renderer::CreateTexture
int(* CreateTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:116
SDL_glfuncs.h
SHADER_INVALID
@ SHADER_INVALID
Definition: SDL_shaders_gl.h:30
SDL_RenderCommand::data
union SDL_RenderCommand::@23 data
size
GLsizeiptr size
Definition: SDL_opengl_glext.h:540
y
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574
SDL_Texture::format
Uint32 format
Definition: SDL_sysrender.h:39
GL_COLOR_ATTACHMENT0_EXT
#define GL_COLOR_ATTACHMENT0_EXT
Definition: SDL_opengl_glext.h:6710
SDL_RENDERCMD_FILL_RECTS
@ SDL_RENDERCMD_FILL_RECTS
Definition: SDL_sysrender.h:75
GL_SCISSOR_TEST
#define GL_SCISSOR_TEST
Definition: SDL_opengl.h:615
SDL_Renderer::DestroyRenderer
void(* DestroyRenderer)(SDL_Renderer *renderer)
Definition: SDL_sysrender.h:149
SDL_Renderer::LockTexture
int(* LockTexture)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
Definition: SDL_sysrender.h:139
GL_TEXTURE_STORAGE_HINT_APPLE
#define GL_TEXTURE_STORAGE_HINT_APPLE
Definition: SDL_opengl_glext.h:5248
SDL_ScaleModeNearest
@ SDL_ScaleModeNearest
Definition: SDL_render.h:93
SDL_calloc
#define SDL_calloc
Definition: SDL_dynapi_overrides.h:375
SDL_GetRendererOutputSize
#define SDL_GetRendererOutputSize
Definition: SDL_dynapi_overrides.h:305
GL_FUNC_SUBTRACT
#define GL_FUNC_SUBTRACT
Definition: SDL_opengl.h:1653
SDL_LogInfo
#define SDL_LogInfo
Definition: SDL_dynapi_overrides.h:34
SDL_Renderer::RenderReadPixels
int(* RenderReadPixels)(SDL_Renderer *renderer, const SDL_Rect *rect, Uint32 format, void *pixels, int pitch)
Definition: SDL_sysrender.h:144
SDL_GetBlendModeSrcAlphaFactor
SDL_BlendFactor SDL_GetBlendModeSrcAlphaFactor(SDL_BlendMode blendMode)
Definition: SDL_render.c:3384
SDL_GetBlendModeColorOperation
SDL_BlendOperation SDL_GetBlendModeColorOperation(SDL_BlendMode blendMode)
Definition: SDL_render.c:3377
SDL_RENDERCMD_COPY_EX
@ SDL_RENDERCMD_COPY_EX
Definition: SDL_sysrender.h:77
GL_MAX_TEXTURE_UNITS_ARB
#define GL_MAX_TEXTURE_UNITS_ARB
Definition: SDL_opengl.h:2024
GL_SRC_COLOR
#define GL_SRC_COLOR
Definition: SDL_opengl.h:402
SDL_BLENDOPERATION_REV_SUBTRACT
@ SDL_BLENDOPERATION_REV_SUBTRACT
Definition: SDL_blendmode.h:69
glActiveTextureARB
GLAPI void GLAPIENTRY glActiveTextureARB(GLenum texture)
src
GLenum src
Definition: SDL_opengl_glext.h:1740
SDL_RenderCommand
Definition: SDL_sysrender.h:81
renderer
static SDL_Renderer * renderer
Definition: testaudiocapture.c:21
GL_DST_ALPHA
#define GL_DST_ALPHA
Definition: SDL_opengl.h:406
GL_MODELVIEW
#define GL_MODELVIEW
Definition: SDL_opengl.h:271
GL_STACK_OVERFLOW
#define GL_STACK_OVERFLOW
Definition: SDL_opengl.h:723
SDL_GetBlendModeDstColorFactor
SDL_BlendFactor SDL_GetBlendModeDstColorFactor(SDL_BlendMode blendMode)
Definition: SDL_render.c:3370
SDL_RenderCommand::cliprect
struct SDL_RenderCommand::@23::@25 cliprect
SDL_BLENDFACTOR_ONE
@ SDL_BLENDFACTOR_ONE
Definition: SDL_blendmode.h:81
SDL_Renderer::info
SDL_RendererInfo info
Definition: SDL_sysrender.h:158
value
GLsizei const GLfloat * value
Definition: SDL_opengl_glext.h:701
SDL_RENDERER_TARGETTEXTURE
@ SDL_RENDERER_TARGETTEXTURE
Definition: SDL_render.h:71
x2
GLfixed GLfixed x2
Definition: SDL_opengl_glext.h:4586
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:30
SDL_GL_CONTEXT_MINOR_VERSION
@ SDL_GL_CONTEXT_MINOR_VERSION
Definition: SDL_video.h:217
SDL_Renderer::RenderPresent
void(* RenderPresent)(SDL_Renderer *renderer)
Definition: SDL_sysrender.h:146
SDL_BYTESPERPIXEL
#define SDL_BYTESPERPIXEL(X)
Definition: SDL_pixels.h:128
GL_FRAMEBUFFER_COMPLETE_EXT
#define GL_FRAMEBUFFER_COMPLETE_EXT
Definition: SDL_opengl_glext.h:6701
SDL_Rect
A rectangle, with the origin at the upper left (integer).
Definition: SDL_rect.h:78
SDL_RendererInfo::max_texture_width
int max_texture_width
Definition: SDL_render.h:84
SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA
@ SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA
Definition: SDL_blendmode.h:85
GL_DEBUG_TYPE_ERROR_ARB
#define GL_DEBUG_TYPE_ERROR_ARB
Definition: SDL_opengl_glext.h:2731
SDL_shaders_gl.h
GL_RGBA
#define GL_RGBA
Definition: SDL_opengl.h:529
SDL_Texture
Definition: SDL_sysrender.h:37
SDL_Renderer::QueueFillRects
int(* QueueFillRects)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FRect *rects, int count)
Definition: SDL_sysrender.h:123
SDL_Renderer::UpdateTexture
int(* UpdateTexture)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch)
Definition: SDL_sysrender.h:131
SDL_hints.h
SDL_RendererFlip
SDL_RendererFlip
Flip constants for SDL_RenderCopyEx.
Definition: SDL_render.h:122
GLsizei
int GLsizei
Definition: SDL_opengl.h:186
SDL_PIXELFORMAT_NV12
@ SDL_PIXELFORMAT_NV12
Definition: SDL_pixels.h:290
SDL_GL_MakeCurrent
#define SDL_GL_MakeCurrent
Definition: SDL_dynapi_overrides.h:560
SDL_TEXTUREACCESS_TARGET
@ SDL_TEXTUREACCESS_TARGET
Definition: SDL_render.h:105
y1
GLfixed y1
Definition: SDL_opengl_glext.h:4586
GLenum
unsigned int GLenum
Definition: SDL_opengl.h:176
GL_PACK_ALIGNMENT
#define GL_PACK_ALIGNMENT
Definition: SDL_opengl.h:652
GL_DEBUG_CALLBACK_USER_PARAM_ARB
#define GL_DEBUG_CALLBACK_USER_PARAM_ARB
Definition: SDL_opengl_glext.h:2724
GL_STORAGE_SHARED_APPLE
#define GL_STORAGE_SHARED_APPLE
Definition: SDL_opengl_glext.h:5251
GL_LINEAR
#define GL_LINEAR
Definition: SDL_opengl.h:447
SDL_GL_GetAttribute
#define SDL_GL_GetAttribute
Definition: SDL_dynapi_overrides.h:558
SDL_FRect
A rectangle, with the origin at the upper left (floating point).
Definition: SDL_rect.h:88
y2
GLfixed GLfixed GLfixed y2
Definition: SDL_opengl_glext.h:4586
SDL_strdup
#define SDL_strdup
Definition: SDL_dynapi_overrides.h:397
SDL_RenderDriver::info
SDL_RendererInfo info
Definition: SDL_sysrender.h:227
SDL_ConvertPixels
#define SDL_ConvertPixels
Definition: SDL_dynapi_overrides.h:465
SHADER_RGB
@ SHADER_RGB
Definition: SDL_shaders_d3d11.h:27
angle
GLfloat angle
Definition: SDL_opengl_glext.h:6100
GL_INVALID_VALUE
#define GL_INVALID_VALUE
Definition: SDL_opengl.h:721
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:162
SDL_GetYUVConversionModeForResolution
#define SDL_GetYUVConversionModeForResolution
Definition: SDL_dynapi_overrides.h:665
GL_OUT_OF_MEMORY
#define GL_OUT_OF_MEMORY
Definition: SDL_opengl.h:725
GL_CLAMP_TO_EDGE
#define GL_CLAMP_TO_EDGE
Definition: SDL_opengl.h:1507
SDL_Renderer::QueueDrawPoints
int(* QueueDrawPoints)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
Definition: SDL_sysrender.h:119
SDL_FALSE
@ SDL_FALSE
Definition: SDL_stdinc.h:163
GLuint
unsigned int GLuint
Definition: SDL_opengl.h:185
SHADER_YUV_BT601
@ SHADER_YUV_BT601
Definition: SDL_shaders_d3d.h:27
SDL_GL_SwapWindow
#define SDL_GL_SwapWindow
Definition: SDL_dynapi_overrides.h:566
internalFormat
GLenum internalFormat
Definition: SDL_opengl_glext.h:5066
SDL_YUV_CONVERSION_BT709
@ SDL_YUV_CONVERSION_BT709
Definition: SDL_surface.h:108
SDL_malloc
#define SDL_malloc
Definition: SDL_dynapi_overrides.h:374
SDL_RENDERER_ACCELERATED
@ SDL_RENDERER_ACCELERATED
Definition: SDL_render.h:67
SDL_RendererInfo::texture_formats
Uint32 texture_formats[16]
Definition: SDL_render.h:83
GL_ONE_MINUS_SRC_ALPHA
#define GL_ONE_MINUS_SRC_ALPHA
Definition: SDL_opengl.h:405
framebuffers
const GLuint * framebuffers
Definition: SDL_opengl_glext.h:1178
SDL_RendererInfo::max_texture_height
int max_texture_height
Definition: SDL_render.h:85
SDL_GL_CONTEXT_FLAGS
@ SDL_GL_CONTEXT_FLAGS
Definition: SDL_video.h:219
SDL_PIXELFORMAT_YV12
@ SDL_PIXELFORMAT_YV12
Definition: SDL_pixels.h:280
SDL_RENDERCMD_SETDRAWCOLOR
@ SDL_RENDERCMD_SETDRAWCOLOR
Definition: SDL_sysrender.h:71
flags
GLbitfield flags
Definition: SDL_opengl_glext.h:1483
SDL_Renderer::QueueCopy
int(* QueueCopy)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_FRect *dstrect)
Definition: SDL_sysrender.h:125
SDL_Renderer::window
SDL_Window * window
Definition: SDL_sysrender.h:161
SDL_TEXTUREACCESS_STREAMING
@ SDL_TEXTUREACCESS_STREAMING
Definition: SDL_render.h:104
SDL_Renderer::target
SDL_Texture * target
Definition: SDL_sysrender.h:194
texture
GLenum GLenum GLuint texture
Definition: SDL_opengl_glext.h:1181
GL_SRC_ALPHA
#define GL_SRC_ALPHA
Definition: SDL_opengl.h:404
GL_STORAGE_CACHED_APPLE
#define GL_STORAGE_CACHED_APPLE
Definition: SDL_opengl_glext.h:5250
GL_INVALID_ENUM
#define GL_INVALID_ENUM
Definition: SDL_opengl.h:720
GL_DST_COLOR
#define GL_DST_COLOR
Definition: SDL_opengl.h:408
GL_ONE_MINUS_DST_COLOR
#define GL_ONE_MINUS_DST_COLOR
Definition: SDL_opengl.h:409
SDL_RenderCommand::viewport
struct SDL_RenderCommand::@23::@24 viewport
rects
EGLSurface EGLint * rects
Definition: eglext.h:282
SDL_FORCE_INLINE
#define SDL_FORCE_INLINE
Definition: begin_code.h:147
SDL_PIXELFORMAT_ABGR8888
@ SDL_PIXELFORMAT_ABGR8888
Definition: SDL_pixels.h:257
SDL_GetBlendModeAlphaOperation
SDL_BlendOperation SDL_GetBlendModeAlphaOperation(SDL_BlendMode blendMode)
Definition: SDL_render.c:3398
type
GLuint GLuint GLsizei GLenum type
Definition: SDL_opengl.h:1571
GL_FUNC_REVERSE_SUBTRACT
#define GL_FUNC_REVERSE_SUBTRACT
Definition: SDL_opengl.h:1654
GL_UNSIGNED_BYTE
#define GL_UNSIGNED_BYTE
Definition: SDL_opengl.h:204
GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB
#define GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB
Definition: SDL_opengl_glext.h:3991
SDL_GL_DeleteContext
#define SDL_GL_DeleteContext
Definition: SDL_dynapi_overrides.h:567
GL_RenderDriver
SDL_RenderDriver GL_RenderDriver
severity
GLenum GLenum severity
Definition: SDL_opengl_glext.h:2482
SDL_RenderCommand::draw
struct SDL_RenderCommand::@23::@26 draw
SHADER_NV21_JPEG
@ SHADER_NV21_JPEG
Definition: SDL_shaders_d3d11.h:34
SDL_LOG_CATEGORY_RENDER
@ SDL_LOG_CATEGORY_RENDER
Definition: SDL_log.h:72
GL_LUMINANCE
#define GL_LUMINANCE
Definition: SDL_opengl.h:510
SHADER_NV21_BT601
@ SHADER_NV21_BT601
Definition: SDL_shaders_d3d11.h:35
SDL_GetBlendModeSrcColorFactor
SDL_BlendFactor SDL_GetBlendModeSrcColorFactor(SDL_BlendMode blendMode)
Definition: SDL_render.c:3363
GL_TRIANGLE_STRIP
#define GL_TRIANGLE_STRIP
Definition: SDL_opengl.h:221
i
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)
Definition: SDL_x11sym.h:50
GLint
int GLint
Definition: SDL_opengl.h:182
GLfloat
float GLfloat
Definition: SDL_opengl.h:187
SDL_RENDERCMD_CLEAR
@ SDL_RENDERCMD_CLEAR
Definition: SDL_sysrender.h:72
SDL_YUV_CONVERSION_BT601
@ SDL_YUV_CONVERSION_BT601
Definition: SDL_surface.h:107
SDL_BlendMode
SDL_BlendMode
The blend mode used in SDL_RenderCopy() and drawing operations.
Definition: SDL_blendmode.h:41
GL_SelectShader
void GL_SelectShader(GL_ShaderContext *ctx, GL_Shader shader)
SDL_Renderer::UnlockTexture
void(* UnlockTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:141
SDL_RendererInfo::num_texture_formats
Uint32 num_texture_formats
Definition: SDL_render.h:82
SDL_GL_CONTEXT_MAJOR_VERSION
@ SDL_GL_CONTEXT_MAJOR_VERSION
Definition: SDL_video.h:216
SDL_Renderer::DestroyTexture
void(* DestroyTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:147
SDL_Renderer::UpdateTextureYUV
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)
Definition: SDL_sysrender.h:134
w
GLubyte GLubyte GLubyte GLubyte w
Definition: SDL_opengl_glext.h:734
SDL_FLIP_HORIZONTAL
@ SDL_FLIP_HORIZONTAL
Definition: SDL_render.h:124
SHADER_YUV_BT709
@ SHADER_YUV_BT709
Definition: SDL_shaders_d3d.h:28
SDL_GL_ExtensionSupported
#define SDL_GL_ExtensionSupported
Definition: SDL_dynapi_overrides.h:556
GL_FRAMEBUFFER_EXT
#define GL_FRAMEBUFFER_EXT
Definition: SDL_opengl_glext.h:6728