This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_renderer_gl.c
960 lines (871 loc) · 29.8 KB
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
35
36
#ifdef __MACOSX__
#include <OpenGL/OpenGL.h>
#endif
37
38
/* OpenGL renderer implementation */
39
40
41
42
/* 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
*/
43
44
static const float inv255f = 1.0f / 255.0f;
45
static SDL_Renderer *GL_CreateRenderer(SDL_Window * window, Uint32 flags);
46
static int GL_ActivateRenderer(SDL_Renderer * renderer);
47
static int GL_DisplayModeChanged(SDL_Renderer * renderer);
48
static int GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
49
50
51
static int GL_QueryTexturePixels(SDL_Renderer * renderer,
SDL_Texture * texture, void **pixels,
int *pitch);
52
53
54
55
56
57
58
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);
59
60
61
62
63
64
65
66
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);
67
68
69
70
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,
71
72
const SDL_Rect * rect, int markDirty, void **pixels,
int *pitch);
73
74
75
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);
76
77
static int GL_RenderFill(SDL_Renderer * renderer, Uint8 r, Uint8 g, Uint8 b,
Uint8 a, const SDL_Rect * rect);
78
static int GL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
79
const SDL_Rect * srcrect, const SDL_Rect * dstrect);
80
81
82
83
84
85
86
87
88
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",
89
90
(SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD |
SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_ACCELERATED),
91
92
(SDL_TEXTUREMODULATE_NONE | SDL_TEXTUREMODULATE_COLOR |
SDL_TEXTUREMODULATE_ALPHA),
93
94
95
96
97
(SDL_TEXTUREBLENDMODE_NONE | SDL_TEXTUREBLENDMODE_MASK |
SDL_TEXTUREBLENDMODE_BLEND | SDL_TEXTUREBLENDMODE_ADD |
SDL_TEXTUREBLENDMODE_MOD),
(SDL_TEXTURESCALEMODE_NONE | SDL_TEXTURESCALEMODE_FAST |
SDL_TEXTURESCALEMODE_SLOW),
98
16,
99
{
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
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},
116
117
118
119
120
121
122
0,
0}
};
typedef struct
{
SDL_GLContext context;
123
SDL_bool updateSize;
124
SDL_bool GL_ARB_texture_rectangle_supported;
125
SDL_bool GL_EXT_paletted_texture_supported;
126
127
128
129
130
131
132
int blendMode;
int scaleMode;
/* OpenGL functions */
#define SDL_PROC(ret,func,params) ret (APIENTRY *func) params;
#include "SDL_glfuncs.h"
#undef SDL_PROC
133
134
PFNGLCOLORTABLEEXTPROC glColorTableEXT;
135
136
void (*glTextureRangeAPPLE) (GLenum target, GLsizei length,
const GLvoid * pointer);
137
138
139
140
141
} GL_RenderData;
typedef struct
{
GLuint texture;
142
GLenum type;
143
144
GLfloat texw;
GLfloat texh;
145
146
GLenum format;
GLenum formattype;
147
Uint8 *palette;
148
149
void *pixels;
int pitch;
150
SDL_DirtyRectList dirty;
151
152
153
} GL_TextureData;
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
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);
}
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
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;
}
217
218
219
void
GL_AddRenderDriver(_THIS)
{
220
if (_this->GL_CreateContext) {
221
222
223
224
225
226
227
228
229
SDL_AddRenderDriver(0, &GL_RenderDriver);
}
}
SDL_Renderer *
GL_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_Renderer *renderer;
GL_RenderData *data;
230
GLint value;
231
int doublebuffer;
232
233
234
235
236
237
238
/* Render directly to the window, unless we're compositing */
#ifndef __MACOSX__
if (flags & SDL_RENDERER_SINGLEBUFFER) {
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 0);
}
#endif
239
if (!(window->flags & SDL_WINDOW_OPENGL)) {
240
if (SDL_RecreateWindow(window, window->flags | SDL_WINDOW_OPENGL) < 0) {
241
242
return NULL;
}
243
244
}
245
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
246
247
248
249
250
if (!renderer) {
SDL_OutOfMemory();
return NULL;
}
251
data = (GL_RenderData *) SDL_calloc(1, sizeof(*data));
252
253
254
255
256
257
if (!data) {
GL_DestroyRenderer(renderer);
SDL_OutOfMemory();
return NULL;
}
258
renderer->ActivateRenderer = GL_ActivateRenderer;
259
renderer->DisplayModeChanged = GL_DisplayModeChanged;
260
renderer->CreateTexture = GL_CreateTexture;
261
renderer->QueryTexturePixels = GL_QueryTexturePixels;
262
263
renderer->SetTexturePalette = GL_SetTexturePalette;
renderer->GetTexturePalette = GL_GetTexturePalette;
264
265
266
267
renderer->SetTextureColorMod = GL_SetTextureColorMod;
renderer->SetTextureAlphaMod = GL_SetTextureAlphaMod;
renderer->SetTextureBlendMode = GL_SetTextureBlendMode;
renderer->SetTextureScaleMode = GL_SetTextureScaleMode;
268
269
270
271
272
273
274
275
276
277
278
279
280
281
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 =
282
(SDL_RENDERER_PRESENTDISCARD | SDL_RENDERER_ACCELERATED);
283
284
285
286
287
288
if (GL_LoadFunctions(data) < 0) {
GL_DestroyRenderer(renderer);
return NULL;
}
289
290
291
292
293
294
295
296
297
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;
}
298
299
300
#ifdef __MACOSX__
/* Enable multi-threaded rendering */
/* Disabled until Ryan finishes his VBO/PBO code...
301
302
CGLEnable(CGLGetCurrentContext(), kCGLCEMPEngine);
*/
303
304
#endif
305
if (flags & SDL_RENDERER_PRESENTVSYNC) {
306
307
308
309
310
SDL_GL_SetSwapInterval(1);
} else {
SDL_GL_SetSwapInterval(0);
}
if (SDL_GL_GetSwapInterval() > 0) {
311
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
312
313
}
314
315
316
317
318
319
if (SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &doublebuffer) == 0) {
if (!doublebuffer) {
renderer->info.flags |= SDL_RENDERER_SINGLEBUFFER;
}
}
320
321
322
323
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;
324
325
326
327
328
if (SDL_GL_ExtensionSupported("GL_ARB_texture_rectangle")
|| SDL_GL_ExtensionSupported("GL_EXT_texture_rectangle")) {
data->GL_ARB_texture_rectangle_supported = SDL_TRUE;
}
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
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;
}
344
345
346
347
348
if (SDL_GL_ExtensionSupported("GL_APPLE_texture_range")) {
data->glTextureRangeAPPLE =
(void (*)(GLenum, GLsizei, const GLvoid *))
SDL_GL_GetProcAddress("glTextureRangeAPPLE");
}
349
350
/* Set up parameters for rendering */
351
352
353
354
data->blendMode = -1;
data->scaleMode = -1;
data->glDisable(GL_DEPTH_TEST);
data->glDisable(GL_CULL_FACE);
355
if (data->GL_ARB_texture_rectangle_supported) {
356
data->glEnable(GL_TEXTURE_RECTANGLE_ARB);
357
} else {
358
data->glEnable(GL_TEXTURE_2D);
359
}
360
data->updateSize = SDL_TRUE;
361
362
363
364
return renderer;
}
365
366
367
368
369
370
static int
GL_ActivateRenderer(SDL_Renderer * renderer)
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
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;
394
395
}
396
397
398
399
400
401
402
403
404
405
406
static __inline__ int
power_of_2(int input)
{
int value = 1;
while (value < input) {
value <<= 1;
}
return value;
}
407
408
409
410
411
412
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;
413
414
GLint internalFormat;
GLenum format, type;
415
int texture_w, texture_h;
416
GLenum result;
417
418
switch (texture->format) {
419
420
case SDL_PIXELFORMAT_INDEX1LSB:
case SDL_PIXELFORMAT_INDEX1MSB:
421
422
423
424
internalFormat = GL_RGB;
format = GL_COLOR_INDEX;
type = GL_BITMAP;
break;
425
case SDL_PIXELFORMAT_INDEX8:
426
427
428
429
430
if (!renderdata->GL_EXT_paletted_texture_supported) {
SDL_SetError("Unsupported texture format");
return -1;
}
internalFormat = GL_COLOR_INDEX8_EXT;
431
432
433
format = GL_COLOR_INDEX;
type = GL_UNSIGNED_BYTE;
break;
434
case SDL_PIXELFORMAT_RGB332:
435
436
437
438
internalFormat = GL_R3_G3_B2;
format = GL_RGB;
type = GL_UNSIGNED_BYTE_3_3_2;
break;
439
case SDL_PIXELFORMAT_RGB444:
440
441
442
443
internalFormat = GL_RGB4;
format = GL_RGB;
type = GL_UNSIGNED_SHORT_4_4_4_4;
break;
444
case SDL_PIXELFORMAT_RGB555:
445
446
447
448
internalFormat = GL_RGB5;
format = GL_RGB;
type = GL_UNSIGNED_SHORT_5_5_5_1;
break;
449
case SDL_PIXELFORMAT_ARGB4444:
450
451
452
453
internalFormat = GL_RGBA4;
format = GL_BGRA;
type = GL_UNSIGNED_SHORT_4_4_4_4_REV;
break;
454
case SDL_PIXELFORMAT_ARGB1555:
455
456
457
458
internalFormat = GL_RGB5_A1;
format = GL_BGRA;
type = GL_UNSIGNED_SHORT_1_5_5_5_REV;
break;
459
case SDL_PIXELFORMAT_RGB565:
460
461
462
463
internalFormat = GL_RGB8;
format = GL_RGB;
type = GL_UNSIGNED_SHORT_5_6_5;
break;
464
case SDL_PIXELFORMAT_RGB24:
465
466
467
468
internalFormat = GL_RGB8;
format = GL_RGB;
type = GL_UNSIGNED_BYTE;
break;
469
case SDL_PIXELFORMAT_RGB888:
470
internalFormat = GL_RGB8;
471
472
format = GL_BGRA;
type = GL_UNSIGNED_BYTE;
473
break;
474
case SDL_PIXELFORMAT_BGR24:
475
476
477
478
internalFormat = GL_RGB8;
format = GL_BGR;
type = GL_UNSIGNED_BYTE;
break;
479
case SDL_PIXELFORMAT_BGR888:
480
internalFormat = GL_RGB8;
481
482
format = GL_RGBA;
type = GL_UNSIGNED_BYTE;
483
break;
484
case SDL_PIXELFORMAT_ARGB8888:
485
486
487
488
489
#ifdef __MACOSX__
internalFormat = GL_RGBA;
format = GL_BGRA;
type = GL_UNSIGNED_INT_8_8_8_8_REV;
#else
490
491
internalFormat = GL_RGBA8;
format = GL_BGRA;
492
type = GL_UNSIGNED_BYTE;
493
#endif
494
break;
495
case SDL_PIXELFORMAT_ABGR8888:
496
497
internalFormat = GL_RGBA8;
format = GL_RGBA;
498
type = GL_UNSIGNED_BYTE;
499
break;
500
case SDL_PIXELFORMAT_ARGB2101010:
501
502
503
504
505
506
507
508
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;
}
509
510
data = (GL_TextureData *) SDL_calloc(1, sizeof(*data));
511
512
513
514
515
if (!data) {
SDL_OutOfMemory();
return -1;
}
516
517
518
519
520
521
522
523
524
525
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));
}
526
527
528
529
530
531
532
533
534
535
if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
data->pixels = SDL_malloc(texture->h * data->pitch);
if (!data->pixels) {
SDL_OutOfMemory();
SDL_free(data);
return -1;
}
}
536
537
texture->driverdata = data;
538
539
renderdata->glGetError();
renderdata->glGenTextures(1, &data->texture);
540
541
542
543
544
545
546
547
548
549
550
551
552
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;
}
553
554
data->format = format;
data->formattype = type;
555
renderdata->glBindTexture(data->type, data->texture);
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
renderdata->glTexParameteri(data->type, GL_TEXTURE_MIN_FILTER,
GL_NEAREST);
renderdata->glTexParameteri(data->type, GL_TEXTURE_MAG_FILTER,
GL_NEAREST);
renderdata->glTexParameteri(data->type, GL_TEXTURE_WRAP_S,
GL_CLAMP_TO_EDGE);
renderdata->glTexParameteri(data->type, GL_TEXTURE_WRAP_T,
GL_CLAMP_TO_EDGE);
#ifdef __MACOSX__
#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);
}
581
582
if (texture->access == SDL_TEXTUREACCESS_STREAMING
&& texture->format == SDL_PIXELFORMAT_ARGB8888) {
583
/*
584
585
586
587
588
589
if (renderdata->glTextureRangeAPPLE) {
renderdata->glTextureRangeAPPLE(data->type,
texture->h * data->pitch,
data->pixels);
}
*/
590
591
592
593
594
595
596
597
598
renderdata->glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
renderdata->glTexImage2D(data->type, 0, internalFormat, texture_w,
texture_h, 0, format, type, data->pixels);
} else
#endif
{
renderdata->glTexImage2D(data->type, 0, internalFormat, texture_w,
texture_h, 0, format, type, NULL);
}
599
result = renderdata->glGetError();
600
601
602
603
if (result != GL_NO_ERROR) {
GL_SetError("glTexImage2D()", result);
return -1;
}
604
605
606
return 0;
}
607
608
609
610
611
612
613
614
615
616
617
static int
GL_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture,
void **pixels, int *pitch)
{
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
*pixels = data->pixels;
*pitch = data->pitch;
return 0;
}
618
619
620
621
622
623
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;
624
Uint8 *palette;
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
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);
640
641
642
643
644
645
646
return 0;
}
static int
GL_GetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
SDL_Color * colors, int firstcolor, int ncolors)
{
647
GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
648
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
649
Uint8 *palette;
650
651
652
653
654
655
656
657
658
659
660
661
662
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;
}
663
664
665
return 0;
}
666
static void
667
668
SetupTextureUpdate(GL_RenderData * renderdata, SDL_Texture * texture,
int pitch)
669
{
670
if (texture->format == SDL_PIXELFORMAT_INDEX1LSB) {
671
renderdata->glPixelStorei(GL_UNPACK_LSB_FIRST, 1);
672
} else if (texture->format == SDL_PIXELFORMAT_INDEX1MSB) {
673
renderdata->glPixelStorei(GL_UNPACK_LSB_FIRST, 0);
674
}
675
676
677
renderdata->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
renderdata->glPixelStorei(GL_UNPACK_ROW_LENGTH,
pitch / SDL_BYTESPERPIXEL(texture->format));
678
679
}
680
681
682
static int
GL_SetTextureColorMod(SDL_Renderer * renderer, SDL_Texture * texture)
{
683
return 0;
684
685
686
687
688
}
static int
GL_SetTextureAlphaMod(SDL_Renderer * renderer, SDL_Texture * texture)
{
689
return 0;
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
}
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;
}
}
728
729
730
731
static int
GL_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const void *pixels, int pitch)
{
732
GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
733
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
734
GLenum result;
735
736
737
738
739
740
741
742
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();
743
744
745
746
if (result != GL_NO_ERROR) {
GL_SetError("glTexSubImage2D()", result);
return -1;
}
747
748
749
750
751
752
753
754
755
756
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;
757
758
if (markDirty) {
SDL_AddDirtyRect(&data->dirty, rect);
759
}
760
761
762
763
764
*pixels =
(void *) ((Uint8 *) data->pixels + rect->y * data->pitch +
rect->x * SDL_BYTESPERPIXEL(texture->format));
*pitch = data->pitch;
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
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) {
781
SDL_AddDirtyRect(&data->dirty, &rects[i]);
782
783
784
785
}
}
static int
786
787
GL_RenderFill(SDL_Renderer * renderer, Uint8 r, Uint8 g, Uint8 b, Uint8 a,
const SDL_Rect * rect)
788
789
790
791
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
792
793
data->glClearColor((GLclampf) r * inv255f, (GLclampf) g * inv255f,
(GLclampf) b * inv255f, (GLclampf) a * inv255f);
794
795
796
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);
797
798
799
800
801
return 0;
}
static int
GL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
802
const SDL_Rect * srcrect, const SDL_Rect * dstrect)
803
804
805
806
807
808
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
GL_TextureData *texturedata = (GL_TextureData *) texture->driverdata;
int minx, miny, maxx, maxy;
GLfloat minu, maxu, minv, maxv;
809
if (texturedata->dirty.list) {
810
811
812
813
814
SDL_DirtyRect *dirty;
void *pixels;
int bpp = SDL_BYTESPERPIXEL(texture->format);
int pitch = texturedata->pitch;
815
816
SetupTextureUpdate(data, texture, pitch);
data->glBindTexture(texturedata->type, texturedata->texture);
817
818
819
820
821
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);
822
823
824
data->glTexSubImage2D(texturedata->type, 0, rect->x, rect->y,
rect->w, rect->h, texturedata->format,
texturedata->formattype, pixels);
825
826
827
828
}
SDL_ClearDirtyRects(&texturedata->dirty);
}
829
830
831
832
833
834
minx = dstrect->x;
miny = dstrect->y;
maxx = dstrect->x + dstrect->w;
maxy = dstrect->y + dstrect->h;
minu = (GLfloat) srcrect->x / texture->w;
835
minu *= texturedata->texw;
836
maxu = (GLfloat) (srcrect->x + srcrect->w) / texture->w;
837
maxu *= texturedata->texw;
838
minv = (GLfloat) srcrect->y / texture->h;
839
minv *= texturedata->texh;
840
maxv = (GLfloat) (srcrect->y + srcrect->h) / texture->h;
841
maxv *= texturedata->texh;
842
843
844
data->glBindTexture(texturedata->type, texturedata->texture);
845
846
847
848
849
850
851
852
853
854
855
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) {
856
case SDL_TEXTUREBLENDMODE_NONE:
857
858
859
data->glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
data->glDisable(GL_BLEND);
break;
860
861
case SDL_TEXTUREBLENDMODE_MASK:
case SDL_TEXTUREBLENDMODE_BLEND:
862
863
864
865
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;
866
case SDL_TEXTUREBLENDMODE_ADD:
867
868
869
870
data->glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
data->glEnable(GL_BLEND);
data->glBlendFunc(GL_SRC_ALPHA, GL_ONE);
break;
871
case SDL_TEXTUREBLENDMODE_MOD:
872
873
874
875
876
data->glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
data->glEnable(GL_BLEND);
data->glBlendFunc(GL_ZERO, GL_SRC_COLOR);
break;
}
877
data->blendMode = texture->blendMode;
878
879
}
880
881
if (texture->scaleMode != data->scaleMode) {
switch (texture->scaleMode) {
882
883
case SDL_TEXTURESCALEMODE_NONE:
case SDL_TEXTURESCALEMODE_FAST:
884
885
886
887
888
data->glTexParameteri(texturedata->type, GL_TEXTURE_MIN_FILTER,
GL_NEAREST);
data->glTexParameteri(texturedata->type, GL_TEXTURE_MAG_FILTER,
GL_NEAREST);
break;
889
890
case SDL_TEXTURESCALEMODE_SLOW:
case SDL_TEXTURESCALEMODE_BEST:
891
892
893
894
895
896
data->glTexParameteri(texturedata->type, GL_TEXTURE_MIN_FILTER,
GL_LINEAR);
data->glTexParameteri(texturedata->type, GL_TEXTURE_MAG_FILTER,
GL_LINEAR);
break;
}
897
data->scaleMode = texture->scaleMode;
898
899
}
900
901
902
903
904
905
906
907
908
909
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();
910
911
912
913
914
915
916
917
918
919
920
921
922
return 0;
}
static void
GL_RenderPresent(SDL_Renderer * renderer)
{
SDL_GL_SwapWindow(renderer->window);
}
static void
GL_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
923
GL_RenderData *renderdata = (GL_RenderData *) renderer->driverdata;
924
925
926
927
928
929
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
if (!data) {
return;
}
if (data->texture) {
930
renderdata->glDeleteTextures(1, &data->texture);
931
}
932
933
934
if (data->palette) {
SDL_free(data->palette);
}
935
936
if (data->pixels) {
SDL_free(data->pixels);
937
}
938
SDL_FreeDirtyRects(&data->dirty);
939
940
941
942
SDL_free(data);
texture->driverdata = NULL;
}
943
static void
944
945
946
947
948
GL_DestroyRenderer(SDL_Renderer * renderer)
{
GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
if (data) {
949
if (data->context) {
950
/* SDL_GL_MakeCurrent(0, NULL); *//* doesn't do anything */
951
SDL_GL_DeleteContext(data->context);
952
953
954
955
956
957
}
SDL_free(data);
}
SDL_free(renderer);
}
958
#endif /* SDL_VIDEO_RENDER_OGL */
959
960
/* vi: set ts=4 sw=4 expandtab: */