This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_renderer_gl.c
821 lines (703 loc) · 24.8 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2010 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
25
26
#include "SDL_opengl.h"
27
#include "../SDL_sysrender.h"
28
29
30
31
32
#ifdef __MACOSX__
#include <OpenGL/OpenGL.h>
#endif
33
34
35
/* OpenGL renderer implementation */
36
37
38
39
/* Details on optimizing the texture path on Mac OS X:
http://developer.apple.com/documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/opengl_texturedata/chapter_10_section_2.html
*/
40
41
/* Used to re-create the window with OpenGL capability */
extern int SDL_RecreateWindow(SDL_Window * window, Uint32 flags);
42
43
44
static const float inv255f = 1.0f / 255.0f;
45
static SDL_Renderer *GL_CreateRenderer(SDL_Window * window, Uint32 flags);
46
47
static void GL_WindowEvent(SDL_Renderer * renderer,
const SDL_WindowEvent *event);
48
49
50
51
52
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,
53
const SDL_Rect * rect, void **pixels, int *pitch);
54
static void GL_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture);
55
56
57
58
59
60
61
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,
const SDL_Rect ** rects, int count);
62
static int GL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
63
const SDL_Rect * srcrect, const SDL_Rect * dstrect);
64
static int GL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
65
Uint32 pixel_format, void * pixels, int pitch);
66
67
68
69
70
71
72
73
74
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",
75
(SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_ACCELERATED),
76
77
1,
{SDL_PIXELFORMAT_ARGB8888},
78
79
80
81
82
83
84
0,
0}
};
typedef struct
{
SDL_GLContext context;
85
SDL_bool updateSize;
86
SDL_bool GL_ARB_texture_rectangle_supported;
87
88
89
90
int blendMode;
/* OpenGL functions */
#define SDL_PROC(ret,func,params) ret (APIENTRY *func) params;
91
#include "../../video/SDL_glfuncs.h"
92
#undef SDL_PROC
93
94
95
void (*glTextureRangeAPPLE) (GLenum target, GLsizei length,
const GLvoid * pointer);
96
97
98
99
100
} GL_RenderData;
typedef struct
{
GLuint texture;
101
GLenum type;
102
103
GLfloat texw;
GLfloat texh;
104
105
GLenum format;
GLenum formattype;
106
107
108
109
110
void *pixels;
int pitch;
} GL_TextureData;
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
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);
}
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
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__ */
164
#include "../../video/SDL_glfuncs.h"
165
166
167
168
#undef SDL_PROC
return 0;
}
169
170
171
172
173
SDL_Renderer *
GL_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_Renderer *renderer;
GL_RenderData *data;
174
GLint value;
175
Uint32 window_flags;
176
177
178
179
window_flags = SDL_GetWindowFlags(window);
if (!(window_flags & SDL_WINDOW_OPENGL)) {
if (SDL_RecreateWindow(window, window_flags | SDL_WINDOW_OPENGL) < 0) {
180
181
return NULL;
}
182
183
}
184
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
185
186
187
188
189
if (!renderer) {
SDL_OutOfMemory();
return NULL;
}
190
data = (GL_RenderData *) SDL_calloc(1, sizeof(*data));
191
192
193
194
195
196
if (!data) {
GL_DestroyRenderer(renderer);
SDL_OutOfMemory();
return NULL;
}
197
renderer->WindowEvent = GL_WindowEvent;
198
199
200
201
renderer->CreateTexture = GL_CreateTexture;
renderer->UpdateTexture = GL_UpdateTexture;
renderer->LockTexture = GL_LockTexture;
renderer->UnlockTexture = GL_UnlockTexture;
202
203
204
205
renderer->RenderClear = GL_RenderClear;
renderer->RenderDrawPoints = GL_RenderDrawPoints;
renderer->RenderDrawLines = GL_RenderDrawLines;
renderer->RenderFillRects = GL_RenderFillRects;
206
renderer->RenderCopy = GL_RenderCopy;
207
renderer->RenderReadPixels = GL_RenderReadPixels;
208
209
210
211
212
213
renderer->RenderPresent = GL_RenderPresent;
renderer->DestroyTexture = GL_DestroyTexture;
renderer->DestroyRenderer = GL_DestroyRenderer;
renderer->info = GL_RenderDriver.info;
renderer->driverdata = data;
214
renderer->info.flags = SDL_RENDERER_ACCELERATED;
215
216
217
218
219
220
if (GL_LoadFunctions(data) < 0) {
GL_DestroyRenderer(renderer);
return NULL;
}
221
data->context = SDL_GL_CreateContext(window);
222
223
224
225
if (!data->context) {
GL_DestroyRenderer(renderer);
return NULL;
}
226
if (SDL_GL_MakeCurrent(window, data->context) < 0) {
227
228
229
GL_DestroyRenderer(renderer);
return NULL;
}
230
231
232
#ifdef __MACOSX__
/* Enable multi-threaded rendering */
/* Disabled until Ryan finishes his VBO/PBO code...
233
234
CGLEnable(CGLGetCurrentContext(), kCGLCEMPEngine);
*/
235
236
#endif
237
if (flags & SDL_RENDERER_PRESENTVSYNC) {
238
239
240
241
242
SDL_GL_SetSwapInterval(1);
} else {
SDL_GL_SetSwapInterval(0);
}
if (SDL_GL_GetSwapInterval() > 0) {
243
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
244
245
}
246
247
248
249
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;
250
251
252
253
254
if (SDL_GL_ExtensionSupported("GL_ARB_texture_rectangle")
|| SDL_GL_ExtensionSupported("GL_EXT_texture_rectangle")) {
data->GL_ARB_texture_rectangle_supported = SDL_TRUE;
}
255
256
257
258
259
if (SDL_GL_ExtensionSupported("GL_APPLE_texture_range")) {
data->glTextureRangeAPPLE =
(void (*)(GLenum, GLsizei, const GLvoid *))
SDL_GL_GetProcAddress("glTextureRangeAPPLE");
}
260
261
/* Set up parameters for rendering */
262
263
264
data->blendMode = -1;
data->glDisable(GL_DEPTH_TEST);
data->glDisable(GL_CULL_FACE);
265
266
/* This ended up causing video discrepancies between OpenGL and Direct3D */
/*data->glEnable(GL_LINE_SMOOTH);*/
267
if (data->GL_ARB_texture_rectangle_supported) {
268
data->glEnable(GL_TEXTURE_RECTANGLE_ARB);
269
} else {
270
data->glEnable(GL_TEXTURE_2D);
271
}
272
data->updateSize = SDL_TRUE;
273
274
275
276
return renderer;
}
277
278
static SDL_GLContext SDL_CurrentContext = NULL;
279
280
281
282
static int
GL_ActivateRenderer(SDL_Renderer * renderer)
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
283
SDL_Window *window = renderer->window;
284
285
286
287
288
289
if (SDL_CurrentContext != data->context) {
if (SDL_GL_MakeCurrent(window, data->context) < 0) {
return -1;
}
SDL_CurrentContext = data->context;
290
}
291
if (data->updateSize) {
292
293
294
int w, h;
SDL_GetWindowSize(window, &w, &h);
295
296
297
298
data->glMatrixMode(GL_PROJECTION);
data->glLoadIdentity();
data->glMatrixMode(GL_MODELVIEW);
data->glLoadIdentity();
299
300
data->glViewport(0, 0, w, h);
data->glOrtho(0.0, (GLdouble) w, (GLdouble) h, 0.0, 0.0, 1.0);
301
302
data->updateSize = SDL_FALSE;
}
303
304
305
return 0;
}
306
307
static void
GL_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
308
309
310
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
311
312
313
314
315
if (event->event == SDL_WINDOWEVENT_RESIZED) {
/* Rebind the context to the window area and update matrices */
SDL_CurrentContext = NULL;
data->updateSize = SDL_TRUE;
}
316
317
}
318
319
320
321
322
323
324
325
326
327
328
static __inline__ int
power_of_2(int input)
{
int value = 1;
while (value < input) {
value <<= 1;
}
return value;
}
329
330
331
static __inline__ SDL_bool
convert_format(GL_RenderData *renderdata, Uint32 pixel_format,
GLint* internalFormat, GLenum* format, GLenum* type)
332
{
333
switch (pixel_format) {
334
335
case SDL_PIXELFORMAT_RGB888:
case SDL_PIXELFORMAT_ARGB8888:
336
337
*internalFormat = GL_RGBA8;
*format = GL_BGRA;
338
*type = GL_UNSIGNED_INT_8_8_8_8_REV;
339
break;
340
default:
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
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;
356
357
GL_ActivateRenderer(renderer);
358
359
if (!convert_format(renderdata, texture->format, &internalFormat,
&format, &type)) {
360
361
SDL_SetError("Texture format %s not supported by OpenGL",
SDL_GetPixelFormatName(texture->format));
362
363
return -1;
}
364
365
data = (GL_TextureData *) SDL_calloc(1, sizeof(*data));
366
367
368
369
370
if (!data) {
SDL_OutOfMemory();
return -1;
}
371
if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
372
data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
373
374
375
376
377
378
379
380
data->pixels = SDL_malloc(texture->h * data->pitch);
if (!data->pixels) {
SDL_OutOfMemory();
SDL_free(data);
return -1;
}
}
381
382
texture->driverdata = data;
383
384
renderdata->glGetError();
renderdata->glGenTextures(1, &data->texture);
385
386
387
388
if (renderdata->GL_ARB_texture_rectangle_supported) {
data->type = GL_TEXTURE_RECTANGLE_ARB;
texture_w = texture->w;
texture_h = texture->h;
389
390
data->texw = (GLfloat) texture_w;
data->texh = (GLfloat) texture_h;
391
392
393
394
} else {
data->type = GL_TEXTURE_2D;
texture_w = power_of_2(texture->w);
texture_h = power_of_2(texture->h);
395
data->texw = (GLfloat) (texture->w) / texture_w;
396
397
data->texh = (GLfloat) texture->h / texture_h;
}
398
399
400
data->format = format;
data->formattype = type;
401
renderdata->glEnable(data->type);
402
renderdata->glBindTexture(data->type, data->texture);
403
renderdata->glTexParameteri(data->type, GL_TEXTURE_MIN_FILTER,
404
GL_LINEAR);
405
renderdata->glTexParameteri(data->type, GL_TEXTURE_MAG_FILTER,
406
GL_LINEAR);
407
408
409
410
renderdata->glTexParameteri(data->type, GL_TEXTURE_WRAP_S,
GL_CLAMP_TO_EDGE);
renderdata->glTexParameteri(data->type, GL_TEXTURE_WRAP_T,
GL_CLAMP_TO_EDGE);
411
#ifdef __MACOSX__
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
#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);
}
428
429
if (texture->access == SDL_TEXTUREACCESS_STREAMING
&& texture->format == SDL_PIXELFORMAT_ARGB8888) {
430
431
432
renderdata->glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
renderdata->glTexImage2D(data->type, 0, internalFormat, texture_w,
texture_h, 0, format, type, data->pixels);
433
434
}
else
435
436
437
438
439
#endif
{
renderdata->glTexImage2D(data->type, 0, internalFormat, texture_w,
texture_h, 0, format, type, NULL);
}
440
renderdata->glDisable(data->type);
441
result = renderdata->glGetError();
442
443
444
445
if (result != GL_NO_ERROR) {
GL_SetError("glTexImage2D()", result);
return -1;
}
446
447
448
return 0;
}
449
static void
450
451
SetupTextureUpdate(GL_RenderData * renderdata, SDL_Texture * texture,
int pitch)
452
{
453
renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
454
renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH,
455
(pitch / SDL_BYTESPERPIXEL(texture->format)));
456
457
}
458
459
460
461
static int
GL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const void *pixels, int pitch)
{
462
GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
463
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
464
GLenum result;
465
466
467
GL_ActivateRenderer(renderer);
468
469
renderdata->glGetError();
SetupTextureUpdate(renderdata, texture, pitch);
470
renderdata->glEnable(data->type);
471
472
473
474
renderdata->glBindTexture(data->type, data->texture);
renderdata->glTexSubImage2D(data->type, 0, rect->x, rect->y, rect->w,
rect->h, data->format, data->formattype,
pixels);
475
renderdata->glDisable(data->type);
476
result = renderdata->glGetError();
477
478
479
480
if (result != GL_NO_ERROR) {
GL_SetError("glTexSubImage2D()", result);
return -1;
}
481
482
483
484
485
return 0;
}
static int
GL_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
486
const SDL_Rect * rect, void **pixels, int *pitch)
487
488
489
{
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
490
491
*pixels =
(void *) ((Uint8 *) data->pixels + rect->y * data->pitch +
492
rect->x * SDL_BYTESPERPIXEL(texture->format));
493
*pitch = data->pitch;
494
495
496
497
498
499
return 0;
}
static void
GL_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
500
GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
501
502
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
503
504
505
506
507
508
509
510
GL_ActivateRenderer(renderer);
SetupTextureUpdate(renderdata, texture, data->pitch);
renderdata->glEnable(data->type);
renderdata->glBindTexture(data->type, data->texture);
renderdata->glTexSubImage2D(data->type, 0, 0, 0, texture->w, texture->h,
data->format, data->formattype, data->pixels);
renderdata->glDisable(data->type);
511
512
}
513
static void
514
GL_SetBlendMode(GL_RenderData * data, int blendMode)
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
{
if (blendMode != data->blendMode) {
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;
}
data->blendMode = blendMode;
}
}
537
static int
538
539
540
541
GL_RenderClear(SDL_Renderer * renderer)
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
542
543
GL_ActivateRenderer(renderer);
544
545
546
547
548
549
550
551
552
553
554
555
556
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)
557
558
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
559
int i;
560
561
562
GL_ActivateRenderer(renderer);
563
GL_SetBlendMode(data, renderer->blendMode);
564
565
566
567
568
data->glColor4f((GLfloat) renderer->r * inv255f,
(GLfloat) renderer->g * inv255f,
(GLfloat) renderer->b * inv255f,
(GLfloat) renderer->a * inv255f);
569
570
data->glBegin(GL_POINTS);
571
572
573
for (i = 0; i < count; ++i) {
data->glVertex2f(0.5f + points[i].x, 0.5f + points[i].y);
}
574
data->glEnd();
575
576
577
578
return 0;
}
579
static int
580
581
GL_RenderDrawLines(SDL_Renderer * renderer, const SDL_Point * points,
int count)
582
583
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
584
int i;
585
586
587
GL_ActivateRenderer(renderer);
588
GL_SetBlendMode(data, renderer->blendMode);
589
590
591
592
593
594
data->glColor4f((GLfloat) renderer->r * inv255f,
(GLfloat) renderer->g * inv255f,
(GLfloat) renderer->b * inv255f,
(GLfloat) renderer->a * inv255f);
595
596
597
598
599
600
601
602
603
604
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 {
605
#if defined(__APPLE__) || defined(__WIN32__)
606
#else
607
int x1, y1, x2, y2;
608
#endif
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
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);
624
#if defined(__APPLE__) || defined(__WIN32__)
625
626
/* 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);
627
#else
628
/* Linux seems to leave the right-most or bottom-most point open */
629
630
631
632
x1 = points[0].x;
y1 = points[0].y;
x2 = points[count-1].x;
y2 = points[count-1].y;
633
634
635
636
637
638
639
640
641
642
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);
}
643
#endif
644
645
data->glEnd();
}
646
647
648
649
return 0;
}
650
651
static int
GL_RenderFillRects(SDL_Renderer * renderer, const SDL_Rect ** rects, int count)
652
653
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
654
int i;
655
656
657
GL_ActivateRenderer(renderer);
658
GL_SetBlendMode(data, renderer->blendMode);
659
660
661
662
663
data->glColor4f((GLfloat) renderer->r * inv255f,
(GLfloat) renderer->g * inv255f,
(GLfloat) renderer->b * inv255f,
(GLfloat) renderer->a * inv255f);
664
665
666
667
668
669
for (i = 0; i < count; ++i) {
const SDL_Rect *rect = rects[i];
data->glRecti(rect->x, rect->y, rect->x + rect->w, rect->y + rect->h);
}
670
671
672
673
674
675
return 0;
}
static int
GL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
676
const SDL_Rect * srcrect, const SDL_Rect * dstrect)
677
678
679
680
681
682
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
GL_TextureData *texturedata = (GL_TextureData *) texture->driverdata;
int minx, miny, maxx, maxy;
GLfloat minu, maxu, minv, maxv;
683
684
GL_ActivateRenderer(renderer);
685
686
687
688
689
690
minx = dstrect->x;
miny = dstrect->y;
maxx = dstrect->x + dstrect->w;
maxy = dstrect->y + dstrect->h;
minu = (GLfloat) srcrect->x / texture->w;
691
minu *= texturedata->texw;
692
maxu = (GLfloat) (srcrect->x + srcrect->w) / texture->w;
693
maxu *= texturedata->texw;
694
minv = (GLfloat) srcrect->y / texture->h;
695
minv *= texturedata->texh;
696
maxv = (GLfloat) (srcrect->y + srcrect->h) / texture->h;
697
maxv *= texturedata->texh;
698
699
data->glEnable(texturedata->type);
700
701
data->glBindTexture(texturedata->type, texturedata->texture);
702
703
704
705
706
707
708
709
710
if (texture->modMode) {
data->glColor4f((GLfloat) texture->r * inv255f,
(GLfloat) texture->g * inv255f,
(GLfloat) texture->b * inv255f,
(GLfloat) texture->a * inv255f);
} else {
data->glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
}
711
GL_SetBlendMode(data, texture->blendMode);
712
713
714
data->glBegin(GL_TRIANGLE_STRIP);
data->glTexCoord2f(minu, minv);
715
data->glVertex2f((GLfloat) minx, (GLfloat) miny);
716
data->glTexCoord2f(maxu, minv);
717
data->glVertex2f((GLfloat) maxx, (GLfloat) miny);
718
data->glTexCoord2f(minu, maxv);
719
data->glVertex2f((GLfloat) minx, (GLfloat) maxy);
720
data->glTexCoord2f(maxu, maxv);
721
data->glVertex2f((GLfloat) maxx, (GLfloat) maxy);
722
data->glEnd();
723
724
725
data->glDisable(texturedata->type);
726
727
728
return 0;
}
729
730
static int
GL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
731
Uint32 pixel_format, void * pixels, int pitch)
732
{
733
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
734
SDL_Window *window = renderer->window;
735
736
GLint internalFormat;
GLenum format, type;
737
Uint8 *src, *dst, *tmp;
738
int w, h, length, rows;
739
740
741
GL_ActivateRenderer(renderer);
742
if (!convert_format(data, pixel_format, &internalFormat, &format, &type)) {
743
/* FIXME: Do a temp copy to a format that is supported */
744
745
746
747
SDL_SetError("Unsupported pixel format");
return -1;
}
748
749
SDL_GetWindowSize(window, &w, &h);
750
751
data->glPixelStorei(GL_PACK_ALIGNMENT, 1);
data->glPixelStorei(GL_PACK_ROW_LENGTH,
752
(pitch / SDL_BYTESPERPIXEL(pixel_format)));
753
754
data->glReadPixels(rect->x, (h-rect->y)-rect->h, rect->w, rect->h,
755
756
757
format, type, pixels);
/* Flip the rows to be top-down */
758
length = rect->w * SDL_BYTESPERPIXEL(pixel_format);
759
760
761
762
763
764
765
766
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);
767
768
dst += pitch;
src -= pitch;
769
770
}
SDL_stack_free(tmp);
771
772
return 0;
773
774
}
775
776
777
static void
GL_RenderPresent(SDL_Renderer * renderer)
{
778
779
GL_ActivateRenderer(renderer);
780
781
782
783
784
785
SDL_GL_SwapWindow(renderer->window);
}
static void
GL_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
786
GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
787
788
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
789
790
GL_ActivateRenderer(renderer);
791
792
793
794
if (!data) {
return;
}
if (data->texture) {
795
renderdata->glDeleteTextures(1, &data->texture);
796
797
798
}
if (data->pixels) {
SDL_free(data->pixels);
799
800
801
802
803
}
SDL_free(data);
texture->driverdata = NULL;
}
804
static void
805
806
807
808
809
GL_DestroyRenderer(SDL_Renderer * renderer)
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
if (data) {
810
if (data->context) {
811
/* SDL_GL_MakeCurrent(0, NULL); *//* doesn't do anything */
812
SDL_GL_DeleteContext(data->context);
813
814
815
816
817
818
}
SDL_free(data);
}
SDL_free(renderer);
}
819
#endif /* SDL_VIDEO_RENDER_OGL */
820
821
/* vi: set ts=4 sw=4 expandtab: */