This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
SDL_renderer_gl.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
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
27
28
29
30
31
#include "SDL_video.h"
#include "SDL_opengl.h"
#include "SDL_sysvideo.h"
#include "SDL_pixels_c.h"
#include "SDL_rect_c.h"
#include "SDL_yuv_sw_c.h"
32
33
34
/* OpenGL renderer implementation */
35
36
static const float inv255f = 1.0f / 255.0f;
37
static SDL_Renderer *GL_CreateRenderer(SDL_Window * window, Uint32 flags);
38
static int GL_ActivateRenderer(SDL_Renderer * renderer);
39
static int GL_DisplayModeChanged(SDL_Renderer * renderer);
40
41
42
43
44
45
46
47
static int GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
static int GL_SetTexturePalette(SDL_Renderer * renderer,
SDL_Texture * texture,
const SDL_Color * colors, int firstcolor,
int ncolors);
static int GL_GetTexturePalette(SDL_Renderer * renderer,
SDL_Texture * texture, SDL_Color * colors,
int firstcolor, int ncolors);
48
49
50
51
52
53
54
55
static int GL_SetTextureColorMod(SDL_Renderer * renderer,
SDL_Texture * texture);
static int GL_SetTextureAlphaMod(SDL_Renderer * renderer,
SDL_Texture * texture);
static int GL_SetTextureBlendMode(SDL_Renderer * renderer,
SDL_Texture * texture);
static int GL_SetTextureScaleMode(SDL_Renderer * renderer,
SDL_Texture * texture);
56
57
58
59
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,
60
61
const SDL_Rect * rect, int markDirty, void **pixels,
int *pitch);
62
63
64
static void GL_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture);
static void GL_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture,
int numrects, const SDL_Rect * rects);
65
66
static int GL_RenderFill(SDL_Renderer * renderer, Uint8 r, Uint8 g, Uint8 b,
Uint8 a, const SDL_Rect * rect);
67
static int GL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
68
const SDL_Rect * srcrect, const SDL_Rect * dstrect);
69
70
71
72
73
74
75
76
77
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",
78
79
(SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD |
SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_ACCELERATED),
80
81
(SDL_TEXTUREMODULATE_NONE | SDL_TEXTUREMODULATE_COLOR |
SDL_TEXTUREMODULATE_ALPHA),
82
83
84
85
86
(SDL_TEXTUREBLENDMODE_NONE | SDL_TEXTUREBLENDMODE_MASK |
SDL_TEXTUREBLENDMODE_BLEND | SDL_TEXTUREBLENDMODE_ADD |
SDL_TEXTUREBLENDMODE_MOD),
(SDL_TEXTURESCALEMODE_NONE | SDL_TEXTURESCALEMODE_FAST |
SDL_TEXTURESCALEMODE_SLOW),
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
SDL_PIXELFORMAT_INDEX1LSB,
SDL_PIXELFORMAT_INDEX1MSB,
SDL_PIXELFORMAT_INDEX8,
SDL_PIXELFORMAT_RGB332,
SDL_PIXELFORMAT_RGB444,
SDL_PIXELFORMAT_RGB555,
SDL_PIXELFORMAT_ARGB4444,
SDL_PIXELFORMAT_ARGB1555,
SDL_PIXELFORMAT_RGB565,
SDL_PIXELFORMAT_RGB24,
SDL_PIXELFORMAT_BGR24,
SDL_PIXELFORMAT_RGB888,
SDL_PIXELFORMAT_BGR888,
SDL_PIXELFORMAT_ARGB8888,
SDL_PIXELFORMAT_ABGR8888,
SDL_PIXELFORMAT_ARGB2101010},
105
106
107
108
109
110
111
0,
0}
};
typedef struct
{
SDL_GLContext context;
112
SDL_bool updateSize;
113
SDL_bool GL_EXT_paletted_texture_supported;
114
SDL_bool GL_ARB_texture_rectangle_supported;
115
116
117
118
119
120
121
int blendMode;
int scaleMode;
/* OpenGL functions */
#define SDL_PROC(ret,func,params) ret (APIENTRY *func) params;
#include "SDL_glfuncs.h"
#undef SDL_PROC
122
123
PFNGLCOLORTABLEEXTPROC glColorTableEXT;
124
125
126
127
128
} GL_RenderData;
typedef struct
{
GLuint texture;
130
131
GLfloat texw;
GLfloat texh;
132
133
GLenum format;
GLenum formattype;
134
Uint8 *palette;
135
136
void *pixels;
int pitch;
137
SDL_DirtyRectList dirty;
138
139
140
} GL_TextureData;
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
172
173
174
175
176
177
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);
}
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
static int
GL_LoadFunctions(GL_RenderData * data)
{
#if defined(__QNXNTO__) && (_NTO_VERSION < 630)
#define __SDL_NOGETPROCADDR__
#elif defined(__MINT__)
#define __SDL_NOGETPROCADDR__
#endif
#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__ */
#include "SDL_glfuncs.h"
#undef SDL_PROC
return 0;
}
204
205
206
void
GL_AddRenderDriver(_THIS)
{
207
if (_this->GL_CreateContext) {
208
209
210
211
212
213
214
215
216
SDL_AddRenderDriver(0, &GL_RenderDriver);
}
}
SDL_Renderer *
GL_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_Renderer *renderer;
GL_RenderData *data;
217
GLint value;
218
int doublebuffer;
220
221
222
223
224
225
/* Render directly to the window, unless we're compositing */
#ifndef __MACOSX__
if (flags & SDL_RENDERER_SINGLEBUFFER) {
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 0);
}
#endif
226
if (!(window->flags & SDL_WINDOW_OPENGL)) {
227
if (SDL_RecreateWindow(window, window->flags | SDL_WINDOW_OPENGL) < 0) {
228
229
return NULL;
}
232
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
233
234
235
236
237
if (!renderer) {
SDL_OutOfMemory();
return NULL;
}
238
data = (GL_RenderData *) SDL_calloc(1, sizeof(*data));
239
240
241
242
243
244
if (!data) {
GL_DestroyRenderer(renderer);
SDL_OutOfMemory();
return NULL;
}
245
renderer->ActivateRenderer = GL_ActivateRenderer;
246
renderer->DisplayModeChanged = GL_DisplayModeChanged;
247
248
249
renderer->CreateTexture = GL_CreateTexture;
renderer->SetTexturePalette = GL_SetTexturePalette;
renderer->GetTexturePalette = GL_GetTexturePalette;
250
251
252
253
renderer->SetTextureColorMod = GL_SetTextureColorMod;
renderer->SetTextureAlphaMod = GL_SetTextureAlphaMod;
renderer->SetTextureBlendMode = GL_SetTextureBlendMode;
renderer->SetTextureScaleMode = GL_SetTextureScaleMode;
254
255
256
257
258
259
260
261
262
263
264
265
266
267
renderer->UpdateTexture = GL_UpdateTexture;
renderer->LockTexture = GL_LockTexture;
renderer->UnlockTexture = GL_UnlockTexture;
renderer->DirtyTexture = GL_DirtyTexture;
renderer->RenderFill = GL_RenderFill;
renderer->RenderCopy = GL_RenderCopy;
renderer->RenderPresent = GL_RenderPresent;
renderer->DestroyTexture = GL_DestroyTexture;
renderer->DestroyRenderer = GL_DestroyRenderer;
renderer->info = GL_RenderDriver.info;
renderer->window = window->id;
renderer->driverdata = data;
renderer->info.flags =
268
(SDL_RENDERER_PRESENTDISCARD | SDL_RENDERER_ACCELERATED);
270
271
272
273
274
if (GL_LoadFunctions(data) < 0) {
GL_DestroyRenderer(renderer);
return NULL;
}
275
276
277
278
279
280
281
282
283
284
data->context = SDL_GL_CreateContext(window->id);
if (!data->context) {
GL_DestroyRenderer(renderer);
return NULL;
}
if (SDL_GL_MakeCurrent(window->id, data->context) < 0) {
GL_DestroyRenderer(renderer);
return NULL;
}
285
if (flags & SDL_RENDERER_PRESENTVSYNC) {
286
287
288
289
290
SDL_GL_SetSwapInterval(1);
} else {
SDL_GL_SetSwapInterval(0);
}
if (SDL_GL_GetSwapInterval() > 0) {
291
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
294
295
296
297
298
299
if (SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &doublebuffer) == 0) {
if (!doublebuffer) {
renderer->info.flags |= SDL_RENDERER_SINGLEBUFFER;
}
}
300
301
302
303
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;
305
306
307
308
if (SDL_GL_ExtensionSupported("GL_ARB_texture_rectangle")
|| SDL_GL_ExtensionSupported("GL_EXT_texture_rectangle")) {
data->GL_ARB_texture_rectangle_supported = SDL_TRUE;
}
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
if (SDL_GL_ExtensionSupported("GL_EXT_paletted_texture")) {
data->GL_EXT_paletted_texture_supported = SDL_TRUE;
data->glColorTableEXT =
(PFNGLCOLORTABLEEXTPROC) SDL_GL_GetProcAddress("glColorTableEXT");
} else {
/* Don't advertise support for 8-bit indexed texture format */
Uint32 i, j;
SDL_RendererInfo *info = &renderer->info;
for (i = 0, j = 0; i < info->num_texture_formats; ++i) {
if (info->texture_formats[i] != SDL_PIXELFORMAT_INDEX8) {
info->texture_formats[j++] = info->texture_formats[i];
}
}
--info->num_texture_formats;
}
325
/* Set up parameters for rendering */
326
327
328
329
data->blendMode = -1;
data->scaleMode = -1;
data->glDisable(GL_DEPTH_TEST);
data->glDisable(GL_CULL_FACE);
330
if (data->GL_ARB_texture_rectangle_supported) {
331
data->glEnable(GL_TEXTURE_RECTANGLE_ARB);
332
} else {
333
data->glEnable(GL_TEXTURE_2D);
335
data->updateSize = SDL_TRUE;
336
337
338
339
return renderer;
}
340
341
342
343
344
345
static int
GL_ActivateRenderer(SDL_Renderer * renderer)
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
if (SDL_GL_MakeCurrent(window->id, data->context) < 0) {
return -1;
}
if (data->updateSize) {
data->glMatrixMode(GL_PROJECTION);
data->glLoadIdentity();
data->glMatrixMode(GL_MODELVIEW);
data->glLoadIdentity();
data->glViewport(0, 0, window->w, window->h);
data->glOrtho(0.0, (GLdouble) window->w, (GLdouble) window->h, 0.0,
0.0, 1.0);
data->updateSize = SDL_FALSE;
}
return 0;
}
static int
GL_DisplayModeChanged(SDL_Renderer * renderer)
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
data->updateSize = SDL_TRUE;
return 0;
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
385
386
387
static int
GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
GL_TextureData *data;
388
389
GLint internalFormat;
GLenum format, type;
390
int texture_w, texture_h;
391
GLenum result;
392
393
switch (texture->format) {
394
395
case SDL_PIXELFORMAT_INDEX1LSB:
case SDL_PIXELFORMAT_INDEX1MSB:
396
397
398
399
internalFormat = GL_RGB;
format = GL_COLOR_INDEX;
type = GL_BITMAP;
break;
400
case SDL_PIXELFORMAT_INDEX8:
401
402
403
404
405
if (!renderdata->GL_EXT_paletted_texture_supported) {
SDL_SetError("Unsupported texture format");
return -1;
}
internalFormat = GL_COLOR_INDEX8_EXT;
406
407
408
format = GL_COLOR_INDEX;
type = GL_UNSIGNED_BYTE;
break;
409
case SDL_PIXELFORMAT_RGB332:
410
411
412
413
internalFormat = GL_R3_G3_B2;
format = GL_RGB;
type = GL_UNSIGNED_BYTE_3_3_2;
break;
414
case SDL_PIXELFORMAT_RGB444:
415
416
417
418
internalFormat = GL_RGB4;
format = GL_RGB;
type = GL_UNSIGNED_SHORT_4_4_4_4;
break;
419
case SDL_PIXELFORMAT_RGB555:
420
421
422
423
internalFormat = GL_RGB5;
format = GL_RGB;
type = GL_UNSIGNED_SHORT_5_5_5_1;
break;
424
case SDL_PIXELFORMAT_ARGB4444:
425
426
427
428
internalFormat = GL_RGBA4;
format = GL_BGRA;
type = GL_UNSIGNED_SHORT_4_4_4_4_REV;
break;
429
case SDL_PIXELFORMAT_ARGB1555:
430
431
432
433
internalFormat = GL_RGB5_A1;
format = GL_BGRA;
type = GL_UNSIGNED_SHORT_1_5_5_5_REV;
break;
434
case SDL_PIXELFORMAT_RGB565:
435
436
437
438
internalFormat = GL_RGB8;
format = GL_RGB;
type = GL_UNSIGNED_SHORT_5_6_5;
break;
439
case SDL_PIXELFORMAT_RGB24:
440
441
442
443
internalFormat = GL_RGB8;
format = GL_RGB;
type = GL_UNSIGNED_BYTE;
break;
444
case SDL_PIXELFORMAT_RGB888:
445
internalFormat = GL_RGB8;
446
447
format = GL_BGRA;
type = GL_UNSIGNED_BYTE;
449
case SDL_PIXELFORMAT_BGR24:
450
451
452
453
internalFormat = GL_RGB8;
format = GL_BGR;
type = GL_UNSIGNED_BYTE;
break;
454
case SDL_PIXELFORMAT_BGR888:
455
internalFormat = GL_RGB8;
456
457
format = GL_RGBA;
type = GL_UNSIGNED_BYTE;
459
case SDL_PIXELFORMAT_ARGB8888:
460
461
internalFormat = GL_RGBA8;
format = GL_BGRA;
462
type = GL_UNSIGNED_BYTE;
464
case SDL_PIXELFORMAT_ABGR8888:
465
466
internalFormat = GL_RGBA8;
format = GL_RGBA;
467
type = GL_UNSIGNED_BYTE;
469
case SDL_PIXELFORMAT_ARGB2101010:
470
471
472
473
474
475
476
477
internalFormat = GL_RGB10_A2;
format = GL_BGRA;
type = GL_UNSIGNED_INT_2_10_10_10_REV;
break;
default:
SDL_SetError("Unsupported texture format");
return -1;
}
479
data = (GL_TextureData *) SDL_calloc(1, sizeof(*data));
480
481
482
483
484
if (!data) {
SDL_OutOfMemory();
return -1;
}
485
486
487
488
489
490
491
492
493
494
if (texture->format == SDL_PIXELFORMAT_INDEX8) {
data->palette = (Uint8 *) SDL_malloc(3 * 256 * sizeof(Uint8));
if (!data->palette) {
SDL_OutOfMemory();
SDL_free(data);
return -1;
}
SDL_memset(data->palette, 0xFF, 3 * 256 * sizeof(Uint8));
}
495
496
texture->driverdata = data;
497
498
renderdata->glGetError();
renderdata->glGenTextures(1, &data->texture);
499
500
501
502
503
504
505
506
507
508
509
510
511
if (renderdata->GL_ARB_texture_rectangle_supported) {
data->type = GL_TEXTURE_RECTANGLE_ARB;
texture_w = texture->w;
texture_h = texture->h;
data->texw = (GLfloat) texture->w;
data->texh = (GLfloat) texture->h;
} else {
data->type = GL_TEXTURE_2D;
texture_w = power_of_2(texture->w);
texture_h = power_of_2(texture->h);
data->texw = (GLfloat) texture->w / texture_w;
data->texh = (GLfloat) texture->h / texture_h;
}
512
513
data->format = format;
data->formattype = type;
514
515
516
517
renderdata->glBindTexture(data->type, data->texture);
renderdata->glTexImage2D(data->type, 0, internalFormat, texture_w,
texture_h, 0, format, type, NULL);
result = renderdata->glGetError();
518
519
520
521
if (result != GL_NO_ERROR) {
GL_SetError("glTexImage2D()", result);
return -1;
}
522
523
524
525
526
527
528
529
530
return 0;
}
static int
GL_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Color * colors, int firstcolor, int ncolors)
{
GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
531
Uint8 *palette;
533
534
535
536
537
538
539
540
541
542
543
544
545
546
if (!data->palette) {
SDL_SetError("Texture doesn't have a palette");
return -1;
}
palette = data->palette + firstcolor * 3;
while (ncolors--) {
*palette++ = colors->r;
*palette++ = colors->g;
*palette++ = colors->b;
++colors;
}
renderdata->glBindTexture(data->type, data->texture);
renderdata->glColorTableEXT(data->type, GL_RGB8, 256, GL_RGB,
GL_UNSIGNED_BYTE, data->palette);
547
548
549
550
551
552
553
return 0;
}
static int
GL_GetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
SDL_Color * colors, int firstcolor, int ncolors)
{
554
GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
555
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
556
Uint8 *palette;
558
559
560
561
562
563
564
565
566
567
568
569
if (!data->palette) {
SDL_SetError("Texture doesn't have a palette");
return -1;
}
palette = data->palette + firstcolor * 3;
while (ncolors--) {
colors->r = *palette++;
colors->g = *palette++;
colors->b = *palette++;
colors->unused = SDL_ALPHA_OPAQUE;
++colors;
}
570
571
572
return 0;
}
574
575
SetupTextureUpdate(GL_RenderData * renderdata, SDL_Texture * texture,
int pitch)
577
if (texture->format == SDL_PIXELFORMAT_INDEX1LSB) {
578
renderdata->glPixelStorei(GL_UNPACK_LSB_FIRST, 1);
579
} else if (texture->format == SDL_PIXELFORMAT_INDEX1MSB) {
580
renderdata->glPixelStorei(GL_UNPACK_LSB_FIRST, 0);
582
583
584
renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH,
pitch / SDL_BYTESPERPIXEL(texture->format));
587
588
589
static int
GL_SetTextureColorMod(SDL_Renderer * renderer, SDL_Texture * texture)
{
590
return 0;
591
592
593
594
595
}
static int
GL_SetTextureAlphaMod(SDL_Renderer * renderer, SDL_Texture * texture)
{
596
return 0;
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
}
static int
GL_SetTextureBlendMode(SDL_Renderer * renderer, SDL_Texture * texture)
{
switch (texture->blendMode) {
case SDL_TEXTUREBLENDMODE_NONE:
case SDL_TEXTUREBLENDMODE_MASK:
case SDL_TEXTUREBLENDMODE_BLEND:
case SDL_TEXTUREBLENDMODE_ADD:
case SDL_TEXTUREBLENDMODE_MOD:
return 0;
default:
SDL_Unsupported();
texture->blendMode = SDL_TEXTUREBLENDMODE_NONE;
return -1;
}
}
static int
GL_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture)
{
switch (texture->scaleMode) {
case SDL_TEXTURESCALEMODE_NONE:
case SDL_TEXTURESCALEMODE_FAST:
case SDL_TEXTURESCALEMODE_SLOW:
return 0;
case SDL_TEXTURESCALEMODE_BEST:
SDL_Unsupported();
texture->scaleMode = SDL_TEXTURESCALEMODE_SLOW;
return -1;
default:
SDL_Unsupported();
texture->scaleMode = SDL_TEXTURESCALEMODE_NONE;
return -1;
}
}
635
636
637
638
static int
GL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const void *pixels, int pitch)
{
639
GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
640
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
641
GLenum result;
643
644
645
646
647
648
649
renderdata->glGetError();
SetupTextureUpdate(renderdata, texture, pitch);
renderdata->glBindTexture(data->type, data->texture);
renderdata->glTexSubImage2D(data->type, 0, rect->x, rect->y, rect->w,
rect->h, data->format, data->formattype,
pixels);
result = renderdata->glGetError();
650
651
652
653
if (result != GL_NO_ERROR) {
GL_SetError("glTexSubImage2D()", result);
return -1;
}
654
655
656
657
658
659
660
661
662
663
return 0;
}
static int
GL_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, int markDirty, void **pixels,
int *pitch)
{
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
664
665
666
667
668
669
670
if (!data->pixels) {
data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
data->pixels = SDL_malloc(texture->h * data->pitch);
if (!data->pixels) {
SDL_OutOfMemory();
return -1;
}
673
674
if (markDirty) {
SDL_AddDirtyRect(&data->dirty, rect);
676
677
678
679
680
*pixels =
(void *) ((Uint8 *) data->pixels + rect->y * data->pitch +
rect->x * SDL_BYTESPERPIXEL(texture->format));
*pitch = data->pitch;
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
return 0;
}
static void
GL_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
}
static void
GL_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture, int numrects,
const SDL_Rect * rects)
{
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
int i;
for (i = 0; i < numrects; ++i) {
697
SDL_AddDirtyRect(&data->dirty, &rects[i]);
698
699
700
701
}
}
static int
702
703
GL_RenderFill(SDL_Renderer * renderer, Uint8 r, Uint8 g, Uint8 b, Uint8 a,
const SDL_Rect * rect)
704
705
706
707
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
708
709
data->glClearColor((GLclampf) r * inv255f, (GLclampf) g * inv255f,
(GLclampf) b * inv255f, (GLclampf) a * inv255f);
710
711
712
data->glViewport(rect->x, window->h - rect->y, rect->w, rect->h);
data->glClear(GL_COLOR_BUFFER_BIT);
data->glViewport(0, 0, window->w, window->h);
713
714
715
716
717
return 0;
}
static int
GL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
718
const SDL_Rect * srcrect, const SDL_Rect * dstrect)
719
720
721
722
723
724
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
GL_TextureData *texturedata = (GL_TextureData *) texture->driverdata;
int minx, miny, maxx, maxy;
GLfloat minu, maxu, minv, maxv;
725
726
727
728
729
730
if (texturedata->dirty.count > 0) {
SDL_DirtyRect *dirty;
void *pixels;
int bpp = SDL_BYTESPERPIXEL(texture->format);
int pitch = texturedata->pitch;
731
732
SetupTextureUpdate(data, texture, pitch);
data->glBindTexture(texturedata->type, texturedata->texture);
733
734
735
736
737
for (dirty = texturedata->dirty.list; dirty; dirty = dirty->next) {
SDL_Rect *rect = &dirty->rect;
pixels =
(void *) ((Uint8 *) texturedata->pixels + rect->y * pitch +
rect->x * bpp);
738
739
740
data->glTexSubImage2D(texturedata->type, 0, rect->x, rect->y,
rect->w, rect->h, texturedata->format,
texturedata->formattype, pixels);
741
742
743
744
}
SDL_ClearDirtyRects(&texturedata->dirty);
}
745
746
747
748
749
750
minx = dstrect->x;
miny = dstrect->y;
maxx = dstrect->x + dstrect->w;
maxy = dstrect->y + dstrect->h;
minu = (GLfloat) srcrect->x / texture->w;
751
minu *= texturedata->texw;
752
maxu = (GLfloat) (srcrect->x + srcrect->w) / texture->w;
753
maxu *= texturedata->texw;
754
minv = (GLfloat) srcrect->y / texture->h;
755
minv *= texturedata->texh;
756
maxv = (GLfloat) (srcrect->y + srcrect->h) / texture->h;
757
maxv *= texturedata->texh;
759
760
data->glBindTexture(texturedata->type, texturedata->texture);
761
762
763
764
765
766
767
768
769
770
771
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);
}
if (texture->blendMode != data->blendMode) {
switch (texture->blendMode) {
772
case SDL_TEXTUREBLENDMODE_NONE:
773
774
775
data->glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
data->glDisable(GL_BLEND);
break;
776
777
case SDL_TEXTUREBLENDMODE_MASK:
case SDL_TEXTUREBLENDMODE_BLEND:
778
779
780
781
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;
782
case SDL_TEXTUREBLENDMODE_ADD:
783
784
785
786
data->glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
data->glEnable(GL_BLEND);
data->glBlendFunc(GL_SRC_ALPHA, GL_ONE);
break;
787
case SDL_TEXTUREBLENDMODE_MOD:
788
789
790
791
792
data->glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
data->glEnable(GL_BLEND);
data->glBlendFunc(GL_ZERO, GL_SRC_COLOR);
break;
}
793
data->blendMode = texture->blendMode;
796
797
if (texture->scaleMode != data->scaleMode) {
switch (texture->scaleMode) {
798
799
case SDL_TEXTURESCALEMODE_NONE:
case SDL_TEXTURESCALEMODE_FAST:
800
801
802
803
804
data->glTexParameteri(texturedata->type, GL_TEXTURE_MIN_FILTER,
GL_NEAREST);
data->glTexParameteri(texturedata->type, GL_TEXTURE_MAG_FILTER,
GL_NEAREST);
break;
805
806
case SDL_TEXTURESCALEMODE_SLOW:
case SDL_TEXTURESCALEMODE_BEST:
807
808
809
810
811
812
data->glTexParameteri(texturedata->type, GL_TEXTURE_MIN_FILTER,
GL_LINEAR);
data->glTexParameteri(texturedata->type, GL_TEXTURE_MAG_FILTER,
GL_LINEAR);
break;
}
813
data->scaleMode = texture->scaleMode;
816
817
818
819
820
821
822
823
824
825
data->glBegin(GL_TRIANGLE_STRIP);
data->glTexCoord2f(minu, minv);
data->glVertex2i(minx, miny);
data->glTexCoord2f(maxu, minv);
data->glVertex2i(maxx, miny);
data->glTexCoord2f(minu, maxv);
data->glVertex2i(minx, maxy);
data->glTexCoord2f(maxu, maxv);
data->glVertex2i(maxx, maxy);
data->glEnd();
826
827
828
829
830
831
832
833
834
835
836
837
838
return 0;
}
static void
GL_RenderPresent(SDL_Renderer * renderer)
{
SDL_GL_SwapWindow(renderer->window);
}
static void
GL_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
839
GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
840
841
842
843
844
845
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
if (!data) {
return;
}
if (data->texture) {
846
renderdata->glDeleteTextures(1, &data->texture);
848
849
850
if (data->palette) {
SDL_free(data->palette);
}
851
852
if (data->pixels) {
SDL_free(data->pixels);
854
SDL_FreeDirtyRects(&data->dirty);
855
856
857
858
SDL_free(data);
texture->driverdata = NULL;
}
859
static void
860
861
862
863
864
GL_DestroyRenderer(SDL_Renderer * renderer)
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
if (data) {
865
866
867
if (data->context) {
SDL_GL_MakeCurrent(0, NULL);
SDL_GL_DeleteContext(data->context);
868
869
870
871
872
873
}
SDL_free(data);
}
SDL_free(renderer);
}
874
#endif /* SDL_VIDEO_RENDER_OGL */
875
876
/* vi: set ts=4 sw=4 expandtab: */