This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_render_gl.c
1017 lines (869 loc) · 31.7 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2011 Sam Lantinga
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
24
#if SDL_VIDEO_RENDER_OGL && !SDL_RENDER_DISABLED
25
26
27
#include "SDL_hints.h"
#include "SDL_log.h"
28
#include "SDL_opengl.h"
29
#include "../SDL_sysrender.h"
30
#include "SDL_shaders_gl.h"
31
32
33
34
35
#ifdef __MACOSX__
#include <OpenGL/OpenGL.h>
#endif
36
37
38
/* OpenGL renderer implementation */
39
/* Details on optimizing the texture path on Mac OS X:
40
http://developer.apple.com/library/mac/#documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/opengl_texturedata/opengl_texturedata.html
41
42
*/
43
44
/* Used to re-create the window with OpenGL capability */
extern int SDL_RecreateWindow(SDL_Window * window, Uint32 flags);
45
46
47
static const float inv255f = 1.0f / 255.0f;
48
static SDL_Renderer *GL_CreateRenderer(SDL_Window * window, Uint32 flags);
49
50
static void GL_WindowEvent(SDL_Renderer * renderer,
const SDL_WindowEvent *event);
51
52
53
54
55
static int GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
static int GL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const void *pixels,
int pitch);
static int GL_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
56
const SDL_Rect * rect, void **pixels, int *pitch);
57
static void GL_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture);
58
static int GL_UpdateViewport(SDL_Renderer * renderer);
59
60
61
62
63
64
static int GL_RenderClear(SDL_Renderer * renderer);
static int GL_RenderDrawPoints(SDL_Renderer * renderer,
const SDL_Point * points, int count);
static int GL_RenderDrawLines(SDL_Renderer * renderer,
const SDL_Point * points, int count);
static int GL_RenderFillRects(SDL_Renderer * renderer,
65
const SDL_Rect * rects, int count);
66
static int GL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
67
const SDL_Rect * srcrect, const SDL_Rect * dstrect);
68
static int GL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
69
Uint32 pixel_format, void * pixels, int pitch);
70
71
72
73
74
75
76
77
78
static void GL_RenderPresent(SDL_Renderer * renderer);
static void GL_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture);
static void GL_DestroyRenderer(SDL_Renderer * renderer);
SDL_RenderDriver GL_RenderDriver = {
GL_CreateRenderer,
{
"opengl",
79
(SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC),
80
81
1,
{SDL_PIXELFORMAT_ARGB8888},
82
83
84
85
86
87
88
0,
0}
};
typedef struct
{
SDL_GLContext context;
89
SDL_bool GL_ARB_texture_rectangle_supported;
90
91
92
93
94
95
struct {
GL_Shader shader;
Uint32 color;
int blendMode;
GLenum scaleMode;
} current;
96
97
98
/* OpenGL functions */
#define SDL_PROC(ret,func,params) ret (APIENTRY *func) params;
99
#include "SDL_glfuncs.h"
100
#undef SDL_PROC
101
102
103
void (*glTextureRangeAPPLE) (GLenum target, GLsizei length,
const GLvoid * pointer);
104
105
106
107
/* Multitexture support */
SDL_bool GL_ARB_multitexture_supported;
PFNGLACTIVETEXTUREARBPROC glActiveTextureARB;
108
GLint num_texture_units;
109
110
111
112
/* Shader support */
GL_ShaderContext *shaders;
113
114
115
116
117
} GL_RenderData;
typedef struct
{
GLuint texture;
118
GLenum type;
119
120
GLfloat texw;
GLfloat texh;
121
122
GLenum format;
GLenum formattype;
123
124
void *pixels;
int pitch;
125
int scaleMode;
126
SDL_Rect locked_rect;
127
128
129
130
131
/* YV12 texture support */
SDL_bool yuv;
GLuint utexture;
GLuint vtexture;
132
133
134
} GL_TextureData;
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
static void
GL_SetError(const char *prefix, GLenum result)
{
const char *error;
switch (result) {
case GL_NO_ERROR:
error = "GL_NO_ERROR";
break;
case GL_INVALID_ENUM:
error = "GL_INVALID_ENUM";
break;
case GL_INVALID_VALUE:
error = "GL_INVALID_VALUE";
break;
case GL_INVALID_OPERATION:
error = "GL_INVALID_OPERATION";
break;
case GL_STACK_OVERFLOW:
error = "GL_STACK_OVERFLOW";
break;
case GL_STACK_UNDERFLOW:
error = "GL_STACK_UNDERFLOW";
break;
case GL_OUT_OF_MEMORY:
error = "GL_OUT_OF_MEMORY";
break;
case GL_TABLE_TOO_LARGE:
error = "GL_TABLE_TOO_LARGE";
break;
default:
error = "UNKNOWN";
break;
}
SDL_SetError("%s: %s", prefix, error);
}
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
static int
GL_LoadFunctions(GL_RenderData * data)
{
#ifdef __SDL_NOGETPROCADDR__
#define SDL_PROC(ret,func,params) data->func=func;
#else
#define SDL_PROC(ret,func,params) \
do { \
data->func = SDL_GL_GetProcAddress(#func); \
if ( ! data->func ) { \
SDL_SetError("Couldn't load GL function %s: %s\n", #func, SDL_GetError()); \
return -1; \
} \
} while ( 0 );
#endif /* __SDL_NOGETPROCADDR__ */
188
#include "SDL_glfuncs.h"
189
190
191
192
#undef SDL_PROC
return 0;
}
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
static SDL_GLContext SDL_CurrentContext = NULL;
static int
GL_ActivateRenderer(SDL_Renderer * renderer)
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
if (SDL_CurrentContext != data->context) {
if (SDL_GL_MakeCurrent(renderer->window, data->context) < 0) {
return -1;
}
SDL_CurrentContext = data->context;
GL_UpdateViewport(renderer);
}
return 0;
}
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
/* This is called if we need to invalidate all of the SDL OpenGL state */
static void
GL_ResetState(SDL_Renderer *renderer)
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
if (SDL_CurrentContext == data->context) {
GL_UpdateViewport(renderer);
} else {
GL_ActivateRenderer(renderer);
}
data->current.shader = SHADER_NONE;
data->current.color = 0;
data->current.blendMode = -1;
data->current.scaleMode = 0;
data->glDisable(GL_DEPTH_TEST);
data->glDisable(GL_CULL_FACE);
/* This ended up causing video discrepancies between OpenGL and Direct3D */
/*data->glEnable(GL_LINE_SMOOTH);*/
data->glMatrixMode(GL_MODELVIEW);
data->glLoadIdentity();
}
237
238
239
240
241
SDL_Renderer *
GL_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_Renderer *renderer;
GL_RenderData *data;
242
const char *hint;
243
GLint value;
244
Uint32 window_flags;
245
246
247
248
window_flags = SDL_GetWindowFlags(window);
if (!(window_flags & SDL_WINDOW_OPENGL)) {
if (SDL_RecreateWindow(window, window_flags | SDL_WINDOW_OPENGL) < 0) {
249
250
return NULL;
}
251
252
}
253
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
254
255
256
257
258
if (!renderer) {
SDL_OutOfMemory();
return NULL;
}
259
data = (GL_RenderData *) SDL_calloc(1, sizeof(*data));
260
261
262
263
264
265
if (!data) {
GL_DestroyRenderer(renderer);
SDL_OutOfMemory();
return NULL;
}
266
renderer->WindowEvent = GL_WindowEvent;
267
268
269
270
renderer->CreateTexture = GL_CreateTexture;
renderer->UpdateTexture = GL_UpdateTexture;
renderer->LockTexture = GL_LockTexture;
renderer->UnlockTexture = GL_UnlockTexture;
271
renderer->UpdateViewport = GL_UpdateViewport;
272
273
274
275
renderer->RenderClear = GL_RenderClear;
renderer->RenderDrawPoints = GL_RenderDrawPoints;
renderer->RenderDrawLines = GL_RenderDrawLines;
renderer->RenderFillRects = GL_RenderFillRects;
276
renderer->RenderCopy = GL_RenderCopy;
277
renderer->RenderReadPixels = GL_RenderReadPixels;
278
279
280
281
renderer->RenderPresent = GL_RenderPresent;
renderer->DestroyTexture = GL_DestroyTexture;
renderer->DestroyRenderer = GL_DestroyRenderer;
renderer->info = GL_RenderDriver.info;
282
renderer->info.flags = SDL_RENDERER_ACCELERATED;
283
renderer->driverdata = data;
284
285
data->context = SDL_GL_CreateContext(window);
286
287
288
289
if (!data->context) {
GL_DestroyRenderer(renderer);
return NULL;
}
290
if (SDL_GL_MakeCurrent(window, data->context) < 0) {
291
292
293
GL_DestroyRenderer(renderer);
return NULL;
}
294
295
296
297
298
299
if (GL_LoadFunctions(data) < 0) {
GL_DestroyRenderer(renderer);
return NULL;
}
300
301
302
#ifdef __MACOSX__
/* Enable multi-threaded rendering */
/* Disabled until Ryan finishes his VBO/PBO code...
303
304
CGLEnable(CGLGetCurrentContext(), kCGLCEMPEngine);
*/
305
306
#endif
307
if (flags & SDL_RENDERER_PRESENTVSYNC) {
308
309
310
311
312
SDL_GL_SetSwapInterval(1);
} else {
SDL_GL_SetSwapInterval(0);
}
if (SDL_GL_GetSwapInterval() > 0) {
313
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
314
315
}
316
317
318
319
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_width = value;
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_height = value;
320
321
322
323
324
if (SDL_GL_ExtensionSupported("GL_ARB_texture_rectangle")
|| SDL_GL_ExtensionSupported("GL_EXT_texture_rectangle")) {
data->GL_ARB_texture_rectangle_supported = SDL_TRUE;
}
325
326
327
328
329
if (SDL_GL_ExtensionSupported("GL_APPLE_texture_range")) {
data->glTextureRangeAPPLE =
(void (*)(GLenum, GLsizei, const GLvoid *))
SDL_GL_GetProcAddress("glTextureRangeAPPLE");
}
330
331
332
333
334
335
336
337
338
339
340
/* Check for multitexture support */
if (SDL_GL_ExtensionSupported("GL_ARB_multitexture")) {
data->glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC) SDL_GL_GetProcAddress("glActiveTextureARB");
if (data->glActiveTextureARB) {
data->GL_ARB_multitexture_supported = SDL_TRUE;
data->glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &data->num_texture_units);
}
}
/* Check for shader support */
341
342
343
344
345
346
hint = SDL_GetHint(SDL_HINT_RENDER_OPENGL_SHADERS);
if (!hint || *hint != '0') {
data->shaders = GL_CreateShaderContext();
}
SDL_LogInfo(SDL_LOG_CATEGORY_RENDER, "OpenGL shaders: %s",
data->shaders ? "ENABLED" : "DISABLED");
347
348
349
350
/* We support YV12 textures using 3 textures and a shader */
if (data->shaders && data->num_texture_units >= 3) {
renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_YV12;
351
renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_IYUV;
352
353
}
354
/* Set up parameters for rendering */
355
GL_ResetState(renderer);
356
357
358
359
return renderer;
}
360
361
static void
GL_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
362
363
364
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
365
if (event->event == SDL_WINDOWEVENT_SIZE_CHANGED) {
366
367
368
/* Rebind the context to the window area and update matrices */
SDL_CurrentContext = NULL;
}
369
370
}
371
372
373
374
375
376
377
378
379
380
381
static __inline__ int
power_of_2(int input)
{
int value = 1;
while (value < input) {
value <<= 1;
}
return value;
}
382
383
384
static __inline__ SDL_bool
convert_format(GL_RenderData *renderdata, Uint32 pixel_format,
GLint* internalFormat, GLenum* format, GLenum* type)
385
{
386
switch (pixel_format) {
387
case SDL_PIXELFORMAT_ARGB8888:
388
389
*internalFormat = GL_RGBA8;
*format = GL_BGRA;
390
*type = GL_UNSIGNED_INT_8_8_8_8_REV;
391
break;
392
393
394
395
396
397
case SDL_PIXELFORMAT_YV12:
case SDL_PIXELFORMAT_IYUV:
*internalFormat = GL_LUMINANCE;
*format = GL_LUMINANCE;
*type = GL_UNSIGNED_BYTE;
break;
398
default:
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
return SDL_FALSE;
}
return SDL_TRUE;
}
static int
GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
GL_TextureData *data;
GLint internalFormat;
GLenum format, type;
int texture_w, texture_h;
GLenum result;
414
415
GL_ActivateRenderer(renderer);
416
417
if (!convert_format(renderdata, texture->format, &internalFormat,
&format, &type)) {
418
419
SDL_SetError("Texture format %s not supported by OpenGL",
SDL_GetPixelFormatName(texture->format));
420
421
return -1;
}
422
423
data = (GL_TextureData *) SDL_calloc(1, sizeof(*data));
424
425
426
427
428
if (!data) {
SDL_OutOfMemory();
return -1;
}
429
if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
430
size_t size;
431
data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
432
433
434
435
436
437
438
size = texture->h * data->pitch;
if (texture->format == SDL_PIXELFORMAT_YV12 ||
texture->format == SDL_PIXELFORMAT_IYUV) {
/* Need to add size for the U and V planes */
size += (2 * (texture->h * data->pitch) / 4);
}
data->pixels = SDL_malloc(size);
439
440
441
442
443
444
445
if (!data->pixels) {
SDL_OutOfMemory();
SDL_free(data);
return -1;
}
}
446
447
texture->driverdata = data;
448
449
renderdata->glGetError();
renderdata->glGenTextures(1, &data->texture);
450
451
452
453
if (renderdata->GL_ARB_texture_rectangle_supported) {
data->type = GL_TEXTURE_RECTANGLE_ARB;
texture_w = texture->w;
texture_h = texture->h;
454
455
data->texw = (GLfloat) texture_w;
data->texh = (GLfloat) texture_h;
456
457
458
459
} else {
data->type = GL_TEXTURE_2D;
texture_w = power_of_2(texture->w);
texture_h = power_of_2(texture->h);
460
data->texw = (GLfloat) (texture->w) / texture_w;
461
462
data->texh = (GLfloat) texture->h / texture_h;
}
463
464
465
data->format = format;
data->formattype = type;
466
data->scaleMode = GL_LINEAR;
467
renderdata->glEnable(data->type);
468
renderdata->glBindTexture(data->type, data->texture);
469
470
471
472
renderdata->glTexParameteri(data->type, GL_TEXTURE_WRAP_S,
GL_CLAMP_TO_EDGE);
renderdata->glTexParameteri(data->type, GL_TEXTURE_WRAP_T,
GL_CLAMP_TO_EDGE);
473
#ifdef __MACOSX__
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
#ifndef GL_TEXTURE_STORAGE_HINT_APPLE
#define GL_TEXTURE_STORAGE_HINT_APPLE 0x85BC
#endif
#ifndef STORAGE_CACHED_APPLE
#define STORAGE_CACHED_APPLE 0x85BE
#endif
#ifndef STORAGE_SHARED_APPLE
#define STORAGE_SHARED_APPLE 0x85BF
#endif
if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
renderdata->glTexParameteri(data->type, GL_TEXTURE_STORAGE_HINT_APPLE,
GL_STORAGE_SHARED_APPLE);
} else {
renderdata->glTexParameteri(data->type, GL_TEXTURE_STORAGE_HINT_APPLE,
GL_STORAGE_CACHED_APPLE);
}
490
491
if (texture->access == SDL_TEXTUREACCESS_STREAMING
&& texture->format == SDL_PIXELFORMAT_ARGB8888) {
492
493
494
renderdata->glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
renderdata->glTexImage2D(data->type, 0, internalFormat, texture_w,
texture_h, 0, format, type, data->pixels);
495
496
}
else
497
498
499
500
501
#endif
{
renderdata->glTexImage2D(data->type, 0, internalFormat, texture_w,
texture_h, 0, format, type, NULL);
}
502
renderdata->glDisable(data->type);
503
result = renderdata->glGetError();
504
505
506
507
if (result != GL_NO_ERROR) {
GL_SetError("glTexImage2D()", result);
return -1;
}
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
if (texture->format == SDL_PIXELFORMAT_YV12 ||
texture->format == SDL_PIXELFORMAT_IYUV) {
data->yuv = SDL_TRUE;
renderdata->glGenTextures(1, &data->utexture);
renderdata->glGenTextures(1, &data->vtexture);
renderdata->glEnable(data->type);
renderdata->glBindTexture(data->type, data->utexture);
renderdata->glTexParameteri(data->type, GL_TEXTURE_WRAP_S,
GL_CLAMP_TO_EDGE);
renderdata->glTexParameteri(data->type, GL_TEXTURE_WRAP_T,
GL_CLAMP_TO_EDGE);
renderdata->glTexImage2D(data->type, 0, internalFormat, texture_w/2,
texture_h/2, 0, format, type, NULL);
renderdata->glBindTexture(data->type, data->vtexture);
renderdata->glTexParameteri(data->type, GL_TEXTURE_WRAP_S,
GL_CLAMP_TO_EDGE);
renderdata->glTexParameteri(data->type, GL_TEXTURE_WRAP_T,
GL_CLAMP_TO_EDGE);
renderdata->glTexImage2D(data->type, 0, internalFormat, texture_w/2,
texture_h/2, 0, format, type, NULL);
renderdata->glDisable(data->type);
}
535
536
537
538
539
540
541
return 0;
}
static int
GL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const void *pixels, int pitch)
{
542
GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
543
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
544
GLenum result;
545
546
547
GL_ActivateRenderer(renderer);
548
renderdata->glGetError();
549
550
551
renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH,
(pitch / SDL_BYTESPERPIXEL(texture->format)));
552
renderdata->glEnable(data->type);
553
554
555
556
renderdata->glBindTexture(data->type, data->texture);
renderdata->glTexSubImage2D(data->type, 0, rect->x, rect->y, rect->w,
rect->h, data->format, data->formattype,
pixels);
557
if (data->yuv) {
558
559
560
561
const void *top;
renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH, (pitch / 2));
562
/* Skip to the top of the next texture */
563
top = (const void*)((const Uint8*)pixels + (texture->h-rect->y) * pitch - rect->x);
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
/* Skip to the correct offset into the next texture */
pixels = (const void*)((const Uint8*)top + (rect->y / 2) * pitch + rect->x / 2);
if (texture->format == SDL_PIXELFORMAT_YV12) {
renderdata->glBindTexture(data->type, data->vtexture);
} else {
renderdata->glBindTexture(data->type, data->utexture);
}
renderdata->glTexSubImage2D(data->type, 0, rect->x/2, rect->y/2,
rect->w/2, rect->h/2,
data->format, data->formattype, pixels);
/* Skip to the top of the next texture */
top = (const void*)((const Uint8*)top + (texture->h * pitch)/4);
/* Skip to the correct offset into the next texture */
pixels = (const void*)((const Uint8*)top + (rect->y / 2) * pitch + rect->x / 2);
if (texture->format == SDL_PIXELFORMAT_YV12) {
renderdata->glBindTexture(data->type, data->utexture);
} else {
renderdata->glBindTexture(data->type, data->vtexture);
}
renderdata->glTexSubImage2D(data->type, 0, rect->x/2, rect->y/2,
rect->w/2, rect->h/2,
data->format, data->formattype, pixels);
}
590
renderdata->glDisable(data->type);
591
result = renderdata->glGetError();
592
593
594
595
if (result != GL_NO_ERROR) {
GL_SetError("glTexSubImage2D()", result);
return -1;
}
596
597
598
599
600
return 0;
}
static int
GL_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
601
const SDL_Rect * rect, void **pixels, int *pitch)
602
603
604
{
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
605
606
data->locked_rect = *rect;
*pixels =
607
(void *) ((Uint8 *) data->pixels + rect->y * data->pitch +
608
rect->x * SDL_BYTESPERPIXEL(texture->format));
609
*pitch = data->pitch;
610
611
612
613
614
615
616
return 0;
}
static void
GL_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
617
618
const SDL_Rect *rect;
void *pixels;
619
620
621
622
623
624
rect = &data->locked_rect;
pixels =
(void *) ((Uint8 *) data->pixels + rect->y * data->pitch +
rect->x * SDL_BYTESPERPIXEL(texture->format));
GL_UpdateTexture(renderer, texture, rect, pixels, data->pitch);
625
626
}
627
628
static int
GL_UpdateViewport(SDL_Renderer * renderer)
629
630
631
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
632
633
634
635
if (SDL_CurrentContext != data->context) {
/* We'll update the viewport after we rebind the context */
return 0;
}
636
637
638
data->glViewport(renderer->viewport.x, renderer->viewport.y,
renderer->viewport.w, renderer->viewport.h);
639
640
641
642
643
644
645
646
data->glMatrixMode(GL_PROJECTION);
data->glLoadIdentity();
data->glOrtho((GLdouble) 0,
(GLdouble) renderer->viewport.w,
(GLdouble) renderer->viewport.h,
(GLdouble) 0, 0.0, 1.0);
return 0;
647
648
}
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
static void
GL_SetShader(GL_RenderData * data, GL_Shader shader)
{
if (data->shaders && shader != data->current.shader) {
GL_SelectShader(data->shaders, shader);
data->current.shader = shader;
}
}
static void
GL_SetColor(GL_RenderData * data, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
{
Uint32 color = ((a << 24) | (r << 16) | (g << 8) | b);
if (color != data->current.color) {
data->glColor4f((GLfloat) r * inv255f,
(GLfloat) g * inv255f,
(GLfloat) b * inv255f,
(GLfloat) a * inv255f);
data->current.color = color;
}
}
672
static void
673
GL_SetBlendMode(GL_RenderData * data, int blendMode)
674
{
675
if (blendMode != data->current.blendMode) {
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
switch (blendMode) {
case SDL_BLENDMODE_NONE:
data->glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
data->glDisable(GL_BLEND);
break;
case SDL_BLENDMODE_BLEND:
data->glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
data->glEnable(GL_BLEND);
data->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
break;
case SDL_BLENDMODE_ADD:
data->glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
data->glEnable(GL_BLEND);
data->glBlendFunc(GL_SRC_ALPHA, GL_ONE);
break;
691
692
693
694
695
case SDL_BLENDMODE_MOD:
data->glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
data->glEnable(GL_BLEND);
data->glBlendFunc(GL_ZERO, GL_SRC_COLOR);
break;
696
}
697
data->current.blendMode = blendMode;
698
699
700
}
}
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
static void
GL_SetDrawingState(SDL_Renderer * renderer)
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
GL_ActivateRenderer(renderer);
GL_SetColor(data, (GLfloat) renderer->r,
(GLfloat) renderer->g,
(GLfloat) renderer->b,
(GLfloat) renderer->a);
GL_SetBlendMode(data, renderer->blendMode);
GL_SetShader(data, SHADER_SOLID);
}
718
static int
719
720
721
722
GL_RenderClear(SDL_Renderer * renderer)
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
723
724
GL_ActivateRenderer(renderer);
725
726
727
728
729
730
731
732
733
734
735
736
737
data->glClearColor((GLfloat) renderer->r * inv255f,
(GLfloat) renderer->g * inv255f,
(GLfloat) renderer->b * inv255f,
(GLfloat) renderer->a * inv255f);
data->glClear(GL_COLOR_BUFFER_BIT);
return 0;
}
static int
GL_RenderDrawPoints(SDL_Renderer * renderer, const SDL_Point * points,
int count)
738
739
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
740
int i;
741
742
GL_SetDrawingState(renderer);
743
744
data->glBegin(GL_POINTS);
745
746
747
for (i = 0; i < count; ++i) {
data->glVertex2f(0.5f + points[i].x, 0.5f + points[i].y);
}
748
data->glEnd();
749
750
751
752
return 0;
}
753
static int
754
755
GL_RenderDrawLines(SDL_Renderer * renderer, const SDL_Point * points,
int count)
756
757
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
758
int i;
759
760
GL_SetDrawingState(renderer);
761
762
763
764
765
766
767
768
769
770
771
if (count > 2 &&
points[0].x == points[count-1].x && points[0].y == points[count-1].y) {
data->glBegin(GL_LINE_LOOP);
/* GL_LINE_LOOP takes care of the final segment */
--count;
for (i = 0; i < count; ++i) {
data->glVertex2f(0.5f + points[i].x, 0.5f + points[i].y);
}
data->glEnd();
} else {
772
#if defined(__APPLE__) || defined(__WIN32__)
773
#else
774
int x1, y1, x2, y2;
775
#endif
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
data->glBegin(GL_LINE_STRIP);
for (i = 0; i < count; ++i) {
data->glVertex2f(0.5f + points[i].x, 0.5f + points[i].y);
}
data->glEnd();
/* The line is half open, so we need one more point to complete it.
* http://www.opengl.org/documentation/specs/version1.1/glspec1.1/node47.html
* If we have to, we can use vertical line and horizontal line textures
* for vertical and horizontal lines, and then create custom textures
* for diagonal lines and software render those. It's terrible, but at
* least it would be pixel perfect.
*/
data->glBegin(GL_POINTS);
791
#if defined(__APPLE__) || defined(__WIN32__)
792
793
/* Mac OS X and Windows seem to always leave the second point open */
data->glVertex2f(0.5f + points[count-1].x, 0.5f + points[count-1].y);
794
#else
795
/* Linux seems to leave the right-most or bottom-most point open */
796
797
798
799
x1 = points[0].x;
y1 = points[0].y;
x2 = points[count-1].x;
y2 = points[count-1].y;
800
801
802
803
804
805
806
807
808
809
if (x1 > x2) {
data->glVertex2f(0.5f + x1, 0.5f + y1);
} else if (x2 > x1) {
data->glVertex2f(0.5f + x2, 0.5f + y2);
} else if (y1 > y2) {
data->glVertex2f(0.5f + x1, 0.5f + y1);
} else if (y2 > y1) {
data->glVertex2f(0.5f + x2, 0.5f + y2);
}
810
#endif
811
812
data->glEnd();
}
813
814
815
816
return 0;
}
817
static int
818
GL_RenderFillRects(SDL_Renderer * renderer, const SDL_Rect * rects, int count)
819
820
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
821
int i;
822
823
GL_SetDrawingState(renderer);
824
825
for (i = 0; i < count; ++i) {
826
const SDL_Rect *rect = &rects[i];
827
828
829
data->glRecti(rect->x, rect->y, rect->x + rect->w, rect->y + rect->h);
}
830
831
832
833
834
835
return 0;
}
static int
GL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
836
const SDL_Rect * srcrect, const SDL_Rect * dstrect)
837
838
839
840
841
842
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
GL_TextureData *texturedata = (GL_TextureData *) texture->driverdata;
int minx, miny, maxx, maxy;
GLfloat minu, maxu, minv, maxv;
843
844
GL_ActivateRenderer(renderer);
845
data->glEnable(texturedata->type);
846
847
848
if (texturedata->yuv) {
data->glActiveTextureARB(GL_TEXTURE2_ARB);
data->glBindTexture(texturedata->type, texturedata->vtexture);
849
850
851
852
853
854
855
if (texturedata->scaleMode != data->current.scaleMode) {
data->glTexParameteri(texturedata->type, GL_TEXTURE_MIN_FILTER,
texturedata->scaleMode);
data->glTexParameteri(texturedata->type, GL_TEXTURE_MAG_FILTER,
texturedata->scaleMode);
}
856
857
data->glActiveTextureARB(GL_TEXTURE1_ARB);
data->glBindTexture(texturedata->type, texturedata->utexture);
858
859
860
861
862
863
864
if (texturedata->scaleMode != data->current.scaleMode) {
data->glTexParameteri(texturedata->type, GL_TEXTURE_MIN_FILTER,
texturedata->scaleMode);
data->glTexParameteri(texturedata->type, GL_TEXTURE_MAG_FILTER,
texturedata->scaleMode);
}
865
866
data->glActiveTextureARB(GL_TEXTURE0_ARB);
}
867
868
data->glBindTexture(texturedata->type, texturedata->texture);
869
870
871
872
873
874
875
876
if (texturedata->scaleMode != data->current.scaleMode) {
data->glTexParameteri(texturedata->type, GL_TEXTURE_MIN_FILTER,
texturedata->scaleMode);
data->glTexParameteri(texturedata->type, GL_TEXTURE_MAG_FILTER,
texturedata->scaleMode);
data->current.scaleMode = texturedata->scaleMode;
}
877
if (texture->modMode) {
878
GL_SetColor(data, texture->r, texture->g, texture->b, texture->a);
879
} else {
880
GL_SetColor(data, 255, 255, 255, 255);
881
882
}
883
GL_SetBlendMode(data, texture->blendMode);
884
885
if (texturedata->yuv) {
886
GL_SetShader(data, SHADER_YV12);
887
} else {
888
GL_SetShader(data, SHADER_RGB);
889
}
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
minx = dstrect->x;
miny = dstrect->y;
maxx = dstrect->x + dstrect->w;
maxy = dstrect->y + dstrect->h;
minu = (GLfloat) srcrect->x / texture->w;
minu *= texturedata->texw;
maxu = (GLfloat) (srcrect->x + srcrect->w) / texture->w;
maxu *= texturedata->texw;
minv = (GLfloat) srcrect->y / texture->h;
minv *= texturedata->texh;
maxv = (GLfloat) (srcrect->y + srcrect->h) / texture->h;
maxv *= texturedata->texh;
905
906
data->glBegin(GL_TRIANGLE_STRIP);
data->glTexCoord2f(minu, minv);
907
data->glVertex2f((GLfloat) minx, (GLfloat) miny);
908
data->glTexCoord2f(maxu, minv);
909
data->glVertex2f((GLfloat) maxx, (GLfloat) miny);
910
data->glTexCoord2f(minu, maxv);
911
data->glVertex2f((GLfloat) minx, (GLfloat) maxy);
912
data->glTexCoord2f(maxu, maxv);
913
data->glVertex2f((GLfloat) maxx, (GLfloat) maxy);
914
data->glEnd();
915
916
917
data->glDisable(texturedata->type);
918
919
920
return 0;
}
921
922
static int
GL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
923
Uint32 pixel_format, void * pixels, int pitch)
924
{
925
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
926
SDL_Window *window = renderer->window;
927
928
GLint internalFormat;
GLenum format, type;
929
Uint8 *src, *dst, *tmp;
930
int w, h, length, rows;
931
932
933
GL_ActivateRenderer(renderer);
934
if (!convert_format(data, pixel_format, &internalFormat, &format, &type)) {
935
/* FIXME: Do a temp copy to a format that is supported */
936
937
938
939
SDL_SetError("Unsupported pixel format");
return -1;
}
940
941
SDL_GetWindowSize(window, &w, &h);
942
943
data->glPixelStorei(GL_PACK_ALIGNMENT, 1);
data->glPixelStorei(GL_PACK_ROW_LENGTH,
944
(pitch / SDL_BYTESPERPIXEL(pixel_format)));
945
946
data->glReadPixels(rect->x, (h-rect->y)-rect->h, rect->w, rect->h,
947
948
949
format, type, pixels);
/* Flip the rows to be top-down */
950
length = rect->w * SDL_BYTESPERPIXEL(pixel_format);
951
952
953
954
955
956
957
958
src = (Uint8*)pixels + (rect->h-1)*pitch;
dst = (Uint8*)pixels;
tmp = SDL_stack_alloc(Uint8, length);
rows = rect->h / 2;
while (rows--) {
SDL_memcpy(tmp, dst, length);
SDL_memcpy(dst, src, length);
SDL_memcpy(src, tmp, length);
959
960
dst += pitch;
src -= pitch;
961
962
}
SDL_stack_free(tmp);
963
964
return 0;
965
966
}
967
968
969
static void
GL_RenderPresent(SDL_Renderer * renderer)
{
970
971
GL_ActivateRenderer(renderer);
972
973
974
975
976
977
SDL_GL_SwapWindow(renderer->window);
}
static void
GL_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
978
GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
979
980
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
981
982
GL_ActivateRenderer(renderer);
983
984
985
986
if (!data) {
return;
}
if (data->texture) {
987
renderdata->glDeleteTextures(1, &data->texture);
988
}
989
990
991
992
if (data->yuv) {
renderdata->glDeleteTextures(1, &data->utexture);
renderdata->glDeleteTextures(1, &data->vtexture);
}
993
994
if (data->pixels) {
SDL_free(data->pixels);
995
996
997
998
999
}
SDL_free(data);
texture->driverdata = NULL;
}
1000
static void