Debian Codegraph @

src/sdl/sdl_display.c

raw
1 /* ______ ___ ___
2 * /\ _ \ /\_ \ /\_ \
3 * \ \ \L\ \\//\ \ \//\ \ __ __ _ __ ___
4 * \ \ __ \ \ \ \ \ \ \ /'__`\ /'_ `\/\`'__\/ __`\
5 * \ \ \/\ \ \_\ \_ \_\ \_/\ __//\ \L\ \ \ \//\ \L\ \
6 * \ \_\ \_\/\____\/\____\ \____\ \____ \ \_\\ \____/
7 * \/_/\/_/\/____/\/____/\/____/\/___L\ \/_/ \/___/
8 * /\____/
9 * \_/__/
10 *
11 * SDL display implementation.
12 *
13 * See LICENSE.txt for copyright information.
14 */
15 #include "allegro5/allegro.h"
16 #include "allegro5/allegro_opengl.h"
17 #include "allegro5/system.h"
18 #include "allegro5/internal/aintern.h"
19 #include "allegro5/internal/aintern_bitmap.h"
20 #include "allegro5/internal/aintern_opengl.h"
21 #include "allegro5/internal/aintern_vector.h"
22 #include "allegro5/internal/aintern_system.h"
23 #include "allegro5/internal/aintern_pixels.h"
24 #include "allegro5/internal/aintern_shader.h"
25 #include "allegro5/platform/allegro_internal_sdl.h"
26
27 ALLEGRO_DEBUG_CHANNEL("display")
28
29 int _al_win_determine_adapter(void);
30
31 static ALLEGRO_DISPLAY_INTERFACE *vt;
32
33 float _al_sdl_get_display_pixel_ratio(ALLEGRO_DISPLAY *display)
34 {
35 ALLEGRO_DISPLAY_SDL *sdl = (void *)display;
36 int window_width, drawable_width, h;
37 SDL_GetWindowSize(sdl->window, &window_width, &h);
38 SDL_GL_GetDrawableSize(sdl->window, &drawable_width, &h);
39 return drawable_width / (float)window_width;
40 }
41
42 ALLEGRO_DISPLAY *_al_sdl_find_display(uint32_t window_id) {
43 unsigned int i;
44 ALLEGRO_SYSTEM *s = al_get_system_driver();
45 for (i = 0; i < _al_vector_size(&s->displays); i++) {
46 void **v = (void **)_al_vector_ref(&s->displays, i);
47 ALLEGRO_DISPLAY_SDL *d = *v;
48 if (SDL_GetWindowID(d->window) == window_id) {
49 return &d->display;
50 break;
51 }
52 }
53 return NULL;
54 }
55
56 void _al_sdl_display_event(SDL_Event *e)
57 {
58 ALLEGRO_EVENT event;
59 event.display.timestamp = al_get_time();
60
61 ALLEGRO_DISPLAY *d = NULL;
62
63 if (e->type == SDL_WINDOWEVENT) {
64 d = _al_sdl_find_display(e->window.windowID);
65 if (e->window.event == SDL_WINDOWEVENT_FOCUS_GAINED) {
66 event.display.type = ALLEGRO_EVENT_DISPLAY_SWITCH_IN;
67 }
68 if (e->window.event == SDL_WINDOWEVENT_FOCUS_LOST) {
69 event.display.type = ALLEGRO_EVENT_DISPLAY_SWITCH_OUT;
70 }
71 if (e->window.event == SDL_WINDOWEVENT_CLOSE) {
72 event.display.type = ALLEGRO_EVENT_DISPLAY_CLOSE;
73 }
74 if (e->window.event == SDL_WINDOWEVENT_RESIZED) {
75 float ratio = _al_sdl_get_display_pixel_ratio(d);
76 event.display.type = ALLEGRO_EVENT_DISPLAY_RESIZE;
77 event.display.width = e->window.data1 * ratio;
78 event.display.height = e->window.data2 * ratio;
79 }
80 }
81 if (e->type == SDL_QUIT) {
82 event.display.type = ALLEGRO_EVENT_DISPLAY_CLOSE;
83 /* Use the first display as event source if we have any displays. */
84 ALLEGRO_SYSTEM *s = al_get_system_driver();
85 if (_al_vector_size(&s->displays) > 0) {
86 void **v = (void **)_al_vector_ref(&s->displays, 0);
87 d = *v;
88 }
89 }
90
91 if (!d)
92 return;
93 ALLEGRO_EVENT_SOURCE *es = &d->es;
94 _al_event_source_lock(es);
95 _al_event_source_emit_event(es, &event);
96 _al_event_source_unlock(es);
97 }
98
99 static void GLoption(int allegro, int sdl)
100 {
101 int i;
102 int x = al_get_new_display_option(allegro, &i);
103 if (i == ALLEGRO_DONTCARE)
104 return;
105 SDL_GL_SetAttribute(sdl, x);
106 }
107
108 static ALLEGRO_DISPLAY *sdl_create_display_locked(int w, int h)
109 {
110 ALLEGRO_DISPLAY_SDL *sdl = al_calloc(1, sizeof *sdl);
111 ALLEGRO_DISPLAY *d = (void *)sdl;
112 d->w = w;
113 d->h = h;
114 d->flags = al_get_new_display_flags();
115 d->flags |= ALLEGRO_OPENGL;
116 #ifdef ALLEGRO_CFG_OPENGLES2
117 d->flags |= ALLEGRO_PROGRAMMABLE_PIPELINE;
118 #endif
119 #ifdef ALLEGRO_CFG_OPENGLES
120 d->flags |= ALLEGRO_OPENGL_ES_PROFILE;
121 #endif
122 int flags = SDL_WINDOW_OPENGL;
123 if (d->flags & ALLEGRO_FULLSCREEN)
124 flags |= SDL_WINDOW_FULLSCREEN;
125 if (d->flags & ALLEGRO_FULLSCREEN_WINDOW)
126 flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
127 if (d->flags & ALLEGRO_FRAMELESS)
128 flags |= SDL_WINDOW_BORDERLESS;
129 if (d->flags & ALLEGRO_RESIZABLE)
130 flags |= SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI;
131
132 if (d->flags & ALLEGRO_OPENGL_ES_PROFILE) {
133 SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
134 #ifdef ALLEGRO_CFG_OPENGLES1
135 SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
136 #else
137 SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
138 #endif
139 SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
140 }
141
142 GLoption(ALLEGRO_COLOR_SIZE, SDL_GL_BUFFER_SIZE);
143 GLoption(ALLEGRO_RED_SIZE, SDL_GL_RED_SIZE);
144 GLoption(ALLEGRO_GREEN_SIZE, SDL_GL_GREEN_SIZE);
145 GLoption(ALLEGRO_BLUE_SIZE, SDL_GL_BLUE_SIZE);
146 GLoption(ALLEGRO_ALPHA_SIZE, SDL_GL_ALPHA_SIZE);
147 GLoption(ALLEGRO_ACC_RED_SIZE, SDL_GL_ACCUM_RED_SIZE);
148 GLoption(ALLEGRO_ACC_GREEN_SIZE, SDL_GL_ACCUM_GREEN_SIZE);
149 GLoption(ALLEGRO_ACC_BLUE_SIZE, SDL_GL_ACCUM_BLUE_SIZE);
150 GLoption(ALLEGRO_ACC_ALPHA_SIZE, SDL_GL_ACCUM_ALPHA_SIZE);
151 GLoption(ALLEGRO_STEREO, SDL_GL_STEREO);
152 GLoption(ALLEGRO_DEPTH_SIZE, SDL_GL_DEPTH_SIZE);
153 GLoption(ALLEGRO_STENCIL_SIZE, SDL_GL_STENCIL_SIZE);
154 GLoption(ALLEGRO_SAMPLE_BUFFERS, SDL_GL_MULTISAMPLEBUFFERS);
155 GLoption(ALLEGRO_SAMPLES, SDL_GL_MULTISAMPLESAMPLES);
156 GLoption(ALLEGRO_OPENGL_MAJOR_VERSION, SDL_GL_CONTEXT_MAJOR_VERSION);
157 GLoption(ALLEGRO_OPENGL_MINOR_VERSION, SDL_GL_CONTEXT_MINOR_VERSION);
158
159 SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "0");
160
161 sdl->window = SDL_CreateWindow(al_get_new_window_title(), sdl->x, sdl->y,
162 d->w, d->h, flags);
163 if (!sdl->window) {
164 ALLEGRO_ERROR("SDL_CreateWindow failed: %s", SDL_GetError());
165 return NULL;
166 }
167
168 sdl->context = SDL_GL_CreateContext(sdl->window);
169
170 SDL_GL_GetDrawableSize(sdl->window, &d->w, &d->h);
171
172 // there's no way to query pixel ratio before creating the window, so we
173 // have to compensate afterwards
174 if (d->flags & ALLEGRO_RESIZABLE &&
175 !(d->flags & ALLEGRO_FULLSCREEN || d->flags & ALLEGRO_FULLSCREEN_WINDOW)) {
176 int window_width, window_height;
177 SDL_GetWindowSize(sdl->window, &window_width, &window_height);
178 float ratio = _al_sdl_get_display_pixel_ratio(d);
179
180 ALLEGRO_DEBUG("resizing the display to %dx%d to match the scaling factor %f\n", (int)(window_width / ratio), (int)(window_height / ratio), ratio);
181
182 SDL_SetWindowSize(sdl->window, window_width / ratio, window_height / ratio);
183
184 SDL_GL_GetDrawableSize(sdl->window, &d->w, &d->h);
185 }
186
187 ALLEGRO_DISPLAY **add;
188 ALLEGRO_SYSTEM *system = al_get_system_driver();
189 add = _al_vector_alloc_back(&system->displays);
190 *add = d;
191
192 _al_event_source_init(&d->es);
193 d->vt = vt;
194
195 d->extra_settings.settings[ALLEGRO_COMPATIBLE_DISPLAY] = true;
196
197 d->ogl_extras = al_calloc(1, sizeof *d->ogl_extras);
198 _al_ogl_manage_extensions(d);
199 _al_ogl_set_extensions(d->ogl_extras->extension_api);
200
201 _al_ogl_setup_gl(d);
202
203 /* Fill in opengl version */
204 const int v = d->ogl_extras->ogl_info.version;
205 d->extra_settings.settings[ALLEGRO_OPENGL_MAJOR_VERSION] = (v >> 24) & 0xFF;
206 d->extra_settings.settings[ALLEGRO_OPENGL_MINOR_VERSION] = (v >> 16) & 0xFF;
207
208 return d;
209 }
210
211 static ALLEGRO_DISPLAY *sdl_create_display(int w, int h)
212 {
213 ALLEGRO_SYSTEM_SDL *s = (void *)al_get_system_driver();
214 al_lock_mutex(s->mutex);
215 ALLEGRO_DISPLAY *d = sdl_create_display_locked(w, h);
216 al_unlock_mutex(s->mutex);
217 return d;
218 }
219
220 static void convert_display_bitmaps_to_memory_bitmap(ALLEGRO_DISPLAY *d)
221 {
222 ALLEGRO_DEBUG("converting display bitmaps to memory bitmaps.\n");
223
224 while (d->bitmaps._size > 0) {
225 ALLEGRO_BITMAP **bptr = _al_vector_ref_back(&d->bitmaps);
226 ALLEGRO_BITMAP *b = *bptr;
227 _al_convert_to_memory_bitmap(b);
228 }
229 }
230
231 static void transfer_display_bitmaps_to_any_other_display(
232 ALLEGRO_SYSTEM *s, ALLEGRO_DISPLAY *d)
233 {
234 size_t i;
235 ALLEGRO_DISPLAY *living = NULL;
236 ASSERT(s->displays._size > 1);
237
238 for (i = 0; i < s->displays._size; i++) {
239 ALLEGRO_DISPLAY **slot = _al_vector_ref(&s->displays, i);
240 living = *slot;
241 if (living != d)
242 break;
243 }
244
245 ALLEGRO_DEBUG("transferring display bitmaps to other display.\n");
246
247 for (i = 0; i < d->bitmaps._size; i++) {
248 ALLEGRO_BITMAP **add = _al_vector_alloc_back(&(living->bitmaps));
249 ALLEGRO_BITMAP **ref = _al_vector_ref(&d->bitmaps, i);
250 *add = *ref;
251 (*add)->_display = living;
252 }
253 }
254
255 static void sdl_destroy_display_locked(ALLEGRO_DISPLAY *d)
256 {
257 ALLEGRO_DISPLAY_SDL *sdl = (void *)d;
258 ALLEGRO_SYSTEM *system = al_get_system_driver();
259 ALLEGRO_OGL_EXTRAS *ogl = d->ogl_extras;
260 bool is_last;
261
262 ALLEGRO_DEBUG("destroying display.\n");
263
264 /* If we're the last display, convert all bitmaps to display independent
265 * (memory) bitmaps. Otherwise, pass all bitmaps to any other living
266 * display. We assume all displays are compatible.)
267 */
268
269 is_last = (system->displays._size == 1);
270 if (is_last)
271 convert_display_bitmaps_to_memory_bitmap(d);
272 else
273 transfer_display_bitmaps_to_any_other_display(system, d);
274
275 _al_ogl_unmanage_extensions(d);
276 ALLEGRO_DEBUG("unmanaged extensions.\n");
277
278 if (ogl->backbuffer) {
279 _al_ogl_destroy_backbuffer(ogl->backbuffer);
280 ogl->backbuffer = NULL;
281 ALLEGRO_DEBUG("destroy backbuffer.\n");
282 }
283
284 _al_vector_free(&d->bitmaps);
285 _al_event_source_free(&d->es);
286
287 al_free(d->ogl_extras);
288 al_free(d->vertex_cache);
289
290 _al_event_source_free(&d->es);
291 _al_vector_find_and_delete(&system->displays, &d);
292
293 SDL_GL_DeleteContext(sdl->context);
294 SDL_DestroyWindow(sdl->window);
295 al_free(sdl);
296 }
297
298 static void sdl_destroy_display(ALLEGRO_DISPLAY *d)
299 {
300 ALLEGRO_SYSTEM_SDL *s = (void *)al_get_system_driver();
301 al_lock_mutex(s->mutex);
302 sdl_destroy_display_locked(d);
303 al_unlock_mutex(s->mutex);
304 }
305
306 static bool sdl_set_current_display(ALLEGRO_DISPLAY *d)
307 {
308 ALLEGRO_DISPLAY_SDL *sdl = (void *)d;
309 SDL_GL_MakeCurrent(sdl->window, sdl->context);
310 return true;
311 }
312
313 static void sdl_unset_current_display(ALLEGRO_DISPLAY *d)
314 {
315 (void)d;
316 }
317
318 static void sdl_flip_display(ALLEGRO_DISPLAY *d)
319 {
320 ALLEGRO_DISPLAY_SDL *sdl = (void *)d;
321 SDL_GL_SwapWindow(sdl->window);
322
323 // SDL loses texture contents, for example on resize.
324 al_backup_dirty_bitmaps(d);
325 }
326
327 static void sdl_update_display_region(ALLEGRO_DISPLAY *d, int x, int y,
328 int width, int height)
329 {
330 ALLEGRO_DISPLAY_SDL *sdl = (void *)d;
331 (void)x;
332 (void)y;
333 (void)width;
334 (void)height;
335 SDL_GL_SwapWindow(sdl->window);
336 }
337
338 static bool sdl_is_compatible_bitmap(ALLEGRO_DISPLAY *display,
339 ALLEGRO_BITMAP *bitmap)
340 {
341 (void)display;
342 (void)bitmap;
343 return true;
344 }
345
346 static bool sdl_set_mouse_cursor(ALLEGRO_DISPLAY *display,
347 ALLEGRO_MOUSE_CURSOR *cursor)
348 {
349 ALLEGRO_MOUSE_CURSOR_SDL *sdl_cursor = (ALLEGRO_MOUSE_CURSOR_SDL *) cursor;
350 (void)display;
351 SDL_SetCursor(sdl_cursor->cursor);
352 return true;
353 }
354
355 static bool sdl_set_system_mouse_cursor(ALLEGRO_DISPLAY *display,
356 ALLEGRO_SYSTEM_MOUSE_CURSOR cursor_id)
357 {
358 (void)display;
359 (void)cursor_id;
360 return false;
361 }
362
363 static bool sdl_show_mouse_cursor(ALLEGRO_DISPLAY *display)
364 {
365 (void)display;
366 return SDL_ShowCursor(SDL_ENABLE) == SDL_ENABLE;
367 }
368
369 static bool sdl_hide_mouse_cursor(ALLEGRO_DISPLAY *display)
370 {
371 (void)display;
372 return SDL_ShowCursor(SDL_DISABLE) == SDL_DISABLE;
373 }
374
375 static void sdl_set_window_position(ALLEGRO_DISPLAY *display, int x, int y)
376 {
377 ALLEGRO_DISPLAY_SDL *sdl = (void *)display;
378 SDL_SetWindowPosition(sdl->window, x, y);
379 }
380
381 static void sdl_get_window_position(ALLEGRO_DISPLAY *display, int *x, int *y)
382 {
383 ALLEGRO_DISPLAY_SDL *sdl = (void *)display;
384 SDL_GetWindowPosition(sdl->window, x, y);
385 }
386
387 static void recreate_textures(ALLEGRO_DISPLAY *display)
388 {
389 unsigned int i;
390 for (i = 0; i < _al_vector_size(&display->bitmaps); i++) {
391 ALLEGRO_BITMAP **bptr = _al_vector_ref(&display->bitmaps, i);
392 ALLEGRO_BITMAP *bitmap = *bptr;
393 int bitmap_flags = al_get_bitmap_flags(bitmap);
394 if (bitmap->parent)
395 continue;
396 if (bitmap_flags & ALLEGRO_MEMORY_BITMAP)
397 continue;
398 if (bitmap_flags & ALLEGRO_NO_PRESERVE_TEXTURE)
399 continue;
400 _al_ogl_upload_bitmap_memory(bitmap, _al_get_bitmap_memory_format(
401 bitmap), bitmap->memory);
402 }
403 }
404
405 static bool sdl_acknowledge_resize(ALLEGRO_DISPLAY *display)
406 {
407 ALLEGRO_DISPLAY_SDL *sdl = (void *)display;
408 SDL_GL_GetDrawableSize(sdl->window, &display->w, &display->h);
409
410 _al_ogl_setup_gl(display);
411
412 if (display->flags & ALLEGRO_PROGRAMMABLE_PIPELINE) {
413 display->default_shader = _al_create_default_shader(display);
414 al_use_shader(display->default_shader);
415 }
416
417 recreate_textures(display);
418
419 _al_glsl_unuse_shaders();
420
421 return true;
422 }
423
424 static void sdl_set_window_title(ALLEGRO_DISPLAY *display, char const *title)
425 {
426 ALLEGRO_DISPLAY_SDL *sdl = (void *)display;
427 SDL_SetWindowTitle(sdl->window, title);
428 }
429
430 static bool sdl_resize_display(ALLEGRO_DISPLAY *display, int width, int height)
431 {
432 ALLEGRO_DISPLAY_SDL *sdl = (void *)display;
433
434 // Allegro uses pixels everywhere, while SDL uses screen space for window size
435 int window_width, drawable_width, h;
436 SDL_GetWindowSize(sdl->window, &window_width, &h);
437 SDL_GL_GetDrawableSize(sdl->window, &drawable_width, &h);
438 float ratio = drawable_width / (float)window_width;
439
440 SDL_SetWindowSize(sdl->window, width / ratio, height / ratio);
441 sdl_acknowledge_resize(display);
442 return true;
443 }
444
445 static bool sdl_set_display_flag(ALLEGRO_DISPLAY *display, int flag,
446 bool flag_onoff)
447 {
448 ALLEGRO_DISPLAY_SDL *sdl = (void *)display;
449 switch (flag) {
450 case ALLEGRO_FRAMELESS:
451 /* The ALLEGRO_FRAMELESS flag is backwards. */
452 SDL_SetWindowBordered(sdl->window, !flag_onoff);
453 return true;
454 case ALLEGRO_FULLSCREEN_WINDOW:
455 SDL_SetWindowFullscreen(sdl->window, flag_onoff ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
456 return true;
457 case ALLEGRO_MAXIMIZED:
458 if (flag_onoff) {
459 SDL_MaximizeWindow(sdl->window);
460 } else {
461 SDL_RestoreWindow(sdl->window);
462 }
463 return true;
464 }
465 return false;
466 }
467
468 static void sdl_set_icons(ALLEGRO_DISPLAY *display, int num_icons, ALLEGRO_BITMAP *bitmaps[]) {
469 ALLEGRO_DISPLAY_SDL *sdl = (void *)display;
470 int w = al_get_bitmap_width(bitmaps[0]);
471 int h = al_get_bitmap_height(bitmaps[0]);
472 int data_size = w * h * 4;
473 (void)num_icons;
474
475 unsigned char* data = al_malloc(data_size * sizeof(data[0]));
476
477 Uint32 rmask, gmask, bmask, amask;
478 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
479 rmask = 0xff000000;
480 gmask = 0x00ff0000;
481 bmask = 0x0000ff00;
482 amask = 0x000000ff;
483 #else // little endian, like x86
484 rmask = 0x000000ff;
485 gmask = 0x0000ff00;
486 bmask = 0x00ff0000;
487 amask = 0xff000000;
488 #endif
489
490 ALLEGRO_LOCKED_REGION *lock = al_lock_bitmap(bitmaps[0], ALLEGRO_PIXEL_FORMAT_ABGR_8888, ALLEGRO_LOCK_READONLY);
491 if (lock) {
492 int i = 0, y = 0;
493 for (y = 0; y < h; y++) {
494 int x = 0;
495 for (x = 0; x < w; x++) {
496 ALLEGRO_COLOR c = al_get_pixel(bitmaps[0], x, y);
497 al_unmap_rgba(c, data+i, data+i+1, data+i+2, data+i+3);
498 i += 4;
499 }
500 }
501 al_unlock_bitmap(bitmaps[0]);
502
503 SDL_Surface *icon = SDL_CreateRGBSurfaceFrom(data, w, h, 4 * 8, w * 4, rmask, gmask, bmask, amask);
504 SDL_SetWindowIcon(sdl->window, icon);
505 SDL_FreeSurface(icon);
506 }
507
508 al_free(data);
509 }
510
511 ALLEGRO_DISPLAY_INTERFACE *_al_sdl_display_driver(void)
512 {
513 if (vt)
514 return vt;
515
516 vt = al_calloc(1, sizeof *vt);
517 vt->id = AL_ID('S', 'D', 'L', '2');
518 vt->create_display = sdl_create_display;
519 vt->destroy_display = sdl_destroy_display;
520 vt->set_current_display = sdl_set_current_display;
521 vt->unset_current_display = sdl_unset_current_display;
522 //vt->clear = GL
523 //vt->draw_pixel = GL
524 vt->flip_display = sdl_flip_display;
525 vt->update_display_region = sdl_update_display_region;
526 vt->acknowledge_resize = sdl_acknowledge_resize;
527 vt->resize_display = sdl_resize_display;
528 /*vt->quick_size = sdl_quick_size;
529 vt->get_orientation = sdl_get_orientation;*/
530 vt->create_bitmap = _al_ogl_create_bitmap;
531 vt->set_target_bitmap = _al_ogl_set_target_bitmap;
532 vt->get_backbuffer = _al_ogl_get_backbuffer;
533 vt->is_compatible_bitmap = sdl_is_compatible_bitmap;
534 /*vt->switch_out = sdl_switch_out;
535 vt->switch_in = sdl_switch_in;
536 vt->draw_memory_bitmap_region = sdl_draw_memory_bitmap_region;
537 vt->wait_for_vsync = sdl_wait_for_vsync;*/
538 vt->set_mouse_cursor = sdl_set_mouse_cursor;
539 vt->set_system_mouse_cursor = sdl_set_system_mouse_cursor;
540 vt->show_mouse_cursor = sdl_show_mouse_cursor;
541 vt->hide_mouse_cursor = sdl_hide_mouse_cursor;
542 vt->set_icons = sdl_set_icons;
543 vt->set_window_position = sdl_set_window_position;
544 vt->get_window_position = sdl_get_window_position;
545 /*vt->set_window_constraints = sdl_set_window_constraints;
546 vt->get_window_constraints = sdl_get_window_constraints;*/
547 vt->set_display_flag = sdl_set_display_flag;
548 vt->set_window_title = sdl_set_window_title;
549 //vt->flush_vertex_cache = GL
550 //vt->prepare_vertex_cache = GL
551 //vt->update_transformation = GL
552 //vt->set_projection = GL
553 /*vt->shutdown = sdl_shutdown;
554 vt->acknowledge_drawing_halt = sdl_acknowledge_drawing_halt;
555 vt->acknowledge_drawing_resume = sdl_acknowledge_drawing_resume;
556 vt->set_display_option = sdl_set_display_option;*/
557 //vt->clear_depth_buffer = GL
558 vt->update_render_state = _al_ogl_update_render_state;
559
560 _al_ogl_add_drawing_functions(vt);
561
562 return vt;
563 }