Mercurial > sdl-ios-xcode

comparison src/video/ataricommon/SDL_atarigl.c @ 991:12b13601a544

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Final touches to OSMesa OpenGL support on Atari, using loadable libraries. Hope SDL 1.2.8 is out soon.
author Patrice Mandin <patmandin@gmail.com>
date Fri, 26 Nov 2004 16:16:50 +0000
parents 475166d13b44
children 0324ce32b2d9
comparison
equal deleted inserted replaced
990:8e20c48a9c13 991:12b13601a544
22 22
23 /* Atari OSMesa.ldg implementation of SDL OpenGL support */ 23 /* Atari OSMesa.ldg implementation of SDL OpenGL support */
24 24
25 /*--- Includes ---*/ 25 /*--- Includes ---*/
26 26
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
27 #ifdef HAVE_OPENGL 30 #ifdef HAVE_OPENGL
28 #include <GL/osmesa.h> 31 #include <GL/osmesa.h>
29 #endif 32 #endif
33
34 #include <mint/osbind.h>
30 35
31 #include "SDL_video.h" 36 #include "SDL_video.h"
32 #include "SDL_error.h" 37 #include "SDL_error.h"
33 #include "SDL_endian.h" 38 #include "SDL_endian.h"
34 #include "SDL_atarigl_c.h" 39 #include "SDL_atarigl_c.h"
35 40 #ifdef ENABLE_OSMESA_SHARED
36 /*--- Variables ---*/ 41 #include "SDL_loadso.h"
42 #endif
43
44 /*--- Defines ---*/
45
46 #define PATH_OSMESA_LDG "osmesa.ldg"
47 #define PATH_MESAGL_LDG "mesa_gl.ldg"
48 #define PATH_TINYGL_LDG "tiny_gl.ldg"
37 49
38 /*--- Functions prototypes ---*/ 50 /*--- Functions prototypes ---*/
39 51
40 static void ConvertNull(SDL_Surface *surface); 52 static void SDL_AtariGL_UnloadLibrary(_THIS);
41 static void Convert565To555be(SDL_Surface *surface); 53
42 static void Convert565To555le(SDL_Surface *surface); 54 static void CopyShadowNull(_THIS, SDL_Surface *surface);
43 static void Convert565le(SDL_Surface *surface); 55 static void CopyShadowDirect(_THIS, SDL_Surface *surface);
44 static void ConvertBGRAToABGR(SDL_Surface *surface); 56 static void CopyShadow8888To555(_THIS, SDL_Surface *surface);
57 static void CopyShadow8888To565(_THIS, SDL_Surface *surface);
58
59 static void ConvertNull(_THIS, SDL_Surface *surface);
60 static void Convert565To555be(_THIS, SDL_Surface *surface);
61 static void Convert565To555le(_THIS, SDL_Surface *surface);
62 static void Convert565le(_THIS, SDL_Surface *surface);
63 static void ConvertBGRAToABGR(_THIS, SDL_Surface *surface);
64
65 static int InitNew(_THIS, SDL_Surface *current);
66 static int InitOld(_THIS, SDL_Surface *current);
45 67
46 /*--- Public functions ---*/ 68 /*--- Public functions ---*/
47 69
48 int SDL_AtariGL_Init(_THIS, SDL_Surface *current) 70 int SDL_AtariGL_Init(_THIS, SDL_Surface *current)
49 { 71 {
50 #ifdef HAVE_OPENGL 72 #ifdef HAVE_OPENGL
73 if (gl_oldmesa) {
74 gl_active = InitOld(this, current);
75 } else {
76 gl_active = InitNew(this, current);
77 }
78 #endif
79
80 return (gl_active);
81 }
82
83 void SDL_AtariGL_Quit(_THIS)
84 {
85 #ifdef HAVE_OPENGL
86 if (!gl_active) {
87 return;
88 }
89
90 if (gl_oldmesa) {
91 /* Old mesa implementations */
92 if (this->gl_data->OSMesaDestroyLDG) {
93 this->gl_data->OSMesaDestroyLDG();
94 }
95 if (gl_shadow) {
96 Mfree(gl_shadow);
97 gl_shadow = NULL;
98 }
99 } else {
100 /* New mesa implementation */
101 if (gl_ctx) {
102 if (this->gl_data->OSMesaDestroyContext) {
103 this->gl_data->OSMesaDestroyContext(gl_ctx);
104 }
105 gl_ctx = NULL;
106 }
107 }
108
109 SDL_AtariGL_UnloadLibrary(this);
110
111 #endif /* HAVE_OPENGL */
112 gl_active = 0;
113 }
114
115 int SDL_AtariGL_LoadLibrary(_THIS, const char *path)
116 {
117 #ifdef HAVE_OPENGL
118
119 #ifdef ENABLE_OSMESA_SHARED
120 void *handle;
121
122 if (gl_active) {
123 SDL_SetError("OpenGL context already created");
124 return -1;
125 }
126
127 /* Unload previous driver */
128 SDL_AtariGL_UnloadLibrary(this);
129
130 /* Load library given by path */
131 handle = SDL_LoadObject(path);
132 if (handle == NULL) {
133 /* Try to load another one */
134 path = getenv("SDL_VIDEO_GL_DRIVER");
135 if ( path != NULL ) {
136 handle = SDL_LoadObject(path);
137 }
138
139 /* If it does not work, try some other */
140 if (handle == NULL) {
141 path = PATH_OSMESA_LDG;
142 handle = SDL_LoadObject(path);
143 }
144
145 if (handle == NULL) {
146 path = PATH_MESAGL_LDG;
147 handle = SDL_LoadObject(path);
148 }
149
150 if (handle == NULL) {
151 path = PATH_TINYGL_LDG;
152 handle = SDL_LoadObject(path);
153 }
154 }
155
156 if (handle == NULL) {
157 SDL_SetError("Could not load OpenGL library");
158 return -1;
159 }
160
161 /* Load functions pointers (osmesa.ldg) */
162 this->gl_data->OSMesaCreateContextExt = SDL_LoadFunction(handle, "OSMesaCreateContextExt");
163 this->gl_data->OSMesaDestroyContext = SDL_LoadFunction(handle, "OSMesaDestroyContext");
164 this->gl_data->OSMesaMakeCurrent = SDL_LoadFunction(handle, "OSMesaMakeCurrent");
165 this->gl_data->OSMesaPixelStore = SDL_LoadFunction(handle, "OSMesaPixelStore");
166 this->gl_data->OSMesaGetProcAddress = SDL_LoadFunction(handle, "OSMesaGetProcAddress");
167 this->gl_data->glGetIntegerv = SDL_LoadFunction(handle, "glGetIntegerv");
168
169 /* Load old functions pointers (mesa_gl.ldg, tiny_gl.ldg) */
170 this->gl_data->OSMesaCreateLDG = SDL_LoadFunction(handle, "OSMesaCreateLDG");
171 this->gl_data->OSMesaDestroyLDG = SDL_LoadFunction(handle, "OSMesaDestroyLDG");
172
173 gl_oldmesa = 0;
174
175 if ( (this->gl_data->OSMesaCreateContextExt == NULL) ||
176 (this->gl_data->OSMesaDestroyContext == NULL) ||
177 (this->gl_data->OSMesaMakeCurrent == NULL) ||
178 (this->gl_data->OSMesaPixelStore == NULL) ||
179 (this->gl_data->glGetIntegerv == NULL) ||
180 (this->gl_data->OSMesaGetProcAddress == NULL)) {
181 /* Hum, maybe old library ? */
182 if ( (this->gl_data->OSMesaCreateLDG == NULL) ||
183 (this->gl_data->OSMesaDestroyLDG == NULL)) {
184 SDL_SetError("Could not retrieve OpenGL functions");
185 return -1;
186 } else {
187 gl_oldmesa = 1;
188 }
189 }
190
191 this->gl_config.dll_handle = handle;
192 if ( path ) {
193 strncpy(this->gl_config.driver_path, path,
194 sizeof(this->gl_config.driver_path)-1);
195 } else {
196 strcpy(this->gl_config.driver_path, "");
197 }
198
199 #endif
200 this->gl_config.driver_loaded = 1;
201
202 return 0;
203 #else
204 return -1;
205 #endif
206 }
207
208 void *SDL_AtariGL_GetProcAddress(_THIS, const char *proc)
209 {
210 void *func = NULL;
211 #ifdef HAVE_OPENGL
212
213 if (this->gl_config.dll_handle) {
214 func = SDL_LoadFunction(this->gl_config.dll_handle, (void *)proc);
215 } else if (this->gl_data->OSMesaGetProcAddress) {
216 func = this->gl_data->OSMesaGetProcAddress(proc);
217 }
218
219 #endif
220 return func;
221 }
222
223 int SDL_AtariGL_GetAttribute(_THIS, SDL_GLattr attrib, int* value)
224 {
225 #ifdef HAVE_OPENGL
226 GLenum mesa_attrib;
227 SDL_Surface *surface;
228
229 if (this->gl_config.dll_handle) {
230 if (this->gl_data->glGetIntegerv == NULL) {
231 return -1;
232 }
233 }
234
235 if (!gl_active) {
236 return -1;
237 }
238
239 switch(attrib) {
240 case SDL_GL_RED_SIZE:
241 mesa_attrib = GL_RED_BITS;
242 break;
243 case SDL_GL_GREEN_SIZE:
244 mesa_attrib = GL_GREEN_BITS;
245 break;
246 case SDL_GL_BLUE_SIZE:
247 mesa_attrib = GL_BLUE_BITS;
248 break;
249 case SDL_GL_ALPHA_SIZE:
250 mesa_attrib = GL_ALPHA_BITS;
251 break;
252 case SDL_GL_DOUBLEBUFFER:
253 surface = this->screen;
254 *value = ((surface->flags & SDL_DOUBLEBUF)==SDL_DOUBLEBUF);
255 return 0;
256 case SDL_GL_DEPTH_SIZE:
257 mesa_attrib = GL_DEPTH_BITS;
258 break;
259 case SDL_GL_STENCIL_SIZE:
260 mesa_attrib = GL_STENCIL_BITS;
261 break;
262 case SDL_GL_ACCUM_RED_SIZE:
263 mesa_attrib = GL_ACCUM_RED_BITS;
264 break;
265 case SDL_GL_ACCUM_GREEN_SIZE:
266 mesa_attrib = GL_ACCUM_GREEN_BITS;
267 break;
268 case SDL_GL_ACCUM_BLUE_SIZE:
269 mesa_attrib = GL_ACCUM_BLUE_BITS;
270 break;
271 case SDL_GL_ACCUM_ALPHA_SIZE:
272 mesa_attrib = GL_ACCUM_ALPHA_BITS;
273 break;
274 default :
275 return -1;
276 }
277
278 this->gl_data->glGetIntegerv(mesa_attrib, value);
279 return 0;
280 #else
281 return -1;
282 #endif
283 }
284
285 int SDL_AtariGL_MakeCurrent(_THIS)
286 {
287 #ifdef HAVE_OPENGL
288 SDL_Surface *surface;
289 GLenum type;
290
291 if (gl_oldmesa && gl_active) {
292 return 0;
293 }
294
295 if (this->gl_config.dll_handle) {
296 if ((this->gl_data->OSMesaMakeCurrent == NULL) ||
297 (this->gl_data->OSMesaPixelStore == NULL)) {
298 return -1;
299 }
300 }
301
302 if (!gl_active) {
303 SDL_SetError("Invalid OpenGL context");
304 return -1;
305 }
306
307 surface = this->screen;
308
309 if ((surface->format->BitsPerPixel == 15) || (surface->format->BitsPerPixel == 16)) {
310 type = GL_UNSIGNED_SHORT_5_6_5;
311 } else {
312 type = GL_UNSIGNED_BYTE;
313 }
314
315 if (!(this->gl_data->OSMesaMakeCurrent(gl_ctx, surface->pixels, type, surface->w, surface->h))) {
316 SDL_SetError("Can not make OpenGL context current");
317 return -1;
318 }
319
320 /* OSMesa draws upside down */
321 this->gl_data->OSMesaPixelStore(OSMESA_Y_UP, 0);
322
323 return 0;
324 #else
325 return -1;
326 #endif
327 }
328
329 void SDL_AtariGL_SwapBuffers(_THIS)
330 {
331 #ifdef HAVE_OPENGL
332 if (gl_active) {
333 gl_copyshadow(this, this->screen);
334 gl_convert(this, this->screen);
335 }
336 #endif
337 }
338
339 void SDL_AtariGL_InitPointers(_THIS)
340 {
341 #if defined(HAVE_OPENGL)
342 this->gl_data->OSMesaCreateContextExt = OSMesaCreateContextExt;
343 this->gl_data->OSMesaDestroyContext = OSMesaDestroyContext;
344 this->gl_data->OSMesaMakeCurrent = OSMesaMakeCurrent;
345 this->gl_data->OSMesaPixelStore = OSMesaPixelStore;
346 this->gl_data->OSMesaGetProcAddress = OSMesaGetProcAddress;
347 this->gl_data->glGetIntegerv = glGetIntegerv;
348 #endif
349 }
350
351 /*--- Private functions ---*/
352
353 static void SDL_AtariGL_UnloadLibrary(_THIS)
354 {
355 #if defined(HAVE_OPENGL)
356 if (this->gl_config.dll_handle) {
357 SDL_UnloadObject(this->gl_config.dll_handle);
358 this->gl_config.dll_handle = NULL;
359
360 /* Restore pointers to static library */
361 this->gl_data->OSMesaCreateContextExt = OSMesaCreateContextExt;
362 this->gl_data->OSMesaDestroyContext = OSMesaDestroyContext;
363 this->gl_data->OSMesaMakeCurrent = OSMesaMakeCurrent;
364 this->gl_data->OSMesaPixelStore = OSMesaPixelStore;
365 this->gl_data->OSMesaGetProcAddress = OSMesaGetProcAddress;
366 this->gl_data->glGetIntegerv = glGetIntegerv;
367
368 this->gl_data->OSMesaCreateLDG = NULL;
369 this->gl_data->OSMesaDestroyLDG = NULL;
370 }
371 #endif
372 }
373
374 /*--- Creation of an OpenGL context using new/old functions ---*/
375
376 static int InitNew(_THIS, SDL_Surface *current)
377 {
51 GLenum osmesa_format; 378 GLenum osmesa_format;
52 SDL_PixelFormat *pixel_format; 379 SDL_PixelFormat *pixel_format;
53 Uint32 redmask; 380 Uint32 redmask;
54 381
55 SDL_AtariGL_Quit(this); /* Destroy previous context if exist */ 382 if (this->gl_config.dll_handle) {
383 if (this->gl_data->OSMesaCreateContextExt == NULL) {
384 return 0;
385 }
386 }
56 387
57 /* Init OpenGL context using OSMesa */ 388 /* Init OpenGL context using OSMesa */
58 gl_convert = ConvertNull; 389 gl_convert = ConvertNull;
390 gl_copyshadow = CopyShadowNull;
59 391
60 pixel_format = current->format; 392 pixel_format = current->format;
61 redmask = pixel_format->Rmask; 393 redmask = pixel_format->Rmask;
62 switch (pixel_format->BitsPerPixel) { 394 switch (pixel_format->BitsPerPixel) {
63 case 15: 395 case 15:
64 /* 1555, big and little endian, unsupported */ 396 /* 1555, big and little endian, unsupported */
397 gl_pixelsize = 2;
65 osmesa_format = OSMESA_RGB_565; 398 osmesa_format = OSMESA_RGB_565;
66 if (redmask == 31<<10) { 399 if (redmask == 31<<10) {
67 gl_convert = Convert565To555be; 400 gl_convert = Convert565To555be;
68 } else { 401 } else {
69 gl_convert = Convert565To555le; 402 gl_convert = Convert565To555le;
70 } 403 }
71 break; 404 break;
72 case 16: 405 case 16:
406 gl_pixelsize = 2;
73 if (redmask == 31<<11) { 407 if (redmask == 31<<11) {
74 osmesa_format = OSMESA_RGB_565; 408 osmesa_format = OSMESA_RGB_565;
75 } else { 409 } else {
76 /* 565, little endian, unsupported */ 410 /* 565, little endian, unsupported */
77 osmesa_format = OSMESA_RGB_565; 411 osmesa_format = OSMESA_RGB_565;
78 gl_convert = Convert565le; 412 gl_convert = Convert565le;
79 } 413 }
80 break; 414 break;
81 case 24: 415 case 24:
416 gl_pixelsize = 3;
82 if (redmask == 255<<16) { 417 if (redmask == 255<<16) {
83 osmesa_format = OSMESA_RGB; 418 osmesa_format = OSMESA_RGB;
84 } else { 419 } else {
85 osmesa_format = OSMESA_BGR; 420 osmesa_format = OSMESA_BGR;
86 } 421 }
87 break; 422 break;
88 case 32: 423 case 32:
424 gl_pixelsize = 4;
89 if (redmask == 255<<16) { 425 if (redmask == 255<<16) {
90 osmesa_format = OSMESA_ARGB; 426 osmesa_format = OSMESA_ARGB;
91 } else if (redmask == 255<<8) { 427 } else if (redmask == 255<<8) {
92 osmesa_format = OSMESA_BGRA; 428 osmesa_format = OSMESA_BGRA;
93 } else if (redmask == 255<<24) { 429 } else if (redmask == 255<<24) {
97 osmesa_format = OSMESA_BGRA; 433 osmesa_format = OSMESA_BGRA;
98 gl_convert = ConvertBGRAToABGR; 434 gl_convert = ConvertBGRAToABGR;
99 } 435 }
100 break; 436 break;
101 default: 437 default:
438 gl_pixelsize = 1;
102 osmesa_format = OSMESA_COLOR_INDEX; 439 osmesa_format = OSMESA_COLOR_INDEX;
103 break; 440 break;
104 } 441 }
105 442
106 gl_ctx = OSMesaCreateContextExt( osmesa_format, this->gl_config.depth_size, 443 gl_ctx = this->gl_data->OSMesaCreateContextExt(
444 osmesa_format, this->gl_config.depth_size,
107 this->gl_config.stencil_size, this->gl_config.accum_red_size + 445 this->gl_config.stencil_size, this->gl_config.accum_red_size +
108 this->gl_config.accum_green_size + this->gl_config.accum_blue_size + 446 this->gl_config.accum_green_size + this->gl_config.accum_blue_size +
109 this->gl_config.accum_alpha_size, NULL ); 447 this->gl_config.accum_alpha_size, NULL );
110 448
111 gl_active = (gl_ctx != NULL); 449 return (gl_ctx != NULL);
112 return (gl_active); 450 }
113 #else 451
114 return 0; 452 static int InitOld(_THIS, SDL_Surface *current)
115 #endif 453 {
116 } 454 GLenum osmesa_format;
117 455 SDL_PixelFormat *pixel_format;
118 void SDL_AtariGL_Quit(_THIS) 456 Uint32 redmask;
119 { 457
120 #ifdef HAVE_OPENGL 458 if (this->gl_config.dll_handle) {
121 /* Shutdown OpenGL context */ 459 if (this->gl_data->OSMesaCreateLDG == NULL) {
122 if (gl_ctx) {
123 OSMesaDestroyContext(gl_ctx);
124 gl_ctx = NULL;
125 }
126 #endif
127 gl_active = 0;
128 }
129
130 int SDL_AtariGL_LoadLibrary(_THIS, const char *path)
131 {
132 #ifdef HAVE_OPENGL
133 /* Library is always opened */
134 this->gl_config.driver_loaded = 1;
135 #endif
136 return 0;
137 }
138
139 void *SDL_AtariGL_GetProcAddress(_THIS, const char *proc)
140 {
141 void *func = NULL;
142 #ifdef HAVE_OPENGL
143 if (gl_ctx != NULL) {
144 func = OSMesaGetProcAddress(proc);
145 }
146 #endif
147 return func;
148 }
149
150 int SDL_AtariGL_GetAttribute(_THIS, SDL_GLattr attrib, int* value)
151 {
152 #ifdef HAVE_OPENGL
153 GLenum mesa_attrib;
154 SDL_Surface *surface;
155
156 if (gl_ctx == NULL) {
157 return -1;
158 }
159
160 switch(attrib) {
161 case SDL_GL_RED_SIZE:
162 mesa_attrib = GL_RED_BITS;
163 break;
164 case SDL_GL_GREEN_SIZE:
165 mesa_attrib = GL_GREEN_BITS;
166 break;
167 case SDL_GL_BLUE_SIZE:
168 mesa_attrib = GL_BLUE_BITS;
169 break;
170 case SDL_GL_ALPHA_SIZE:
171 mesa_attrib = GL_ALPHA_BITS;
172 break;
173 case SDL_GL_DOUBLEBUFFER:
174 surface = this->screen;
175 *value = ((surface->flags & SDL_DOUBLEBUF)==SDL_DOUBLEBUF);
176 return 0; 460 return 0;
177 case SDL_GL_DEPTH_SIZE: 461 }
178 mesa_attrib = GL_DEPTH_BITS; 462 }
179 break; 463
180 case SDL_GL_STENCIL_SIZE: 464 /* Init OpenGL context using OSMesa */
181 mesa_attrib = GL_STENCIL_BITS; 465 gl_convert = ConvertNull;
182 break; 466 gl_copyshadow = CopyShadowNull;
183 case SDL_GL_ACCUM_RED_SIZE: 467
184 mesa_attrib = GL_ACCUM_RED_BITS; 468 pixel_format = current->format;
185 break; 469 redmask = pixel_format->Rmask;
186 case SDL_GL_ACCUM_GREEN_SIZE: 470 switch (pixel_format->BitsPerPixel) {
187 mesa_attrib = GL_ACCUM_GREEN_BITS; 471 case 15:
188 break; 472 /* 15 bits unsupported */
189 case SDL_GL_ACCUM_BLUE_SIZE: 473 gl_pixelsize = 2;
190 mesa_attrib = GL_ACCUM_BLUE_BITS; 474 osmesa_format = OSMESA_ARGB;
191 break; 475 if (redmask == 31<<10) {
192 case SDL_GL_ACCUM_ALPHA_SIZE: 476 gl_copyshadow = CopyShadow8888To555;
193 mesa_attrib = GL_ACCUM_ALPHA_BITS; 477 } else {
194 break; 478 gl_copyshadow = CopyShadow8888To565;
195 default : 479 gl_convert = Convert565To555le;
196 return -1; 480 }
197 } 481 break;
198 482 case 16:
199 glGetIntegerv(mesa_attrib, value); 483 /* 16 bits unsupported */
200 return 0; 484 gl_pixelsize = 2;
201 #else 485 osmesa_format = OSMESA_ARGB;
202 return -1; 486 gl_copyshadow = CopyShadow8888To565;
203 #endif 487 if (redmask != 31<<11) {
204 } 488 /* 565, little endian, unsupported */
205 489 gl_convert = Convert565le;
206 int SDL_AtariGL_MakeCurrent(_THIS) 490 }
207 { 491 break;
208 #ifdef HAVE_OPENGL 492 case 24:
209 SDL_Surface *surface; 493 gl_pixelsize = 3;
210 GLenum type; 494 gl_copyshadow = CopyShadowDirect;
211 495 if (redmask == 255<<16) {
212 if (gl_ctx == NULL) { 496 osmesa_format = OSMESA_RGB;
213 SDL_SetError("Invalid OpenGL context"); 497 } else {
214 return -1; 498 osmesa_format = OSMESA_BGR;
215 } 499 }
216 500 break;
217 surface = this->screen; 501 case 32:
218 502 gl_pixelsize = 4;
219 if ((surface->format->BitsPerPixel == 15) || (surface->format->BitsPerPixel == 16)) { 503 gl_copyshadow = CopyShadowDirect;
220 type = GL_UNSIGNED_SHORT_5_6_5; 504 if (redmask == 255<<16) {
221 } else { 505 osmesa_format = OSMESA_ARGB;
222 type = GL_UNSIGNED_BYTE; 506 } else if (redmask == 255<<8) {
223 } 507 osmesa_format = OSMESA_BGRA;
224 508 } else if (redmask == 255<<24) {
225 if (!OSMesaMakeCurrent(gl_ctx, surface->pixels, type, surface->w, surface->h)) { 509 osmesa_format = OSMESA_RGBA;
226 SDL_SetError("Can not make OpenGL context current"); 510 } else {
227 return -1; 511 /* ABGR format unsupported */
228 } 512 osmesa_format = OSMESA_BGRA;
229 513 gl_convert = ConvertBGRAToABGR;
230 /* OSMesa draws upside down */ 514 }
231 OSMesaPixelStore(OSMESA_Y_UP, 0); 515 break;
232 516 default:
233 return 0; 517 gl_pixelsize = 1;
234 #else 518 gl_copyshadow = CopyShadowDirect;
235 return -1; 519 osmesa_format = OSMESA_COLOR_INDEX;
236 #endif 520 break;
237 } 521 }
238 522
239 void SDL_AtariGL_SwapBuffers(_THIS) 523 gl_shadow = this->gl_data->OSMesaCreateLDG(
240 { 524 osmesa_format, GL_UNSIGNED_BYTE, current->w, current->h
241 #ifdef HAVE_OPENGL 525 );
242 if (gl_ctx == NULL) { 526
243 return; 527 return (gl_shadow != NULL);
244 } 528 }
245 529
246 gl_convert(this->screen); 530 /*--- Conversions routines from shadow buffer to the screen ---*/
247 #endif 531
248 } 532 static void CopyShadowNull(_THIS, SDL_Surface *surface)
249 533 {
250 /*--- Private functions ---*/ 534 }
251 535
252 static void ConvertNull(SDL_Surface *surface) 536 static void CopyShadowDirect(_THIS, SDL_Surface *surface)
253 { 537 {
254 } 538 int y, srcpitch, dstpitch;
255 539 Uint8 *srcline, *dstline;
256 static void Convert565To555be(SDL_Surface *surface) 540
541 srcline = gl_shadow;
542 srcpitch = surface->w * gl_pixelsize;
543 dstline = surface->pixels;
544 dstpitch = surface->pitch;
545
546 for (y=0; y<surface->h; y++) {
547 memcpy(dstline, srcline, srcpitch);
548
549 srcline += srcpitch;
550 dstline += dstpitch;
551 }
552 }
553
554 static void CopyShadow8888To555(_THIS, SDL_Surface *surface)
555 {
556 int x,y, srcpitch, dstpitch;
557 Uint16 *dstline, *dstcol;
558 Uint32 *srcline, *srccol;
559
560 srcline = (Uint32 *)gl_shadow;
561 srcpitch = surface->w;
562 dstline = surface->pixels;
563 dstpitch = surface->pitch >>1;
564
565 for (y=0; y<surface->h; y++) {
566 srccol = srcline;
567 dstcol = dstline;
568 for (x=0; x<surface->w; x++) {
569 Uint32 srccolor;
570 Uint16 dstcolor;
571
572 srccolor = *srccol++;
573 dstcolor = (srccolor>>9) & (31<<10);
574 dstcolor |= (srccolor>>6) & (31<<5);
575 dstcolor |= (srccolor>>3) & 31;
576 *dstcol++ = dstcolor;
577 }
578
579 srcline += srcpitch;
580 dstline += dstpitch;
581 }
582 }
583
584 static void CopyShadow8888To565(_THIS, SDL_Surface *surface)
585 {
586 int x,y, srcpitch, dstpitch;
587 Uint16 *dstline, *dstcol;
588 Uint32 *srcline, *srccol;
589
590 srcline = (Uint32 *)gl_shadow;
591 srcpitch = surface->w;
592 dstline = surface->pixels;
593 dstpitch = surface->pitch >>1;
594
595 for (y=0; y<surface->h; y++) {
596 srccol = srcline;
597 dstcol = dstline;
598
599 for (x=0; x<surface->w; x++) {
600 Uint32 srccolor;
601 Uint16 dstcolor;
602
603 srccolor = *srccol++;
604 dstcolor = (srccolor>>8) & (31<<11);
605 dstcolor |= (srccolor>>5) & (63<<5);
606 dstcolor |= (srccolor>>3) & 31;
607 *dstcol++ = dstcolor;
608 }
609
610 srcline += srcpitch;
611 dstline += dstpitch;
612 }
613 }
614
615 /*--- Conversions routines in the screen ---*/
616
617 static void ConvertNull(_THIS, SDL_Surface *surface)
618 {
619 }
620
621 static void Convert565To555be(_THIS, SDL_Surface *surface)
257 { 622 {
258 int x,y, pitch; 623 int x,y, pitch;
259 unsigned short *line, *pixel; 624 unsigned short *line, *pixel;
260 625
261 line = surface->pixels; 626 line = surface->pixels;
270 635
271 line += pitch; 636 line += pitch;
272 } 637 }
273 } 638 }
274 639
275 static void Convert565To555le(SDL_Surface *surface) 640 static void Convert565To555le(_THIS, SDL_Surface *surface)
276 { 641 {
277 int x,y, pitch; 642 int x,y, pitch;
278 unsigned short *line, *pixel; 643 unsigned short *line, *pixel;
279 644
280 line = surface->pixels; 645 line = surface->pixels;
290 655
291 line += pitch; 656 line += pitch;
292 } 657 }
293 } 658 }
294 659
295 static void Convert565le(SDL_Surface *surface) 660 static void Convert565le(_THIS, SDL_Surface *surface)
296 { 661 {
297 int x,y, pitch; 662 int x,y, pitch;
298 unsigned short *line, *pixel; 663 unsigned short *line, *pixel;
299 664
300 line = surface->pixels; 665 line = surface->pixels;
309 674
310 line += pitch; 675 line += pitch;
311 } 676 }
312 } 677 }
313 678
314 static void ConvertBGRAToABGR(SDL_Surface *surface) 679 static void ConvertBGRAToABGR(_THIS, SDL_Surface *surface)
315 { 680 {
316 int x,y, pitch; 681 int x,y, pitch;
317 unsigned long *line, *pixel; 682 unsigned long *line, *pixel;
318 683
319 line = surface->pixels; 684 line = surface->pixels;