This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_render_gl.c
826 lines (708 loc) · 25.1 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
{
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;
532
533
534
535
536
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;
537
538
539
540
541
}
data->blendMode = blendMode;
}
}
542
static int
543
544
545
546
GL_RenderClear(SDL_Renderer * renderer)
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
547
548
GL_ActivateRenderer(renderer);
549
550
551
552
553
554
555
556
557
558
559
560
561
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)
562
563
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
564
int i;
565
566
567
GL_ActivateRenderer(renderer);
568
GL_SetBlendMode(data, renderer->blendMode);
569
570
571
572
573
data->glColor4f((GLfloat) renderer->r * inv255f,
(GLfloat) renderer->g * inv255f,
(GLfloat) renderer->b * inv255f,
(GLfloat) renderer->a * inv255f);
574
575
data->glBegin(GL_POINTS);
576
577
578
for (i = 0; i < count; ++i) {
data->glVertex2f(0.5f + points[i].x, 0.5f + points[i].y);
}
579
data->glEnd();
580
581
582
583
return 0;
}
584
static int
585
586
GL_RenderDrawLines(SDL_Renderer * renderer, const SDL_Point * points,
int count)
587
588
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
589
int i;
590
591
592
GL_ActivateRenderer(renderer);
593
GL_SetBlendMode(data, renderer->blendMode);
594
595
596
597
598
599
data->glColor4f((GLfloat) renderer->r * inv255f,
(GLfloat) renderer->g * inv255f,
(GLfloat) renderer->b * inv255f,
(GLfloat) renderer->a * inv255f);
600
601
602
603
604
605
606
607
608
609
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 {
610
#if defined(__APPLE__) || defined(__WIN32__)
611
#else
612
int x1, y1, x2, y2;
613
#endif
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
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);
629
#if defined(__APPLE__) || defined(__WIN32__)
630
631
/* 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);
632
#else
633
/* Linux seems to leave the right-most or bottom-most point open */
634
635
636
637
x1 = points[0].x;
y1 = points[0].y;
x2 = points[count-1].x;
y2 = points[count-1].y;
638
639
640
641
642
643
644
645
646
647
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);
}
648
#endif
649
650
data->glEnd();
}
651
652
653
654
return 0;
}
655
656
static int
GL_RenderFillRects(SDL_Renderer * renderer, const SDL_Rect ** rects, int count)
657
658
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
659
int i;
660
661
662
GL_ActivateRenderer(renderer);
663
GL_SetBlendMode(data, renderer->blendMode);
664
665
666
667
668
data->glColor4f((GLfloat) renderer->r * inv255f,
(GLfloat) renderer->g * inv255f,
(GLfloat) renderer->b * inv255f,
(GLfloat) renderer->a * inv255f);
669
670
671
672
673
674
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);
}
675
676
677
678
679
680
return 0;
}
static int
GL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
681
const SDL_Rect * srcrect, const SDL_Rect * dstrect)
682
683
684
685
686
687
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
GL_TextureData *texturedata = (GL_TextureData *) texture->driverdata;
int minx, miny, maxx, maxy;
GLfloat minu, maxu, minv, maxv;
688
689
GL_ActivateRenderer(renderer);
690
691
692
693
694
695
minx = dstrect->x;
miny = dstrect->y;
maxx = dstrect->x + dstrect->w;
maxy = dstrect->y + dstrect->h;
minu = (GLfloat) srcrect->x / texture->w;
696
minu *= texturedata->texw;
697
maxu = (GLfloat) (srcrect->x + srcrect->w) / texture->w;
698
maxu *= texturedata->texw;
699
minv = (GLfloat) srcrect->y / texture->h;
700
minv *= texturedata->texh;
701
maxv = (GLfloat) (srcrect->y + srcrect->h) / texture->h;
702
maxv *= texturedata->texh;
703
704
data->glEnable(texturedata->type);
705
706
data->glBindTexture(texturedata->type, texturedata->texture);
707
708
709
710
711
712
713
714
715
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);
}
716
GL_SetBlendMode(data, texture->blendMode);
717
718
719
data->glBegin(GL_TRIANGLE_STRIP);
data->glTexCoord2f(minu, minv);
720
data->glVertex2f((GLfloat) minx, (GLfloat) miny);
721
data->glTexCoord2f(maxu, minv);
722
data->glVertex2f((GLfloat) maxx, (GLfloat) miny);
723
data->glTexCoord2f(minu, maxv);
724
data->glVertex2f((GLfloat) minx, (GLfloat) maxy);
725
data->glTexCoord2f(maxu, maxv);
726
data->glVertex2f((GLfloat) maxx, (GLfloat) maxy);
727
data->glEnd();
728
729
730
data->glDisable(texturedata->type);
731
732
733
return 0;
}
734
735
static int
GL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
736
Uint32 pixel_format, void * pixels, int pitch)
737
{
738
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
739
SDL_Window *window = renderer->window;
740
741
GLint internalFormat;
GLenum format, type;
742
Uint8 *src, *dst, *tmp;
743
int w, h, length, rows;
744
745
746
GL_ActivateRenderer(renderer);
747
if (!convert_format(data, pixel_format, &internalFormat, &format, &type)) {
748
/* FIXME: Do a temp copy to a format that is supported */
749
750
751
752
SDL_SetError("Unsupported pixel format");
return -1;
}
753
754
SDL_GetWindowSize(window, &w, &h);
755
756
data->glPixelStorei(GL_PACK_ALIGNMENT, 1);
data->glPixelStorei(GL_PACK_ROW_LENGTH,
757
(pitch / SDL_BYTESPERPIXEL(pixel_format)));
758
759
data->glReadPixels(rect->x, (h-rect->y)-rect->h, rect->w, rect->h,
760
761
762
format, type, pixels);
/* Flip the rows to be top-down */
763
length = rect->w * SDL_BYTESPERPIXEL(pixel_format);
764
765
766
767
768
769
770
771
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);
772
773
dst += pitch;
src -= pitch;
774
775
}
SDL_stack_free(tmp);
776
777
return 0;
778
779
}
780
781
782
static void
GL_RenderPresent(SDL_Renderer * renderer)
{
783
784
GL_ActivateRenderer(renderer);
785
786
787
788
789
790
SDL_GL_SwapWindow(renderer->window);
}
static void
GL_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
791
GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
792
793
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
794
795
GL_ActivateRenderer(renderer);
796
797
798
799
if (!data) {
return;
}
if (data->texture) {
800
renderdata->glDeleteTextures(1, &data->texture);
801
802
803
}
if (data->pixels) {
SDL_free(data->pixels);
804
805
806
807
808
}
SDL_free(data);
texture->driverdata = NULL;
}
809
static void
810
811
812
813
814
GL_DestroyRenderer(SDL_Renderer * renderer)
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
if (data) {
815
if (data->context) {
816
/* SDL_GL_MakeCurrent(0, NULL); *//* doesn't do anything */
817
SDL_GL_DeleteContext(data->context);
818
819
820
821
822
823
}
SDL_free(data);
}
SDL_free(renderer);
}
824
#endif /* SDL_VIDEO_RENDER_OGL */
825
826
/* vi: set ts=4 sw=4 expandtab: */