SDL  2.0
SDL_render_gles.c
Go to the documentation of this file.
1 /*
2  Simple DirectMedia Layer
3  Copyright (C) 1997-2019 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_ES && !SDL_RENDER_DISABLED
24 
25 #include "SDL_hints.h"
26 #include "SDL_opengles.h"
27 #include "../SDL_sysrender.h"
28 
29 /* To prevent unnecessary window recreation,
30  * these should match the defaults selected in SDL_GL_ResetAttributes
31  */
32 
33 #define RENDERER_CONTEXT_MAJOR 1
34 #define RENDERER_CONTEXT_MINOR 1
35 
36 #if defined(SDL_VIDEO_DRIVER_PANDORA)
37 
38 /* Empty function stub to get OpenGL ES 1.x support without */
39 /* OpenGL ES extension GL_OES_draw_texture supported */
40 GL_API void GL_APIENTRY
41 glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)
42 {
43  return;
44 }
45 
46 #endif /* SDL_VIDEO_DRIVER_PANDORA */
47 
48 /* OpenGL ES 1.1 renderer implementation, based on the OpenGL renderer */
49 
50 /* Used to re-create the window with OpenGL ES capability */
52 
53 static const float inv255f = 1.0f / 255.0f;
54 
55 typedef struct GLES_FBOList GLES_FBOList;
56 
57 struct GLES_FBOList
58 {
59  Uint32 w, h;
60  GLuint FBO;
61  GLES_FBOList *next;
62 };
63 
64 typedef struct
65 {
67  SDL_bool viewport_dirty;
70  int drawablew;
71  int drawableh;
72  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 } GLES_DrawStateCache;
81 
82 typedef struct
83 {
85 
86 #define SDL_PROC(ret,func,params) ret (APIENTRY *func) params;
87 #define SDL_PROC_OES SDL_PROC
88 #include "SDL_glesfuncs.h"
89 #undef SDL_PROC
90 #undef SDL_PROC_OES
91  SDL_bool GL_OES_framebuffer_object_supported;
92  GLES_FBOList *framebuffers;
93  GLuint window_framebuffer;
94 
95  SDL_bool GL_OES_blend_func_separate_supported;
96  SDL_bool GL_OES_blend_equation_separate_supported;
97  SDL_bool GL_OES_blend_subtract_supported;
98 
99  GLES_DrawStateCache drawstate;
100 } GLES_RenderData;
101 
102 typedef struct
103 {
104  GLuint texture;
105  GLenum type;
106  GLfloat texw;
107  GLfloat texh;
108  GLenum format;
109  GLenum formattype;
110  void *pixels;
111  int pitch;
112  GLES_FBOList *fbo;
113 } GLES_TextureData;
114 
115 static int
116 GLES_SetError(const char *prefix, GLenum result)
117 {
118  const char *error;
119 
120  switch (result) {
121  case GL_NO_ERROR:
122  error = "GL_NO_ERROR";
123  break;
124  case GL_INVALID_ENUM:
125  error = "GL_INVALID_ENUM";
126  break;
127  case GL_INVALID_VALUE:
128  error = "GL_INVALID_VALUE";
129  break;
131  error = "GL_INVALID_OPERATION";
132  break;
133  case GL_STACK_OVERFLOW:
134  error = "GL_STACK_OVERFLOW";
135  break;
136  case GL_STACK_UNDERFLOW:
137  error = "GL_STACK_UNDERFLOW";
138  break;
139  case GL_OUT_OF_MEMORY:
140  error = "GL_OUT_OF_MEMORY";
141  break;
142  default:
143  error = "UNKNOWN";
144  break;
145  }
146  return SDL_SetError("%s: %s", prefix, error);
147 }
148 
149 static int GLES_LoadFunctions(GLES_RenderData * data)
150 {
151 #if SDL_VIDEO_DRIVER_UIKIT
152 #define __SDL_NOGETPROCADDR__
153 #elif SDL_VIDEO_DRIVER_ANDROID
154 #define __SDL_NOGETPROCADDR__
155 #elif SDL_VIDEO_DRIVER_PANDORA
156 #define __SDL_NOGETPROCADDR__
157 #endif
158 
159 #ifdef __SDL_NOGETPROCADDR__
160 #define SDL_PROC(ret,func,params) data->func=func;
161 #define SDL_PROC_OES(ret,func,params) data->func=func;
162 #else
163 #define SDL_PROC(ret,func,params) \
164  do { \
165  data->func = SDL_GL_GetProcAddress(#func); \
166  if ( ! data->func ) { \
167  return SDL_SetError("Couldn't load GLES function %s: %s", #func, SDL_GetError()); \
168  } \
169  } while ( 0 );
170 #define SDL_PROC_OES(ret,func,params) \
171  do { \
172  data->func = SDL_GL_GetProcAddress(#func); \
173  } while ( 0 );
174 #endif /* __SDL_NOGETPROCADDR__ */
175 
176 #include "SDL_glesfuncs.h"
177 #undef SDL_PROC
178 #undef SDL_PROC_OES
179  return 0;
180 }
181 
182 static GLES_FBOList *
183 GLES_GetFBO(GLES_RenderData *data, Uint32 w, Uint32 h)
184 {
185  GLES_FBOList *result = data->framebuffers;
186  while ((result) && ((result->w != w) || (result->h != h)) ) {
187  result = result->next;
188  }
189  if (result == NULL) {
190  result = SDL_malloc(sizeof(GLES_FBOList));
191  result->w = w;
192  result->h = h;
193  data->glGenFramebuffersOES(1, &result->FBO);
194  result->next = data->framebuffers;
195  data->framebuffers = result;
196  }
197  return result;
198 }
199 
200 
201 static int
202 GLES_ActivateRenderer(SDL_Renderer * renderer)
203 {
204  GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
205 
206  if (SDL_GL_GetCurrentContext() != data->context) {
207  if (SDL_GL_MakeCurrent(renderer->window, data->context) < 0) {
208  return -1;
209  }
210  }
211 
212  return 0;
213 }
214 
215 static void
216 GLES_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
217 {
218  GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
219 
220  if (event->event == SDL_WINDOWEVENT_MINIMIZED) {
221  /* According to Apple documentation, we need to finish drawing NOW! */
222  data->glFinish();
223  }
224 }
225 
226 static int
227 GLES_GetOutputSize(SDL_Renderer * renderer, int *w, int *h)
228 {
230  return 0;
231 }
232 
233 static GLenum GetBlendFunc(SDL_BlendFactor factor)
234 {
235  switch (factor) {
237  return GL_ZERO;
238  case SDL_BLENDFACTOR_ONE:
239  return GL_ONE;
241  return GL_SRC_COLOR;
243  return GL_ONE_MINUS_SRC_COLOR;
245  return GL_SRC_ALPHA;
247  return GL_ONE_MINUS_SRC_ALPHA;
249  return GL_DST_COLOR;
251  return GL_ONE_MINUS_DST_COLOR;
253  return GL_DST_ALPHA;
255  return GL_ONE_MINUS_DST_ALPHA;
256  default:
257  return GL_INVALID_ENUM;
258  }
259 }
260 
261 static GLenum GetBlendEquation(SDL_BlendOperation operation)
262 {
263  switch (operation) {
265  return GL_FUNC_ADD_OES;
267  return GL_FUNC_SUBTRACT_OES;
269  return GL_FUNC_REVERSE_SUBTRACT_OES;
270  default:
271  return GL_INVALID_ENUM;
272  }
273 }
274 
275 static SDL_bool
276 GLES_SupportsBlendMode(SDL_Renderer * renderer, SDL_BlendMode blendMode)
277 {
278  GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
285 
286  if (GetBlendFunc(srcColorFactor) == GL_INVALID_ENUM ||
287  GetBlendFunc(srcAlphaFactor) == GL_INVALID_ENUM ||
288  GetBlendEquation(colorOperation) == GL_INVALID_ENUM ||
289  GetBlendFunc(dstColorFactor) == GL_INVALID_ENUM ||
290  GetBlendFunc(dstAlphaFactor) == GL_INVALID_ENUM ||
291  GetBlendEquation(alphaOperation) == GL_INVALID_ENUM) {
292  return SDL_FALSE;
293  }
294  if ((srcColorFactor != srcAlphaFactor || dstColorFactor != dstAlphaFactor) && !data->GL_OES_blend_func_separate_supported) {
295  return SDL_FALSE;
296  }
297  if (colorOperation != alphaOperation && !data->GL_OES_blend_equation_separate_supported) {
298  return SDL_FALSE;
299  }
300  if (colorOperation != SDL_BLENDOPERATION_ADD && !data->GL_OES_blend_subtract_supported) {
301  return SDL_FALSE;
302  }
303  return SDL_TRUE;
304 }
305 
306 static SDL_INLINE int
307 power_of_2(int input)
308 {
309  int value = 1;
310 
311  while (value < input) {
312  value <<= 1;
313  }
314  return value;
315 }
316 
317 static int
318 GLES_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
319 {
320  GLES_RenderData *renderdata = (GLES_RenderData *) renderer->driverdata;
321  GLES_TextureData *data;
323  GLenum format, type;
324  int texture_w, texture_h;
325  GLenum scaleMode;
326  GLenum result;
327 
328  GLES_ActivateRenderer(renderer);
329 
330  switch (texture->format) {
333  format = GL_RGBA;
335  break;
336  default:
337  return SDL_SetError("Texture format not supported");
338  }
339 
340  data = (GLES_TextureData *) SDL_calloc(1, sizeof(*data));
341  if (!data) {
342  return SDL_OutOfMemory();
343  }
344 
345  if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
346  data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
347  data->pixels = SDL_calloc(1, texture->h * data->pitch);
348  if (!data->pixels) {
349  SDL_free(data);
350  return SDL_OutOfMemory();
351  }
352  }
353 
354 
355  if (texture->access == SDL_TEXTUREACCESS_TARGET) {
356  if (!renderdata->GL_OES_framebuffer_object_supported) {
357  SDL_free(data);
358  return SDL_SetError("GL_OES_framebuffer_object not supported");
359  }
360  data->fbo = GLES_GetFBO(renderer->driverdata, texture->w, texture->h);
361  } else {
362  data->fbo = NULL;
363  }
364 
365 
366  renderdata->glGetError();
367  renderdata->glEnable(GL_TEXTURE_2D);
368  renderdata->glGenTextures(1, &data->texture);
369  result = renderdata->glGetError();
370  if (result != GL_NO_ERROR) {
371  if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
372  SDL_free(data->pixels);
373  }
374  SDL_free(data);
375  return GLES_SetError("glGenTextures()", result);
376  }
377 
378  data->type = GL_TEXTURE_2D;
379  /* no NPOV textures allowed in OpenGL ES (yet) */
380  texture_w = power_of_2(texture->w);
381  texture_h = power_of_2(texture->h);
382  data->texw = (GLfloat) texture->w / texture_w;
383  data->texh = (GLfloat) texture->h / texture_h;
384 
385  data->format = format;
386  data->formattype = type;
387  scaleMode = (texture->scaleMode == SDL_ScaleModeNearest) ? GL_NEAREST : GL_LINEAR;
388  renderdata->glBindTexture(data->type, data->texture);
389  renderdata->glTexParameteri(data->type, GL_TEXTURE_MIN_FILTER, scaleMode);
390  renderdata->glTexParameteri(data->type, GL_TEXTURE_MAG_FILTER, scaleMode);
391  renderdata->glTexParameteri(data->type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
392  renderdata->glTexParameteri(data->type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
393 
394  renderdata->glTexImage2D(data->type, 0, internalFormat, texture_w,
395  texture_h, 0, format, type, NULL);
396  renderdata->glDisable(GL_TEXTURE_2D);
397  renderdata->drawstate.texture = texture;
398  renderdata->drawstate.texturing = SDL_FALSE;
399 
400  result = renderdata->glGetError();
401  if (result != GL_NO_ERROR) {
402  if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
403  SDL_free(data->pixels);
404  }
405  SDL_free(data);
406  return GLES_SetError("glTexImage2D()", result);
407  }
408 
409  texture->driverdata = data;
410  return 0;
411 }
412 
413 static int
414 GLES_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
415  const SDL_Rect * rect, const void *pixels, int pitch)
416 {
417  GLES_RenderData *renderdata = (GLES_RenderData *) renderer->driverdata;
418  GLES_TextureData *data = (GLES_TextureData *) texture->driverdata;
419  Uint8 *blob = NULL;
420  Uint8 *src;
421  int srcPitch;
422  int y;
423 
424  GLES_ActivateRenderer(renderer);
425 
426  /* Bail out if we're supposed to update an empty rectangle */
427  if (rect->w <= 0 || rect->h <= 0) {
428  return 0;
429  }
430 
431  /* Reformat the texture data into a tightly packed array */
432  srcPitch = rect->w * SDL_BYTESPERPIXEL(texture->format);
433  src = (Uint8 *)pixels;
434  if (pitch != srcPitch) {
435  blob = (Uint8 *)SDL_malloc(srcPitch * rect->h);
436  if (!blob) {
437  return SDL_OutOfMemory();
438  }
439  src = blob;
440  for (y = 0; y < rect->h; ++y) {
441  SDL_memcpy(src, pixels, srcPitch);
442  src += srcPitch;
443  pixels = (Uint8 *)pixels + pitch;
444  }
445  src = blob;
446  }
447 
448  /* Create a texture subimage with the supplied data */
449  renderdata->glGetError();
450  renderdata->glEnable(data->type);
451  renderdata->glBindTexture(data->type, data->texture);
452  renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
453  renderdata->glTexSubImage2D(data->type,
454  0,
455  rect->x,
456  rect->y,
457  rect->w,
458  rect->h,
459  data->format,
460  data->formattype,
461  src);
462  renderdata->glDisable(data->type);
463  SDL_free(blob);
464 
465  renderdata->drawstate.texture = texture;
466  renderdata->drawstate.texturing = SDL_FALSE;
467 
468  if (renderdata->glGetError() != GL_NO_ERROR) {
469  return SDL_SetError("Failed to update texture");
470  }
471  return 0;
472 }
473 
474 static int
475 GLES_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
476  const SDL_Rect * rect, void **pixels, int *pitch)
477 {
478  GLES_TextureData *data = (GLES_TextureData *) texture->driverdata;
479 
480  *pixels =
481  (void *) ((Uint8 *) data->pixels + rect->y * data->pitch +
482  rect->x * SDL_BYTESPERPIXEL(texture->format));
483  *pitch = data->pitch;
484  return 0;
485 }
486 
487 static void
488 GLES_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
489 {
490  GLES_TextureData *data = (GLES_TextureData *) texture->driverdata;
491  SDL_Rect rect;
492 
493  /* We do whole texture updates, at least for now */
494  rect.x = 0;
495  rect.y = 0;
496  rect.w = texture->w;
497  rect.h = texture->h;
498  GLES_UpdateTexture(renderer, texture, &rect, data->pixels, data->pitch);
499 }
500 
501 static int
502 GLES_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture)
503 {
504  GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
505  GLES_TextureData *texturedata = NULL;
506  GLenum status;
507 
508  if (!data->GL_OES_framebuffer_object_supported) {
509  return SDL_SetError("Can't enable render target support in this renderer");
510  }
511 
512  data->drawstate.viewport_dirty = SDL_TRUE;
513 
514  if (texture == NULL) {
515  data->glBindFramebufferOES(GL_FRAMEBUFFER_OES, data->window_framebuffer);
516  return 0;
517  }
518 
519  texturedata = (GLES_TextureData *) texture->driverdata;
520  data->glBindFramebufferOES(GL_FRAMEBUFFER_OES, texturedata->fbo->FBO);
521  /* TODO: check if texture pixel format allows this operation */
522  data->glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, texturedata->type, texturedata->texture, 0);
523  /* Check FBO status */
524  status = data->glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES);
525  if (status != GL_FRAMEBUFFER_COMPLETE_OES) {
526  return SDL_SetError("glFramebufferTexture2DOES() failed");
527  }
528  return 0;
529 }
530 
531 
532 static int
533 GLES_QueueSetViewport(SDL_Renderer * renderer, SDL_RenderCommand *cmd)
534 {
535  return 0; /* nothing to do in this backend. */
536 }
537 
538 static int
539 GLES_QueueDrawPoints(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FPoint * points, int count)
540 {
541  GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, count * 2 * sizeof (GLfloat), 0, &cmd->data.draw.first);
542  int i;
543 
544  if (!verts) {
545  return -1;
546  }
547 
548  cmd->data.draw.count = count;
549  for (i = 0; i < count; i++) {
550  *(verts++) = 0.5f + points[i].x;
551  *(verts++) = 0.5f + points[i].y;
552  }
553 
554  return 0;
555 }
556 
557 static int
558 GLES_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FRect * rects, int count)
559 {
560  GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, count * 8 * sizeof (GLfloat), 0, &cmd->data.draw.first);
561  int i;
562 
563  if (!verts) {
564  return -1;
565  }
566 
567  cmd->data.draw.count = count;
568 
569  for (i = 0; i < count; i++) {
570  const SDL_FRect *rect = &rects[i];
571  const GLfloat minx = rect->x;
572  const GLfloat maxx = rect->x + rect->w;
573  const GLfloat miny = rect->y;
574  const GLfloat maxy = rect->y + rect->h;
575  *(verts++) = minx;
576  *(verts++) = miny;
577  *(verts++) = maxx;
578  *(verts++) = miny;
579  *(verts++) = minx;
580  *(verts++) = maxy;
581  *(verts++) = maxx;
582  *(verts++) = maxy;
583  }
584 
585  return 0;
586 }
587 
588 static int
589 GLES_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
590  const SDL_Rect * srcrect, const SDL_FRect * dstrect)
591 {
592  GLES_TextureData *texturedata = (GLES_TextureData *) texture->driverdata;
593  GLfloat minx, miny, maxx, maxy;
594  GLfloat minu, maxu, minv, maxv;
595  GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, 16 * sizeof (GLfloat), 0, &cmd->data.draw.first);
596 
597  if (!verts) {
598  return -1;
599  }
600 
601  cmd->data.draw.count = 1;
602 
603  minx = dstrect->x;
604  miny = dstrect->y;
605  maxx = dstrect->x + dstrect->w;
606  maxy = dstrect->y + dstrect->h;
607 
608  minu = (GLfloat) srcrect->x / texture->w;
609  minu *= texturedata->texw;
610  maxu = (GLfloat) (srcrect->x + srcrect->w) / texture->w;
611  maxu *= texturedata->texw;
612  minv = (GLfloat) srcrect->y / texture->h;
613  minv *= texturedata->texh;
614  maxv = (GLfloat) (srcrect->y + srcrect->h) / texture->h;
615  maxv *= texturedata->texh;
616 
617  *(verts++) = minx;
618  *(verts++) = miny;
619  *(verts++) = maxx;
620  *(verts++) = miny;
621  *(verts++) = minx;
622  *(verts++) = maxy;
623  *(verts++) = maxx;
624  *(verts++) = maxy;
625 
626  *(verts++) = minu;
627  *(verts++) = minv;
628  *(verts++) = maxu;
629  *(verts++) = minv;
630  *(verts++) = minu;
631  *(verts++) = maxv;
632  *(verts++) = maxu;
633  *(verts++) = maxv;
634 
635  return 0;
636 }
637 
638 static int
639 GLES_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
640  const SDL_Rect * srcquad, const SDL_FRect * dstrect,
641  const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
642 {
643  GLES_TextureData *texturedata = (GLES_TextureData *) texture->driverdata;
644  GLfloat minx, miny, maxx, maxy;
645  GLfloat centerx, centery;
646  GLfloat minu, maxu, minv, maxv;
647  GLfloat *verts = (GLfloat *) SDL_AllocateRenderVertices(renderer, 19 * sizeof (GLfloat), 0, &cmd->data.draw.first);
648 
649  if (!verts) {
650  return -1;
651  }
652 
653  centerx = center->x;
654  centery = center->y;
655 
656  if (flip & SDL_FLIP_HORIZONTAL) {
657  minx = dstrect->w - centerx;
658  maxx = -centerx;
659  }
660  else {
661  minx = -centerx;
662  maxx = dstrect->w - centerx;
663  }
664 
665  if (flip & SDL_FLIP_VERTICAL) {
666  miny = dstrect->h - centery;
667  maxy = -centery;
668  }
669  else {
670  miny = -centery;
671  maxy = dstrect->h - centery;
672  }
673 
674  minu = (GLfloat) srcquad->x / texture->w;
675  minu *= texturedata->texw;
676  maxu = (GLfloat) (srcquad->x + srcquad->w) / texture->w;
677  maxu *= texturedata->texw;
678  minv = (GLfloat) srcquad->y / texture->h;
679  minv *= texturedata->texh;
680  maxv = (GLfloat) (srcquad->y + srcquad->h) / texture->h;
681  maxv *= texturedata->texh;
682 
683  cmd->data.draw.count = 1;
684 
685  *(verts++) = minx;
686  *(verts++) = miny;
687  *(verts++) = maxx;
688  *(verts++) = miny;
689  *(verts++) = minx;
690  *(verts++) = maxy;
691  *(verts++) = maxx;
692  *(verts++) = maxy;
693 
694  *(verts++) = minu;
695  *(verts++) = minv;
696  *(verts++) = maxu;
697  *(verts++) = minv;
698  *(verts++) = minu;
699  *(verts++) = maxv;
700  *(verts++) = maxu;
701  *(verts++) = maxv;
702 
703  *(verts++) = (GLfloat) dstrect->x + centerx;
704  *(verts++) = (GLfloat) dstrect->y + centery;
705  *(verts++) = (GLfloat) angle;
706 
707  return 0;
708 }
709 
710 static void
711 SetDrawState(GLES_RenderData *data, const SDL_RenderCommand *cmd)
712 {
713  const SDL_BlendMode blend = cmd->data.draw.blend;
714  const Uint8 r = cmd->data.draw.r;
715  const Uint8 g = cmd->data.draw.g;
716  const Uint8 b = cmd->data.draw.b;
717  const Uint8 a = cmd->data.draw.a;
718  const Uint32 color = ((a << 24) | (r << 16) | (g << 8) | b);
719 
720  if (color != data->drawstate.color) {
721  const GLfloat fr = ((GLfloat) r) * inv255f;
722  const GLfloat fg = ((GLfloat) g) * inv255f;
723  const GLfloat fb = ((GLfloat) b) * inv255f;
724  const GLfloat fa = ((GLfloat) a) * inv255f;
725  data->glColor4f(fr, fg, fb, fa);
726  data->drawstate.color = color;
727  }
728 
729  if (data->drawstate.viewport_dirty) {
730  const SDL_Rect *viewport = &data->drawstate.viewport;
731  const SDL_bool istarget = (data->drawstate.target != NULL);
732  data->glMatrixMode(GL_PROJECTION);
733  data->glLoadIdentity();
734  data->glViewport(viewport->x,
735  istarget ? viewport->y : (data->drawstate.drawableh - viewport->y - viewport->h),
736  viewport->w, viewport->h);
737  if (viewport->w && viewport->h) {
738  data->glOrthof((GLfloat) 0, (GLfloat) viewport->w,
739  (GLfloat) (istarget ? 0 : viewport->h),
740  (GLfloat) (istarget ? viewport->h : 0),
741  0.0, 1.0);
742  }
743  data->glMatrixMode(GL_MODELVIEW);
744  data->drawstate.viewport_dirty = SDL_FALSE;
745  }
746 
747  if (data->drawstate.cliprect_enabled_dirty) {
748  if (data->drawstate.cliprect_enabled) {
749  data->glEnable(GL_SCISSOR_TEST);
750  } else {
751  data->glDisable(GL_SCISSOR_TEST);
752  }
753  data->drawstate.cliprect_enabled_dirty = SDL_FALSE;
754  }
755 
756  if (data->drawstate.cliprect_enabled && data->drawstate.cliprect_dirty) {
757  const SDL_Rect *viewport = &data->drawstate.viewport;
758  const SDL_Rect *rect = &data->drawstate.cliprect;
759  const SDL_bool istarget = (data->drawstate.target != NULL);
760  data->glScissor(viewport->x + rect->x,
761  istarget ? viewport->y + rect->y : data->drawstate.drawableh - viewport->y - rect->y - rect->h,
762  rect->w, rect->h);
763  data->drawstate.cliprect_dirty = SDL_FALSE;
764  }
765 
766  if (blend != data->drawstate.blend) {
767  if (blend == SDL_BLENDMODE_NONE) {
768  data->glDisable(GL_BLEND);
769  } else {
770  data->glEnable(GL_BLEND);
771  if (data->GL_OES_blend_func_separate_supported) {
772  data->glBlendFuncSeparateOES(GetBlendFunc(SDL_GetBlendModeSrcColorFactor(blend)),
773  GetBlendFunc(SDL_GetBlendModeDstColorFactor(blend)),
774  GetBlendFunc(SDL_GetBlendModeSrcAlphaFactor(blend)),
775  GetBlendFunc(SDL_GetBlendModeDstAlphaFactor(blend)));
776  } else {
777  data->glBlendFunc(GetBlendFunc(SDL_GetBlendModeSrcColorFactor(blend)),
778  GetBlendFunc(SDL_GetBlendModeDstColorFactor(blend)));
779  }
780  if (data->GL_OES_blend_equation_separate_supported) {
781  data->glBlendEquationSeparateOES(GetBlendEquation(SDL_GetBlendModeColorOperation(blend)),
782  GetBlendEquation(SDL_GetBlendModeAlphaOperation(blend)));
783  } else if (data->GL_OES_blend_subtract_supported) {
784  data->glBlendEquationOES(GetBlendEquation(SDL_GetBlendModeColorOperation(blend)));
785  }
786  }
787  data->drawstate.blend = blend;
788  }
789 
790  if ((cmd->data.draw.texture != NULL) != data->drawstate.texturing) {
791  if (cmd->data.draw.texture == NULL) {
792  data->glDisable(GL_TEXTURE_2D);
793  data->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
794  data->drawstate.texturing = SDL_FALSE;
795  } else {
796  data->glEnable(GL_TEXTURE_2D);
797  data->glEnableClientState(GL_TEXTURE_COORD_ARRAY);
798  data->drawstate.texturing = SDL_TRUE;
799  }
800  }
801 }
802 
803 static void
804 SetCopyState(GLES_RenderData *data, const SDL_RenderCommand *cmd)
805 {
806  SDL_Texture *texture = cmd->data.draw.texture;
807  SetDrawState(data, cmd);
808 
809  if (texture != data->drawstate.texture) {
810  GLES_TextureData *texturedata = (GLES_TextureData *) texture->driverdata;
811  data->glBindTexture(GL_TEXTURE_2D, texturedata->texture);
812  data->drawstate.texture = texture;
813  }
814 }
815 
816 static int
817 GLES_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
818 {
819  GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
820  size_t i;
821 
822  if (GLES_ActivateRenderer(renderer) < 0) {
823  return -1;
824  }
825 
826  data->drawstate.target = renderer->target;
827 
828  if (!renderer->target) {
829  SDL_GL_GetDrawableSize(renderer->window, &data->drawstate.drawablew, &data->drawstate.drawableh);
830  }
831 
832  while (cmd) {
833  switch (cmd->command) {
835  break; /* not used in this render backend. */
836  }
837 
839  SDL_Rect *viewport = &data->drawstate.viewport;
840  if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof (SDL_Rect)) != 0) {
841  SDL_memcpy(viewport, &cmd->data.viewport.rect, sizeof (SDL_Rect));
842  data->drawstate.viewport_dirty = SDL_TRUE;
843  }
844  break;
845  }
846 
848  const SDL_Rect *rect = &cmd->data.cliprect.rect;
849  if (data->drawstate.cliprect_enabled != cmd->data.cliprect.enabled) {
850  data->drawstate.cliprect_enabled = cmd->data.cliprect.enabled;
851  data->drawstate.cliprect_enabled_dirty = SDL_TRUE;
852  }
853  if (SDL_memcmp(&data->drawstate.cliprect, rect, sizeof (SDL_Rect)) != 0) {
854  SDL_memcpy(&data->drawstate.cliprect, rect, sizeof (SDL_Rect));
855  data->drawstate.cliprect_dirty = SDL_TRUE;
856  }
857  break;
858  }
859 
860  case SDL_RENDERCMD_CLEAR: {
861  const Uint8 r = cmd->data.color.r;
862  const Uint8 g = cmd->data.color.g;
863  const Uint8 b = cmd->data.color.b;
864  const Uint8 a = cmd->data.color.a;
865  const Uint32 color = ((a << 24) | (r << 16) | (g << 8) | b);
866  if (color != data->drawstate.clear_color) {
867  const GLfloat fr = ((GLfloat) r) * inv255f;
868  const GLfloat fg = ((GLfloat) g) * inv255f;
869  const GLfloat fb = ((GLfloat) b) * inv255f;
870  const GLfloat fa = ((GLfloat) a) * inv255f;
871  data->glClearColor(fr, fg, fb, fa);
872  data->drawstate.clear_color = color;
873  }
874 
875  if (data->drawstate.cliprect_enabled) {
876  data->glDisable(GL_SCISSOR_TEST);
877  data->drawstate.cliprect_enabled_dirty = SDL_TRUE;
878  }
879 
880  data->glClear(GL_COLOR_BUFFER_BIT);
881 
882  break;
883  }
884 
886  const size_t count = cmd->data.draw.count;
887  const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
888  SetDrawState(data, cmd);
889  data->glVertexPointer(2, GL_FLOAT, 0, verts);
890  data->glDrawArrays(GL_POINTS, 0, (GLsizei) count);
891  break;
892  }
893 
895  const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
896  const size_t count = cmd->data.draw.count;
897  SetDrawState(data, cmd);
898  data->glVertexPointer(2, GL_FLOAT, 0, verts);
899  if (count > 2 && (verts[0] == verts[(count-1)*2]) && (verts[1] == verts[(count*2)-1])) {
900  /* GL_LINE_LOOP takes care of the final segment */
901  data->glDrawArrays(GL_LINE_LOOP, 0, (GLsizei) (count - 1));
902  } else {
903  data->glDrawArrays(GL_LINE_STRIP, 0, (GLsizei) count);
904  /* We need to close the endpoint of the line */
905  data->glDrawArrays(GL_POINTS, (GLsizei) (count - 1), 1);
906  }
907  break;
908  }
909 
911  const size_t count = cmd->data.draw.count;
912  const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
913  GLsizei offset = 0;
914  SetDrawState(data, cmd);
915  data->glVertexPointer(2, GL_FLOAT, 0, verts);
916  for (i = 0; i < count; ++i, offset += 4) {
917  data->glDrawArrays(GL_TRIANGLE_STRIP, offset, 4);
918  }
919  break;
920  }
921 
922  case SDL_RENDERCMD_COPY: {
923  const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
924  SetCopyState(data, cmd);
925  data->glVertexPointer(2, GL_FLOAT, 0, verts);
926  data->glTexCoordPointer(2, GL_FLOAT, 0, verts + 8);
927  data->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
928  break;
929  }
930 
931  case SDL_RENDERCMD_COPY_EX: {
932  const GLfloat *verts = (GLfloat *) (((Uint8 *) vertices) + cmd->data.draw.first);
933  const GLfloat translatex = verts[16];
934  const GLfloat translatey = verts[17];
935  const GLfloat angle = verts[18];
936  SetCopyState(data, cmd);
937  data->glVertexPointer(2, GL_FLOAT, 0, verts);
938  data->glTexCoordPointer(2, GL_FLOAT, 0, verts + 8);
939 
940  /* Translate to flip, rotate, translate to position */
941  data->glPushMatrix();
942  data->glTranslatef(translatex, translatey, 0.0f);
943  data->glRotatef(angle, 0.0, 0.0, 1.0);
944  data->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
945  data->glPopMatrix();
946  break;
947  }
948 
949  case SDL_RENDERCMD_NO_OP:
950  break;
951  }
952 
953  cmd = cmd->next;
954  }
955 
956  return 0;
957 }
958 
959 static int
960 GLES_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
961  Uint32 pixel_format, void * pixels, int pitch)
962 {
963  GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
965  void *temp_pixels;
966  int temp_pitch;
967  Uint8 *src, *dst, *tmp;
968  int w, h, length, rows;
969  int status;
970 
971  GLES_ActivateRenderer(renderer);
972 
973  temp_pitch = rect->w * SDL_BYTESPERPIXEL(temp_format);
974  temp_pixels = SDL_malloc(rect->h * temp_pitch);
975  if (!temp_pixels) {
976  return SDL_OutOfMemory();
977  }
978 
980 
981  data->glPixelStorei(GL_PACK_ALIGNMENT, 1);
982 
983  data->glReadPixels(rect->x, renderer->target ? rect->y : (h-rect->y)-rect->h,
984  rect->w, rect->h, GL_RGBA, GL_UNSIGNED_BYTE, temp_pixels);
985 
986  /* Flip the rows to be top-down if necessary */
987  if (!renderer->target) {
988  SDL_bool isstack;
989  length = rect->w * SDL_BYTESPERPIXEL(temp_format);
990  src = (Uint8*)temp_pixels + (rect->h-1)*temp_pitch;
991  dst = (Uint8*)temp_pixels;
992  tmp = SDL_small_alloc(Uint8, length, &isstack);
993  rows = rect->h / 2;
994  while (rows--) {
995  SDL_memcpy(tmp, dst, length);
997  SDL_memcpy(src, tmp, length);
998  dst += temp_pitch;
999  src -= temp_pitch;
1000  }
1001  SDL_small_free(tmp, isstack);
1002  }
1003 
1004  status = SDL_ConvertPixels(rect->w, rect->h,
1005  temp_format, temp_pixels, temp_pitch,
1006  pixel_format, pixels, pitch);
1007  SDL_free(temp_pixels);
1008 
1009  return status;
1010 }
1011 
1012 static void
1013 GLES_RenderPresent(SDL_Renderer * renderer)
1014 {
1015  GLES_ActivateRenderer(renderer);
1016 
1018 }
1019 
1020 static void
1021 GLES_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
1022 {
1023  GLES_RenderData *renderdata = (GLES_RenderData *) renderer->driverdata;
1024 
1025  GLES_TextureData *data = (GLES_TextureData *) texture->driverdata;
1026 
1027  GLES_ActivateRenderer(renderer);
1028 
1029  if (renderdata->drawstate.texture == texture) {
1030  renderdata->drawstate.texture = NULL;
1031  }
1032  if (renderdata->drawstate.target == texture) {
1033  renderdata->drawstate.target = NULL;
1034  }
1035 
1036  if (!data) {
1037  return;
1038  }
1039  if (data->texture) {
1040  renderdata->glDeleteTextures(1, &data->texture);
1041  }
1042  SDL_free(data->pixels);
1043  SDL_free(data);
1044  texture->driverdata = NULL;
1045 }
1046 
1047 static void
1048 GLES_DestroyRenderer(SDL_Renderer * renderer)
1049 {
1050  GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
1051 
1052  if (data) {
1053  if (data->context) {
1054  while (data->framebuffers) {
1055  GLES_FBOList *nextnode = data->framebuffers->next;
1056  data->glDeleteFramebuffersOES(1, &data->framebuffers->FBO);
1057  SDL_free(data->framebuffers);
1058  data->framebuffers = nextnode;
1059  }
1060  SDL_GL_DeleteContext(data->context);
1061  }
1062  SDL_free(data);
1063  }
1064  SDL_free(renderer);
1065 }
1066 
1067 static int GLES_BindTexture (SDL_Renderer * renderer, SDL_Texture *texture, float *texw, float *texh)
1068 {
1069  GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
1070  GLES_TextureData *texturedata = (GLES_TextureData *) texture->driverdata;
1071  GLES_ActivateRenderer(renderer);
1072 
1073  data->glEnable(GL_TEXTURE_2D);
1074  data->glBindTexture(texturedata->type, texturedata->texture);
1075 
1076  data->drawstate.texture = texture;
1077  data->drawstate.texturing = SDL_TRUE;
1078 
1079  if (texw) {
1080  *texw = (float)texturedata->texw;
1081  }
1082  if (texh) {
1083  *texh = (float)texturedata->texh;
1084  }
1085 
1086  return 0;
1087 }
1088 
1089 static int GLES_UnbindTexture (SDL_Renderer * renderer, SDL_Texture *texture)
1090 {
1091  GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
1092  GLES_TextureData *texturedata = (GLES_TextureData *) texture->driverdata;
1093  GLES_ActivateRenderer(renderer);
1094  data->glDisable(texturedata->type);
1095 
1096  data->drawstate.texture = NULL;
1097  data->drawstate.texturing = SDL_FALSE;
1098 
1099  return 0;
1100 }
1101 
1102 static SDL_Renderer *
1103 GLES_CreateRenderer(SDL_Window * window, Uint32 flags)
1104 {
1106  GLES_RenderData *data;
1107  GLint value;
1108  Uint32 window_flags;
1109  int profile_mask = 0, major = 0, minor = 0;
1110  SDL_bool changed_window = SDL_FALSE;
1111 
1115 
1116  window_flags = SDL_GetWindowFlags(window);
1117  if (!(window_flags & SDL_WINDOW_OPENGL) ||
1118  profile_mask != SDL_GL_CONTEXT_PROFILE_ES || major != RENDERER_CONTEXT_MAJOR || minor != RENDERER_CONTEXT_MINOR) {
1119 
1120  changed_window = SDL_TRUE;
1122  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, RENDERER_CONTEXT_MAJOR);
1123  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, RENDERER_CONTEXT_MINOR);
1124 
1125  if (SDL_RecreateWindow(window, window_flags | SDL_WINDOW_OPENGL) < 0) {
1126  goto error;
1127  }
1128  }
1129 
1130  renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
1131  if (!renderer) {
1132  SDL_OutOfMemory();
1133  goto error;
1134  }
1135 
1136  data = (GLES_RenderData *) SDL_calloc(1, sizeof(*data));
1137  if (!data) {
1138  GLES_DestroyRenderer(renderer);
1139  SDL_OutOfMemory();
1140  goto error;
1141  }
1142 
1143  renderer->WindowEvent = GLES_WindowEvent;
1144  renderer->GetOutputSize = GLES_GetOutputSize;
1145  renderer->SupportsBlendMode = GLES_SupportsBlendMode;
1146  renderer->CreateTexture = GLES_CreateTexture;
1147  renderer->UpdateTexture = GLES_UpdateTexture;
1148  renderer->LockTexture = GLES_LockTexture;
1149  renderer->UnlockTexture = GLES_UnlockTexture;
1150  renderer->SetRenderTarget = GLES_SetRenderTarget;
1151  renderer->QueueSetViewport = GLES_QueueSetViewport;
1152  renderer->QueueSetDrawColor = GLES_QueueSetViewport; /* SetViewport and SetDrawColor are (currently) no-ops. */
1153  renderer->QueueDrawPoints = GLES_QueueDrawPoints;
1154  renderer->QueueDrawLines = GLES_QueueDrawPoints; /* lines and points queue vertices the same way. */
1155  renderer->QueueFillRects = GLES_QueueFillRects;
1156  renderer->QueueCopy = GLES_QueueCopy;
1157  renderer->QueueCopyEx = GLES_QueueCopyEx;
1158  renderer->RunCommandQueue = GLES_RunCommandQueue;
1159  renderer->RenderReadPixels = GLES_RenderReadPixels;
1160  renderer->RenderPresent = GLES_RenderPresent;
1161  renderer->DestroyTexture = GLES_DestroyTexture;
1162  renderer->DestroyRenderer = GLES_DestroyRenderer;
1163  renderer->GL_BindTexture = GLES_BindTexture;
1164  renderer->GL_UnbindTexture = GLES_UnbindTexture;
1168  renderer->window = window;
1169 
1170  data->context = SDL_GL_CreateContext(window);
1171  if (!data->context) {
1172  GLES_DestroyRenderer(renderer);
1173  goto error;
1174  }
1175  if (SDL_GL_MakeCurrent(window, data->context) < 0) {
1176  GLES_DestroyRenderer(renderer);
1177  goto error;
1178  }
1179 
1180  if (GLES_LoadFunctions(data) < 0) {
1181  GLES_DestroyRenderer(renderer);
1182  goto error;
1183  }
1184 
1187  } else {
1189  }
1190  if (SDL_GL_GetSwapInterval() > 0) {
1192  }
1193 
1194  value = 0;
1195  data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
1197  value = 0;
1198  data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
1200 
1201  /* Android does not report GL_OES_framebuffer_object but the functionality seems to be there anyway */
1202  if (SDL_GL_ExtensionSupported("GL_OES_framebuffer_object") || data->glGenFramebuffersOES) {
1203  data->GL_OES_framebuffer_object_supported = SDL_TRUE;
1205 
1206  value = 0;
1207  data->glGetIntegerv(GL_FRAMEBUFFER_BINDING_OES, &value);
1208  data->window_framebuffer = (GLuint)value;
1209  }
1210  data->framebuffers = NULL;
1211 
1212  if (SDL_GL_ExtensionSupported("GL_OES_blend_func_separate")) {
1213  data->GL_OES_blend_func_separate_supported = SDL_TRUE;
1214  }
1215  if (SDL_GL_ExtensionSupported("GL_OES_blend_equation_separate")) {
1216  data->GL_OES_blend_equation_separate_supported = SDL_TRUE;
1217  }
1218  if (SDL_GL_ExtensionSupported("GL_OES_blend_subtract")) {
1219  data->GL_OES_blend_subtract_supported = SDL_TRUE;
1220  }
1221 
1222  /* Set up parameters for rendering */
1223  data->glDisable(GL_DEPTH_TEST);
1224  data->glDisable(GL_CULL_FACE);
1225 
1226  data->glMatrixMode(GL_MODELVIEW);
1227  data->glLoadIdentity();
1228 
1229  data->glEnableClientState(GL_VERTEX_ARRAY);
1230  data->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1231 
1232  data->glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
1233 
1234  data->drawstate.blend = SDL_BLENDMODE_INVALID;
1235  data->drawstate.color = 0xFFFFFFFF;
1236  data->drawstate.clear_color = 0xFFFFFFFF;
1237 
1238  return renderer;
1239 
1240 error:
1241  if (changed_window) {
1242  /* Uh oh, better try to put it back... */
1246  SDL_RecreateWindow(window, window_flags);
1247  }
1248  return NULL;
1249 }
1250 
1252  GLES_CreateRenderer,
1253  {
1254  "opengles",
1256  1,
1258  0,
1259  0
1260  }
1261 };
1262 
1263 #endif /* SDL_VIDEO_RENDER_OGL_ES && !SDL_RENDER_DISABLED */
1264 
1265 /* vi: set ts=4 sw=4 expandtab: */
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:4558
Uint32
uint32_t Uint32
Definition: SDL_stdinc.h:203
GL_ONE
#define GL_ONE
Definition: SDL_opengl.h:401
SDL_Renderer::GL_UnbindTexture
int(* GL_UnbindTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:164
SDL_BLENDOPERATION_SUBTRACT
@ SDL_BLENDOPERATION_SUBTRACT
Definition: SDL_blendmode.h:65
GL_POINTS
#define GL_POINTS
Definition: SDL_opengl.h:216
SDL_small_free
#define SDL_small_free(ptr, isstack)
Definition: SDL_internal.h:40
offset
GLintptr offset
Definition: SDL_opengl_glext.h:538
target
GLenum target
Definition: SDL_opengl_glext.h:1551
blendMode
static SDL_BlendMode blendMode
Definition: testdraw2.c:34
SDL_BLENDOPERATION_ADD
@ SDL_BLENDOPERATION_ADD
Definition: SDL_blendmode.h:64
SDL_RecreateWindow
int SDL_RecreateWindow(SDL_Window *window, Uint32 flags)
Definition: SDL_video.c:1614
SDL_BLENDFACTOR_SRC_ALPHA
@ SDL_BLENDFACTOR_SRC_ALPHA
Definition: SDL_blendmode.h:81
SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA
@ SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA
Definition: SDL_blendmode.h:82
GL_TEXTURE_2D
#define GL_TEXTURE_2D
Definition: SDL_opengl.h:671
SDL_BLENDOPERATION_REV_SUBTRACT
@ SDL_BLENDOPERATION_REV_SUBTRACT
Definition: SDL_blendmode.h:66
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:140
SDL_AllocateRenderVertices
void * SDL_AllocateRenderVertices(SDL_Renderer *renderer, const size_t numbytes, const size_t alignment, size_t *offset)
Definition: SDL_render.c:284
SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR
@ SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR
Definition: SDL_blendmode.h:84
SDL_RenderCommand::cliprect
struct SDL_RenderCommand::@30::@32 cliprect
SDL_Renderer::RunCommandQueue
int(* RunCommandQueue)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
Definition: SDL_sysrender.h:143
SDL_FPoint::x
float x
Definition: SDL_rect.h:62
SDL_FRect::h
float h
Definition: SDL_rect.h:92
NULL
#define NULL
Definition: begin_code.h:167
SDL_ScaleModeNearest
@ SDL_ScaleModeNearest
Definition: SDL_sysrender.h:37
GL_NEAREST
#define GL_NEAREST
Definition: SDL_opengl.h:704
b
GLboolean GLboolean GLboolean b
Definition: SDL_opengl_glext.h:1109
SDL_Renderer::SetRenderTarget
int(* SetRenderTarget)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:155
width
GLint GLint GLsizei width
Definition: SDL_opengl.h:1572
GL_STACK_UNDERFLOW
#define GL_STACK_UNDERFLOW
Definition: SDL_opengl.h:724
g
GLboolean GLboolean g
Definition: SDL_opengl_glext.h:1109
GL_MAX_TEXTURE_SIZE
#define GL_MAX_TEXTURE_SIZE
Definition: SDL_opengl.h:536
SDL_GL_CreateContext
#define SDL_GL_CreateContext
Definition: SDL_dynapi_overrides.h:559
count
GLuint GLuint GLsizei count
Definition: SDL_opengl.h:1571
SDL_GetWindowFlags
#define SDL_GetWindowFlags
Definition: SDL_dynapi_overrides.h:518
SDL_RenderCommand::next
struct SDL_RenderCommand * next
Definition: SDL_sysrender.h:110
SDL_BlendOperation
SDL_BlendOperation
The blend operation used when combining source and destination pixel components.
Definition: SDL_blendmode.h:62
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:101
viewport
SDL_Rect viewport
Definition: testviewport.c:28
z
GLdouble GLdouble z
Definition: SDL_opengl_glext.h:404
SDL_RenderDriver
Definition: SDL_sysrender.h:236
SDL_FRect::x
float x
Definition: SDL_rect.h:89
GL_COLOR_BUFFER_BIT
#define GL_COLOR_BUFFER_BIT
Definition: SDL_opengl.h:742
SDL_Renderer::WindowEvent
void(* WindowEvent)(SDL_Renderer *renderer, const SDL_WindowEvent *event)
Definition: SDL_sysrender.h:126
input
GLenum GLenum GLenum input
Definition: SDL_opengl_glext.h:9374
GL_UNPACK_ALIGNMENT
#define GL_UNPACK_ALIGNMENT
Definition: SDL_opengl.h:658
GLES_RenderDriver
SDL_RenderDriver GLES_RenderDriver
SDL_FPoint::y
float y
Definition: SDL_rect.h:63
a
GLboolean GLboolean GLboolean GLboolean a
Definition: SDL_opengl_glext.h:1109
SDL_GL_CONTEXT_MINOR_VERSION
@ SDL_GL_CONTEXT_MINOR_VERSION
Definition: SDL_video.h:218
h
GLfloat GLfloat GLfloat GLfloat h
Definition: SDL_opengl_glext.h:1946
SDL_opengles.h
SDL_RendererFlip
SDL_RendererFlip
Flip constants for SDL_RenderCopyEx.
Definition: SDL_render.h:111
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:669
SDL_Rect::x
int x
Definition: SDL_rect.h:79
SDL_RENDERCMD_COPY
@ SDL_RENDERCMD_COPY
Definition: SDL_sysrender.h:82
GL_BLEND
#define GL_BLEND
Definition: SDL_opengl.h:397
SDL_RENDERCMD_SETCLIPRECT
@ SDL_RENDERCMD_SETCLIPRECT
Definition: SDL_sysrender.h:76
result
GLuint64EXT * result
Definition: SDL_opengl_glext.h:9432
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
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:73
dst
GLenum GLenum dst
Definition: SDL_opengl_glext.h:1737
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
GL_INVALID_OPERATION
#define GL_INVALID_OPERATION
Definition: SDL_opengl.h:722
SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR
@ SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR
Definition: SDL_blendmode.h:80
SDL_BLENDMODE_NONE
@ SDL_BLENDMODE_NONE
Definition: SDL_blendmode.h:42
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
event
struct _cl_event * event
Definition: SDL_opengl_glext.h:2649
SDL_Renderer
Definition: SDL_sysrender.h:122
SDL_FALSE
@ SDL_FALSE
Definition: SDL_stdinc.h:163
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:131
SDL_FPoint
The structure that defines a point (floating point)
Definition: SDL_rect.h:60
SDL_Renderer::driverdata
void * driverdata
Definition: SDL_sysrender.h:232
SDL_FRect::y
float y
Definition: SDL_rect.h:90
SDL_FRect::w
float w
Definition: SDL_rect.h:91
GL_VERTEX_ARRAY
#define GL_VERTEX_ARRAY
Definition: SDL_opengl.h:228
SDL_FLIP_HORIZONTAL
@ SDL_FLIP_HORIZONTAL
Definition: SDL_render.h:114
x
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
color
GLuint color
Definition: SDL_opengl_glext.h:1148
window
EGLSurface EGLNativeWindowType * window
Definition: eglext.h:1025
GL_LINE_LOOP
#define GL_LINE_LOOP
Definition: SDL_opengl.h:218
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_INLINE
#define SDL_INLINE
Definition: begin_code.h:134
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:1870
height
GLint GLint GLsizei GLsizei height
Definition: SDL_opengl.h:1572
SDL_Renderer::SupportsBlendMode
SDL_bool(* SupportsBlendMode)(SDL_Renderer *renderer, SDL_BlendMode blendMode)
Definition: SDL_sysrender.h:128
SDL_RENDERCMD_SETVIEWPORT
@ SDL_RENDERCMD_SETVIEWPORT
Definition: SDL_sysrender.h:75
SDL_Renderer::QueueDrawLines
int(* QueueDrawLines)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
Definition: SDL_sysrender.h:134
SDL_RENDERER_PRESENTVSYNC
@ SDL_RENDERER_PRESENTVSYNC
Definition: SDL_render.h:69
SDL_RenderCommand::color
struct SDL_RenderCommand::@30::@34 color
SDL_RENDERCMD_DRAW_POINTS
@ SDL_RENDERCMD_DRAW_POINTS
Definition: SDL_sysrender.h:79
SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA
@ SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA
Definition: SDL_blendmode.h:86
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:233
SDL_GL_GetSwapInterval
#define SDL_GL_GetSwapInterval
Definition: SDL_dynapi_overrides.h:565
SDL_BlendFactor
SDL_BlendFactor
The normalized factor used to multiply pixel components.
Definition: SDL_blendmode.h:75
SetDrawState
static void SetDrawState(SDL_Surface *surface, SW_DrawStateCache *drawstate)
Definition: SDL_render_sw.c:584
SDL_GL_SetSwapInterval
#define SDL_GL_SetSwapInterval
Definition: SDL_dynapi_overrides.h:564
SDL_GetBlendModeDstAlphaFactor
SDL_BlendFactor SDL_GetBlendModeDstAlphaFactor(SDL_BlendMode blendMode)
Definition: SDL_render.c:3370
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:163
SDL_RenderCommand::command
SDL_RenderCommandType command
Definition: SDL_sysrender.h:88
SDL_RENDERCMD_NO_OP
@ SDL_RENDERCMD_NO_OP
Definition: SDL_sysrender.h:74
SDL_Renderer::QueueSetViewport
int(* QueueSetViewport)(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
Definition: SDL_sysrender.h:130
GL_TEXTURE_COORD_ARRAY
#define GL_TEXTURE_COORD_ARRAY
Definition: SDL_opengl.h:232
SDL_GL_GetCurrentContext
#define SDL_GL_GetCurrentContext
Definition: SDL_dynapi_overrides.h:562
SDL_BLENDFACTOR_ZERO
@ SDL_BLENDFACTOR_ZERO
Definition: SDL_blendmode.h:77
SDL_WINDOWEVENT_MINIMIZED
@ SDL_WINDOWEVENT_MINIMIZED
Definition: SDL_video.h:159
GL_TEXTURE_WRAP_S
#define GL_TEXTURE_WRAP_S
Definition: SDL_opengl.h:672
SDL_RENDERCMD_DRAW_LINES
@ SDL_RENDERCMD_DRAW_LINES
Definition: SDL_sysrender.h:80
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:127
SDL_RenderCommand::data
union SDL_RenderCommand::@30 data
SDL_BLENDFACTOR_DST_COLOR
@ SDL_BLENDFACTOR_DST_COLOR
Definition: SDL_blendmode.h:83
SDL_OutOfMemory
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_GL_CONTEXT_MAJOR_VERSION
@ SDL_GL_CONTEXT_MAJOR_VERSION
Definition: SDL_video.h:217
SDL_GL_CONTEXT_PROFILE_MASK
@ SDL_GL_CONTEXT_PROFILE_MASK
Definition: SDL_video.h:221
SDL_Renderer::CreateTexture
int(* CreateTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:129
y
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574
SDL_Texture::format
Uint32 format
Definition: SDL_sysrender.h:46
SDL_RENDERCMD_FILL_RECTS
@ SDL_RENDERCMD_FILL_RECTS
Definition: SDL_sysrender.h:81
GL_SCISSOR_TEST
#define GL_SCISSOR_TEST
Definition: SDL_opengl.h:615
SDL_Renderer::DestroyRenderer
void(* DestroyRenderer)(SDL_Renderer *renderer)
Definition: SDL_sysrender.h:161
SDL_Renderer::LockTexture
int(* LockTexture)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
Definition: SDL_sysrender.h:152
SDL_BLENDMODE_INVALID
@ SDL_BLENDMODE_INVALID
Definition: SDL_blendmode.h:53
SDL_calloc
#define SDL_calloc
Definition: SDL_dynapi_overrides.h:375
SDL_GetRendererOutputSize
#define SDL_GetRendererOutputSize
Definition: SDL_dynapi_overrides.h:305
SDL_Renderer::RenderReadPixels
int(* RenderReadPixels)(SDL_Renderer *renderer, const SDL_Rect *rect, Uint32 format, void *pixels, int pitch)
Definition: SDL_sysrender.h:156
SDL_GetBlendModeSrcAlphaFactor
SDL_BlendFactor SDL_GetBlendModeSrcAlphaFactor(SDL_BlendMode blendMode)
Definition: SDL_render.c:3363
SDL_GetBlendModeColorOperation
SDL_BlendOperation SDL_GetBlendModeColorOperation(SDL_BlendMode blendMode)
Definition: SDL_render.c:3356
SDL_RENDERCMD_COPY_EX
@ SDL_RENDERCMD_COPY_EX
Definition: SDL_sysrender.h:83
GL_SRC_COLOR
#define GL_SRC_COLOR
Definition: SDL_opengl.h:402
SDL_GLContext
void * SDL_GLContext
An opaque handle to an OpenGL context.
Definition: SDL_video.h:193
SDL_RenderCommand
Definition: SDL_sysrender.h:86
src
GLenum src
Definition: SDL_opengl_glext.h:1737
renderer
static SDL_Renderer * renderer
Definition: testaudiocapture.c:21
GL_DST_ALPHA
#define GL_DST_ALPHA
Definition: SDL_opengl.h:406
SDL_TRUE
@ SDL_TRUE
Definition: SDL_stdinc.h:164
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:3349
SDL_Renderer::info
SDL_RendererInfo info
Definition: SDL_sysrender.h:170
value
GLsizei const GLfloat * value
Definition: SDL_opengl_glext.h:698
SDL_RENDERER_TARGETTEXTURE
@ SDL_RENDERER_TARGETTEXTURE
Definition: SDL_render.h:71
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:30
SDL_Renderer::RenderPresent
void(* RenderPresent)(SDL_Renderer *renderer)
Definition: SDL_sysrender.h:158
SDL_BYTESPERPIXEL
#define SDL_BYTESPERPIXEL(X)
Definition: SDL_pixels.h:128
SDL_glesfuncs.h
SDL_Rect
A rectangle, with the origin at the upper left (integer).
Definition: SDL_rect.h:77
SDL_RendererInfo::max_texture_width
int max_texture_width
Definition: SDL_render.h:84
SDL_RenderCommand::viewport
struct SDL_RenderCommand::@30::@31 viewport
GL_RGBA
#define GL_RGBA
Definition: SDL_opengl.h:529
SDL_BLENDFACTOR_SRC_COLOR
@ SDL_BLENDFACTOR_SRC_COLOR
Definition: SDL_blendmode.h:79
SDL_Texture
Definition: SDL_sysrender.h:43
SDL_Renderer::QueueFillRects
int(* QueueFillRects)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FRect *rects, int count)
Definition: SDL_sysrender.h:136
SDL_Renderer::UpdateTexture
int(* UpdateTexture)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch)
Definition: SDL_sysrender.h:144
SDL_hints.h
GLsizei
int GLsizei
Definition: SDL_opengl.h:186
SDL_GL_MakeCurrent
#define SDL_GL_MakeCurrent
Definition: SDL_dynapi_overrides.h:560
SDL_TEXTUREACCESS_TARGET
@ SDL_TEXTUREACCESS_TARGET
Definition: SDL_render.h:95
GLenum
unsigned int GLenum
Definition: SDL_opengl.h:176
GL_PACK_ALIGNMENT
#define GL_PACK_ALIGNMENT
Definition: SDL_opengl.h:652
SDL_WindowEvent
Window state change event data (event.window.*)
Definition: SDL_events.h:195
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:87
SDL_RenderCommand::draw
struct SDL_RenderCommand::@30::@33 draw
SDL_RenderDriver::info
SDL_RendererInfo info
Definition: SDL_sysrender.h:241
SDL_ConvertPixels
#define SDL_ConvertPixels
Definition: SDL_dynapi_overrides.h:465
angle
GLfloat angle
Definition: SDL_opengl_glext.h:6097
SDL_BLENDFACTOR_DST_ALPHA
@ SDL_BLENDFACTOR_DST_ALPHA
Definition: SDL_blendmode.h:85
SDL_FLIP_VERTICAL
@ SDL_FLIP_VERTICAL
Definition: SDL_render.h:115
GL_INVALID_VALUE
#define GL_INVALID_VALUE
Definition: SDL_opengl.h:721
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
GL_APIENTRY
#define GL_APIENTRY
Definition: SDL_opengles2_gl2platform.h:27
SDL_Renderer::QueueDrawPoints
int(* QueueDrawPoints)(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
Definition: SDL_sysrender.h:132
SDL_BLENDFACTOR_ONE
@ SDL_BLENDFACTOR_ONE
Definition: SDL_blendmode.h:78
GLuint
unsigned int GLuint
Definition: SDL_opengl.h:185
SDL_GL_SwapWindow
#define SDL_GL_SwapWindow
Definition: SDL_dynapi_overrides.h:566
internalFormat
GLenum internalFormat
Definition: SDL_opengl_glext.h:5063
SDL_malloc
#define SDL_malloc
Definition: SDL_dynapi_overrides.h:374
SDL_RENDERER_ACCELERATED
@ SDL_RENDERER_ACCELERATED
Definition: SDL_render.h:67
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:1175
SDL_RendererInfo::max_texture_height
int max_texture_height
Definition: SDL_render.h:85
SDL_RENDERCMD_SETDRAWCOLOR
@ SDL_RENDERCMD_SETDRAWCOLOR
Definition: SDL_sysrender.h:77
flags
GLbitfield flags
Definition: SDL_opengl_glext.h:1480
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:138
SDL_Renderer::window
SDL_Window * window
Definition: SDL_sysrender.h:173
SDL_TEXTUREACCESS_STREAMING
@ SDL_TEXTUREACCESS_STREAMING
Definition: SDL_render.h:94
SDL_Renderer::target
SDL_Texture * target
Definition: SDL_sysrender.h:206
texture
GLenum GLenum GLuint texture
Definition: SDL_opengl_glext.h:1178
GL_SRC_ALPHA
#define GL_SRC_ALPHA
Definition: SDL_opengl.h:404
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
rects
EGLSurface EGLint * rects
Definition: eglext.h:282
SDL_PIXELFORMAT_ABGR8888
@ SDL_PIXELFORMAT_ABGR8888
Definition: SDL_pixels.h:254
SDL_GetBlendModeAlphaOperation
SDL_BlendOperation SDL_GetBlendModeAlphaOperation(SDL_BlendMode blendMode)
Definition: SDL_render.c:3377
SDL_BlendMode
SDL_BlendMode
The blend mode used in SDL_RenderCopy() and drawing operations.
Definition: SDL_blendmode.h:40
type
GLuint GLuint GLsizei GLenum type
Definition: SDL_opengl.h:1571
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
GL_UNSIGNED_BYTE
#define GL_UNSIGNED_BYTE
Definition: SDL_opengl.h:204
SDL_GL_DeleteContext
#define SDL_GL_DeleteContext
Definition: SDL_dynapi_overrides.h:567
SDL_GetBlendModeSrcColorFactor
SDL_BlendFactor SDL_GetBlendModeSrcColorFactor(SDL_BlendMode blendMode)
Definition: SDL_render.c:3342
GL_TRIANGLE_STRIP
#define GL_TRIANGLE_STRIP
Definition: SDL_opengl.h:221
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:78
GL_FLOAT
#define GL_FLOAT
Definition: SDL_opengl.h:209
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:161
SDL_Renderer::UnlockTexture
void(* UnlockTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:154
SDL_Renderer::DestroyTexture
void(* DestroyTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
Definition: SDL_sysrender.h:159
w
GLubyte GLubyte GLubyte GLubyte w
Definition: SDL_opengl_glext.h:731
SDL_GL_ExtensionSupported
#define SDL_GL_ExtensionSupported
Definition: SDL_dynapi_overrides.h:556
Uint8
uint8_t Uint8
Definition: SDL_stdinc.h:179