/* Function: al_create_event_queue */ ALLEGRO_EVENT_QUEUE *al_create_event_queue(void) { ALLEGRO_EVENT_QUEUE *queue = al_malloc(sizeof *queue); ASSERT(queue); if (queue) { _al_vector_init(&queue->sources, sizeof(ALLEGRO_EVENT_SOURCE *)); _al_vector_init(&queue->events, sizeof(ALLEGRO_EVENT)); _al_vector_alloc_back(&queue->events); queue->events_head = 0; queue->events_tail = 0; queue->paused = false; _AL_MARK_MUTEX_UNINITED(queue->mutex); _al_mutex_init(&queue->mutex); _al_cond_init(&queue->cond); _al_register_destructor(_al_dtor_list, "queue", queue, (void (*)(void *)) al_destroy_event_queue); } return queue; }
/* Function: al_create_path */ ALLEGRO_PATH *al_create_path(const char *str) { ALLEGRO_PATH *path; path = _AL_MALLOC(sizeof(ALLEGRO_PATH)); if (!path) return NULL; path->drive = al_ustr_new(""); path->filename = al_ustr_new(""); _al_vector_init(&path->segments, sizeof(ALLEGRO_USTR *)); path->basename = al_ustr_new(""); path->full_string = al_ustr_new(""); if (str != NULL) { ALLEGRO_USTR *copy = al_ustr_new(str); replace_backslashes(copy); if (!parse_path_string(copy, path)) { al_destroy_path(path); path = NULL; } al_ustr_free(copy); } return path; }
/* Internal function: _al_event_source_init * Initialise an event source structure. */ void _al_event_source_init(ALLEGRO_EVENT_SOURCE *es) { ALLEGRO_EVENT_SOURCE_REAL *this = (ALLEGRO_EVENT_SOURCE_REAL *)es; memset(es, 0, sizeof(*es)); _AL_MARK_MUTEX_UNINITED(this->mutex); _al_mutex_init(&this->mutex); _al_vector_init(&this->queues, sizeof(ALLEGRO_EVENT_QUEUE *)); this->data = 0; }
/* Internal function: _al_init_destructors * Initialise a list of destructors. */ _AL_DTOR_LIST *_al_init_destructors(void) { _AL_DTOR_LIST *dtors = al_malloc(sizeof(*dtors)); _AL_MARK_MUTEX_UNINITED(dtors->mutex); _al_mutex_init(&dtors->mutex); _al_vector_init(&dtors->dtors, sizeof(DTOR)); return dtors; }
void _al_d3d_bmp_destroy(void) { while (!_al_vector_is_empty(&created_bitmaps)) _al_vector_delete_at(&created_bitmaps, _al_vector_size(&created_bitmaps)-1); _al_vector_free(&created_bitmaps); _al_vector_init(&created_bitmaps, sizeof(ALLEGRO_SYSTEM_INTERFACE *)); al_free(vt); vt = NULL; }
/* ljoy_init_joystick: [primary thread] * Initialise the joystick driver. */ static bool ljoy_init_joystick(void) { _al_vector_init(&joysticks, sizeof(ALLEGRO_JOYSTICK_LINUX *)); num_joysticks = 0; if (!(config_mutex = al_create_mutex())) { return false; } // Scan for joysticks ljoy_scan(false); ljoy_merge(); #ifdef SUPPORT_HOTPLUG if (!(hotplug_mutex = al_create_mutex())) { al_destroy_mutex(config_mutex); return false; } if (!(hotplug_cond = al_create_cond())) { al_destroy_mutex(config_mutex); al_destroy_mutex(hotplug_mutex); return false; } if (!(hotplug_thread = al_create_thread(hotplug_proc, NULL))) { al_destroy_mutex(config_mutex); al_destroy_mutex(hotplug_mutex); al_destroy_cond(hotplug_cond); return false; } al_start_thread(hotplug_thread); inotify_fd = inotify_init(); if (inotify_fd != -1) { fcntl(inotify_fd, F_SETFL, O_NONBLOCK); /* Modern Linux probably only needs to monitor /dev/input. */ inotify_add_watch(inotify_fd, "/dev/input", IN_CREATE|IN_DELETE); _al_unix_start_watching_fd(inotify_fd, ljoy_config_dev_changed, NULL); ALLEGRO_INFO("Hotplugging enabled\n"); } else { ALLEGRO_WARN("Hotplugging not enabled\n"); if (inotify_fd != -1) { close(inotify_fd); inotify_fd = -1; } } #endif return true; }
/* Function: al_create_menu */ ALLEGRO_MENU *al_create_menu(void) { ALLEGRO_MENU *m = al_calloc(1, sizeof(*m)); if (m) { _al_vector_init(&m->items, sizeof(ALLEGRO_MENU_ITEM*)); /* Make sure the platform actually supports menus */ if (!_al_init_menu(m)) { al_destroy_menu(m); m = NULL; } } return m; }
/* al_init will call this. */ ALLEGRO_SYSTEM *iphone_initialize(int flags) { (void)flags; iphone = al_calloc(1, sizeof *iphone); ALLEGRO_SYSTEM *sys = &iphone->system; iphone->mutex = al_create_mutex(); iphone->cond = al_create_cond(); sys->vt = _al_get_iphone_system_interface(); _al_vector_init(&sys->displays, sizeof (ALLEGRO_DISPLAY_IPHONE *)); _al_unix_init_time(); _al_iphone_init_path(); return sys; }
static void shutdown_system_driver(void) { if (active_sysdrv) { if (active_sysdrv->user_exe_path) al_destroy_path(active_sysdrv->user_exe_path); if (active_sysdrv->vt && active_sysdrv->vt->shutdown_system) active_sysdrv->vt->shutdown_system(); active_sysdrv = NULL; while (!_al_vector_is_empty(&_al_system_interfaces)) _al_vector_delete_at(&_al_system_interfaces, _al_vector_size(&_al_system_interfaces)-1); _al_vector_free(&_al_system_interfaces); _al_vector_init(&_al_system_interfaces, sizeof(ALLEGRO_SYSTEM_INTERFACE *)); } al_destroy_config(sys_config); sys_config = NULL; }
ALLEGRO_SHADER *_al_create_shader_glsl(ALLEGRO_SHADER_PLATFORM platform) { ALLEGRO_SHADER_GLSL_S *shader = al_calloc(1, sizeof(ALLEGRO_SHADER_GLSL_S)); if (!shader) return NULL; shader->shader.platform = platform; shader->shader.vt = &shader_glsl_vt; _al_vector_init(&shader->shader.bitmaps, sizeof(ALLEGRO_BITMAP *)); al_lock_mutex(shaders_mutex); { ALLEGRO_SHADER **back = (ALLEGRO_SHADER **)_al_vector_alloc_back(&shaders); *back = (ALLEGRO_SHADER *)shader; } al_unlock_mutex(shaders_mutex); return (ALLEGRO_SHADER *)shader; }
/* Function: al_create_popup_menu */ ALLEGRO_MENU *al_create_popup_menu(void) { ALLEGRO_MENU *m = al_calloc(1, sizeof(*m)); if (m) { _al_vector_init(&m->items, sizeof(ALLEGRO_MENU_ITEM*)); if (!_al_init_popup_menu(m)) { al_destroy_menu(m); m = NULL; } else { /* Popups are slightly different... They can be used multiple times * with al_popup_menu(), but never as a display menu. */ m->is_popup_menu = true; } } return m; }
/* Create a new system object. */ static ALLEGRO_SYSTEM *win_initialize(int flags) { (void)flags; set_dpi_awareness(); _al_win_system = al_calloc(1, sizeof *_al_win_system); // Request a 1ms resolution from our timer if (timeBeginPeriod(1) != TIMERR_NOCANDO) { using_higher_res_timer = true; } _al_win_init_time(); _al_win_init_window(); _al_vector_init(&_al_win_system->system.displays, sizeof (ALLEGRO_SYSTEM_WIN *)); _al_win_system->system.vt = vt; return &_al_win_system->system; }
static ALLEGRO_SYSTEM *xglx_initialize(int flags) { Display *x11display; Display *gfxdisplay; ALLEGRO_SYSTEM_XGLX *s; (void)flags; #ifdef DEBUG_X11 _Xdebug = 1; #endif XInitThreads(); /* Get an X11 display handle. */ x11display = XOpenDisplay(0); if (x11display) { /* Never ask. */ gfxdisplay = XOpenDisplay(0); if (!gfxdisplay) { ALLEGRO_ERROR("XOpenDisplay failed second time.\n"); XCloseDisplay(x11display); return NULL; } } else { ALLEGRO_INFO("XOpenDisplay failed; assuming headless mode.\n"); gfxdisplay = NULL; } _al_unix_init_time(); s = al_calloc(1, sizeof *s); _al_mutex_init_recursive(&s->lock); _al_cond_init(&s->resized); s->inhibit_screensaver = false; _al_vector_init(&s->system.displays, sizeof (ALLEGRO_DISPLAY_XGLX *)); s->system.vt = xglx_vt; s->gfxdisplay = gfxdisplay; s->x11display = x11display; if (s->x11display) { ALLEGRO_INFO("XGLX driver connected to X11 (%s %d).\n", ServerVendor(s->x11display), VendorRelease(s->x11display)); ALLEGRO_INFO("X11 protocol version %d.%d.\n", ProtocolVersion(s->x11display), ProtocolRevision(s->x11display)); /* We need to put *some* atom into the ClientMessage we send for * faking mouse movements with al_set_mouse_xy - so let's ask X11 * for one here. */ s->AllegroAtom = XInternAtom(x11display, "AllegroAtom", False); /* Message type for XEmbed protocol. */ s->XEmbedAtom = XInternAtom(x11display, "_XEMBED", False); _al_thread_create(&s->xevents_thread, _al_xwin_background_thread, s); s->have_xevents_thread = true; ALLEGRO_INFO("events thread spawned.\n"); } return &s->system; }
/* Create a new system object for the dummy X11 driver. */ static ALLEGRO_SYSTEM *xglx_initialize(int flags) { Display *x11display; Display *gfxdisplay; ALLEGRO_SYSTEM_XGLX *s; (void)flags; #ifdef DEBUG_X11 _Xdebug = 1; #endif XInitThreads(); /* Get an X11 display handle. */ x11display = XOpenDisplay(0); if (!x11display) { ALLEGRO_ERROR("XOpenDisplay failed.\n"); return NULL; } /* Never ask. */ gfxdisplay = XOpenDisplay(0); if (!gfxdisplay) { ALLEGRO_ERROR("XOpenDisplay failed.\n"); XCloseDisplay(x11display); return NULL; } _al_unix_init_time(); s = _AL_MALLOC(sizeof *s); memset(s, 0, sizeof *s); /* We need to put *some* atom into the ClientMessage we send for * faking mouse movements with al_set_mouse_xy - so lets ask X11 * for one here. */ s->AllegroAtom = XInternAtom(x11display, "AllegroAtom", False); _al_mutex_init_recursive(&s->lock); _al_cond_init(&s->resized); s->inhibit_screensaver = false; _al_vector_init(&s->system.displays, sizeof (ALLEGRO_DISPLAY_XGLX *)); s->gfxdisplay = gfxdisplay; s->x11display = x11display; s->system.vt = xglx_vt; ALLEGRO_INFO("XGLX driver connected to X11 (%s %d).\n", ServerVendor(s->x11display), VendorRelease(s->x11display)); ALLEGRO_INFO("X11 protocol version %d.%d.\n", ProtocolVersion(s->x11display), ProtocolRevision(s->x11display)); #ifdef ALLEGRO_XWINDOWS_WITH_XINERAMA _al_xsys_xinerama_init(s); #endif _al_xglx_store_video_mode(s); _al_thread_create(&s->thread, xglx_background_thread, s); ALLEGRO_INFO("events thread spawned.\n"); return &s->system; }
void _al_glsl_init_shaders(void) { _al_vector_init(&shaders, sizeof(ALLEGRO_SHADER *)); shaders_mutex = al_create_mutex(); }
void _al_d3d_bmp_init(void) { _al_vector_init(&created_bitmaps, sizeof(ALLEGRO_BITMAP_D3D *)); }
/* Function: al_install_system */ bool al_install_system(int version, int (*atexit_ptr)(void (*)(void))) { ALLEGRO_SYSTEM bootstrap; ALLEGRO_SYSTEM *real_system; int library_version = al_get_allegro_version(); if (active_sysdrv) { return true; } /* Note: We cannot call logging functions yet. * TODO: Maybe we want to do the check after the "bootstrap" system * is available at least? */ if (!compatible_versions(version, library_version)) return false; _al_tls_init_once(); _al_vector_init(&_al_system_interfaces, sizeof(ALLEGRO_SYSTEM_INTERFACE *)); /* Set up a bootstrap system so the calls expecting it don't freak out */ memset(&bootstrap, 0, sizeof(bootstrap)); active_sysdrv = &bootstrap; read_allegro_cfg(); #ifdef ALLEGRO_BCC32 /* This supresses exceptions on floating point divide by zero */ _control87(MCW_EM, MCW_EM); #endif /* Register builtin system drivers */ _al_register_system_interfaces(); /* Check for a user-defined system driver first */ real_system = find_system(&_user_system_interfaces); /* If a user-defined driver is not found, look for a builtin one */ if (real_system == NULL) { real_system = find_system(&_al_system_interfaces); } if (real_system == NULL) { active_sysdrv = NULL; return false; } active_sysdrv = real_system; active_sysdrv->mouse_wheel_precision = 1; ALLEGRO_INFO("Allegro version: %s\n", ALLEGRO_VERSION_STR); if (strcmp(al_get_app_name(), "") == 0) { al_set_app_name(NULL); } _al_add_exit_func(shutdown_system_driver, "shutdown_system_driver"); _al_dtor_list = _al_init_destructors(); _al_init_events(); _al_init_pixels(); _al_init_iio_table(); _al_init_convert_bitmap_list(); _al_init_timers(); #ifdef ALLEGRO_CFG_SHADER_GLSL _al_glsl_init_shaders(); #endif if (active_sysdrv->vt->heartbeat_init) active_sysdrv->vt->heartbeat_init(); if (atexit_ptr && atexit_virgin) { #ifndef ALLEGRO_ANDROID atexit_ptr(al_uninstall_system); #endif atexit_virgin = false; } /* Clear errnos set while searching for config files. */ al_set_errno(0); active_sysdrv->installed = true; _al_srand(time(NULL)); return true; }
void _al_d3d_generate_display_format_list(void) { static bool fullscreen = !(al_get_new_display_flags() & ALLEGRO_FULLSCREEN); /* stop warning */ static int adapter = ~al_get_new_display_adapter(); /* stop warning */ int i; if (!_al_vector_is_empty(&eds_list) && (fullscreen == (bool)(al_get_new_display_flags() & ALLEGRO_FULLSCREEN)) && (adapter == al_get_new_display_adapter())) { return; } else if (!_al_vector_is_empty(&eds_list)) { _al_d3d_destroy_display_format_list(); } fullscreen = (al_get_new_display_flags() & ALLEGRO_FULLSCREEN) != 0; adapter = al_get_new_display_adapter(); if (adapter < 0) adapter = 0; _al_vector_init(&eds_list, sizeof(ALLEGRO_EXTRA_DISPLAY_SETTINGS *)); /* Loop through each bit combination of: * bit 0: 16/32 bit * bit 1: single-buffer * bit 2: vsync */ for (i = 0; i < 8; i++) { int format_num = !!(i & 1); int single_buffer = !!(i & 2); int vsync = !!(i & 4); int allegro_format = ALLEGRO_PIXEL_FORMAT_XRGB_8888; if (format_num == 1) allegro_format = ALLEGRO_PIXEL_FORMAT_RGB_565; D3DFORMAT d3d_format = (D3DFORMAT)_al_pixel_format_to_d3d(allegro_format); /* Count available multisample quality levels. */ DWORD quality_levels = 0; if (_al_d3d->CheckDeviceMultiSampleType(adapter, D3DDEVTYPE_HAL, d3d_format, !fullscreen, D3DMULTISAMPLE_NONMASKABLE, &quality_levels) != D3D_OK) { _al_d3d->CheckDeviceMultiSampleType(adapter, D3DDEVTYPE_REF, d3d_format, !fullscreen, D3DMULTISAMPLE_NONMASKABLE, &quality_levels); } /* Loop through available depth/stencil formats. */ for (int j = 0; j < D3D_DEPTH_FORMATS; j++) { if (j == 0 || IsDepthFormatExisting( depth_stencil_formats[j].format, d3d_format)) { DEPTH_STENCIL_DESC *ds = depth_stencil_formats + j; for (int k = 0; k < (int)quality_levels + 1; k++) { ALLEGRO_EXTRA_DISPLAY_SETTINGS *eds, **peds; peds = (ALLEGRO_EXTRA_DISPLAY_SETTINGS **)_al_vector_alloc_back(&eds_list); eds = *peds = (ALLEGRO_EXTRA_DISPLAY_SETTINGS *)al_malloc(sizeof *eds); memset(eds->settings, 0, sizeof(int) * ALLEGRO_DISPLAY_OPTIONS_COUNT); eds->settings[ALLEGRO_COMPATIBLE_DISPLAY] = 1; if (format_num == 0) { eds->settings[ALLEGRO_RED_SIZE] = 8; eds->settings[ALLEGRO_GREEN_SIZE] = 8; eds->settings[ALLEGRO_BLUE_SIZE] = 8; eds->settings[ALLEGRO_RED_SHIFT] = 16; eds->settings[ALLEGRO_GREEN_SHIFT] = 8; eds->settings[ALLEGRO_BLUE_SHIFT] = 0; eds->settings[ALLEGRO_COLOR_SIZE] = 32; } else if (format_num == 1) { eds->settings[ALLEGRO_RED_SIZE] = 5; eds->settings[ALLEGRO_GREEN_SIZE] = 6; eds->settings[ALLEGRO_BLUE_SIZE] = 5; eds->settings[ALLEGRO_RED_SHIFT] = 11; eds->settings[ALLEGRO_GREEN_SHIFT] = 5; eds->settings[ALLEGRO_BLUE_SHIFT] = 0; eds->settings[ALLEGRO_COLOR_SIZE] = 16; } if (single_buffer) { eds->settings[ALLEGRO_SINGLE_BUFFER] = 1; eds->settings[ALLEGRO_UPDATE_DISPLAY_REGION] = 1; } if (vsync) { eds->settings[ALLEGRO_VSYNC] = 1; } eds->settings[ALLEGRO_DEPTH_SIZE] = ds->d; eds->settings[ALLEGRO_STENCIL_SIZE] = ds->s; if (k > 1) { eds->settings[ALLEGRO_SAMPLE_BUFFERS] = 1; // TODO: Is it ok to use the quality level here? eds->settings[ALLEGRO_SAMPLES] = k; } } } } } ALLEGRO_INFO("found %d format combinations\n", _al_vector_size(&eds_list)); }
/* Function: al_create_display */ ALLEGRO_DISPLAY *al_create_display(int w, int h) { ALLEGRO_SYSTEM *system; ALLEGRO_DISPLAY_INTERFACE *driver; ALLEGRO_DISPLAY *display; ALLEGRO_EXTRA_DISPLAY_SETTINGS *settings; int flags; system = al_get_system_driver(); driver = system->vt->get_display_driver(); if (!driver) { ALLEGRO_ERROR("Failed to create display (no display driver)\n"); return NULL; } display = driver->create_display(w, h); if (!display) { ALLEGRO_ERROR("Failed to create display (NULL)\n"); return NULL; } ASSERT(display->vt); settings = &display->extra_settings; flags = settings->required | settings->suggested; if (!(flags & (1 << ALLEGRO_AUTO_CONVERT_BITMAPS))) { settings->settings[ALLEGRO_AUTO_CONVERT_BITMAPS] = 1; } display->min_w = 0; display->min_h = 0; display->max_w = 0; display->max_h = 0; display->use_constraints = false; display->vertex_cache = 0; display->num_cache_vertices = 0; display->cache_enabled = false; display->vertex_cache_size = 0; display->cache_texture = 0; al_identity_transform(&display->projview_transform); display->default_shader = NULL; _al_vector_init(&display->display_invalidated_callbacks, sizeof(void *)); _al_vector_init(&display->display_validated_callbacks, sizeof(void *)); display->render_state.write_mask = ALLEGRO_MASK_RGBA | ALLEGRO_MASK_DEPTH; display->render_state.depth_test = false; display->render_state.depth_function = ALLEGRO_RENDER_LESS; display->render_state.alpha_test = false; display->render_state.alpha_function = ALLEGRO_RENDER_ALWAYS; display->render_state.alpha_test_value = 0; _al_vector_init(&display->bitmaps, sizeof(ALLEGRO_BITMAP*)); if (settings->settings[ALLEGRO_COMPATIBLE_DISPLAY]) { al_set_target_bitmap(al_get_backbuffer(display)); } else { ALLEGRO_DEBUG("ALLEGRO_COMPATIBLE_DISPLAY not set\n"); _al_set_current_display_only(display); } if (display->flags & ALLEGRO_PROGRAMMABLE_PIPELINE) { display->default_shader = _al_create_default_shader(display->flags); if (!display->default_shader) { al_destroy_display(display); return NULL; } al_use_shader(display->default_shader); } /* Clear the screen */ if (settings->settings[ALLEGRO_COMPATIBLE_DISPLAY]) { al_clear_to_color(al_map_rgb(0, 0, 0)); /* TODO: * on iphone, don't kill the initial splashscreen - in fact, it's also * annoying in linux to have an extra black frame as first frame and I * suppose we never really want it */ #if 0 al_flip_display(); #endif } if (settings->settings[ALLEGRO_AUTO_CONVERT_BITMAPS]) { /* We convert video bitmaps to memory bitmaps when the display is * destroyed, so seems only fair to re-convertt hem when the * display is re-created again. */ al_convert_memory_bitmaps(); } return display; }
static bool wgl_resize_helper(ALLEGRO_DISPLAY *d, int width, int height) { ALLEGRO_DISPLAY_WGL *wgl_disp = (ALLEGRO_DISPLAY_WGL *)d; ALLEGRO_DISPLAY *ogl_disp = (ALLEGRO_DISPLAY *)d; ALLEGRO_DISPLAY_WIN *win_disp = (ALLEGRO_DISPLAY_WIN *)d; int full_w, full_h; ALLEGRO_MONITOR_INFO mi; int adapter = al_get_new_display_adapter(); if (adapter < 0) adapter = 0; al_get_monitor_info(adapter, &mi); full_w = mi.x2 - mi.x1; full_h = mi.y2 - mi.y1; if ((d->flags & ALLEGRO_FULLSCREEN_WINDOW) && (full_w != width || full_h != height)) { win_disp->toggle_w = width; win_disp->toggle_h = height; return true; } win_disp->can_acknowledge = false; if (d->flags & ALLEGRO_FULLSCREEN) { ALLEGRO_BITMAP *target_bmp; _AL_VECTOR disp_bmps; bool was_backbuffer = false; size_t i; target_bmp = al_get_target_bitmap(); if (target_bmp->vt) was_backbuffer = ((ALLEGRO_BITMAP_OGL*)target_bmp)->is_backbuffer; /* Remeber display bitmaps. */ _al_vector_init(&disp_bmps, sizeof(ALLEGRO_BITMAP*)); for (i = 0; i < _al_vector_size(&d->bitmaps); i++) { ALLEGRO_BITMAP **dis = _al_vector_ref(&d->bitmaps, i); ALLEGRO_BITMAP **mem = _al_vector_alloc_back(&disp_bmps); *mem = *dis; } /* This flag prevents from switching to desktop resolution in between. */ _wgl_do_not_change_display_mode = true; destroy_display_internals(wgl_disp); _wgl_do_not_change_display_mode = false; d->w = width; d->h = height; if (!create_display_internals(wgl_disp)) return false; /* Reupload bitmaps. */ while (_al_vector_is_nonempty(&disp_bmps)) { ALLEGRO_BITMAP **back = _al_vector_ref_back(&disp_bmps); _al_convert_to_display_bitmap(*back); _al_vector_delete_at(&disp_bmps, _al_vector_size(&disp_bmps) - 1); } /* We have a new backbuffer now. */ if (was_backbuffer) al_set_target_bitmap(al_get_backbuffer(d)); } else { RECT win_size; WINDOWINFO wi; win_size.left = 0; win_size.top = 0; win_size.right = width; win_size.bottom = height; wi.cbSize = sizeof(WINDOWINFO); GetWindowInfo(win_disp->window, &wi); AdjustWindowRectEx(&win_size, wi.dwStyle, false, wi.dwExStyle); if (!SetWindowPos(win_disp->window, HWND_TOP, 0, 0, win_size.right - win_size.left, win_size.bottom - win_size.top, SWP_NOMOVE|SWP_NOZORDER)) return false; PostMessage(win_disp->window, WM_USER+0, 0, 0); d->w = width; d->h = height; if (!(d->flags & ALLEGRO_FULLSCREEN_WINDOW)) { win_disp->toggle_w = width; win_disp->toggle_h = height; } _al_ogl_resize_backbuffer(ogl_disp->ogl_extras->backbuffer, width, height); setup_gl(d); } return true; }
/* Function: al_create_display */ ALLEGRO_DISPLAY *al_create_display(int w, int h) { ALLEGRO_SYSTEM *system; ALLEGRO_DISPLAY_INTERFACE *driver; ALLEGRO_DISPLAY *display; ALLEGRO_EXTRA_DISPLAY_SETTINGS *eds; eds = _al_get_new_display_settings(); /* We cannot depend on al_reset_new_display_options() having been called * anywhere because al_create_display() may be called from new threads. */ if (!eds) al_reset_new_display_options(); else _al_fill_display_settings(eds); system = al_get_system_driver(); driver = system->vt->get_display_driver(); display = driver->create_display(w, h); if (!display) { ALLEGRO_DEBUG("Failed to create display (NULL)\n"); return NULL; } display->vertex_cache = 0; display->num_cache_vertices = 0; display->cache_enabled = false; display->vertex_cache_size = 0; display->cache_texture = 0; al_identity_transform(&display->cur_transform); _al_initialize_blender(&display->cur_blender); _al_vector_init(&display->bitmaps, sizeof(ALLEGRO_BITMAP*)); al_set_current_display(display); /* Clear the screen */ #ifndef ALLEGRO_GP2XWIZ if (display->extra_settings.settings[ALLEGRO_COMPATIBLE_DISPLAY]) al_clear_to_color(al_map_rgb(0, 0, 0)); #else al_clear_to_color(al_map_rgb(0, 0, 0)); #endif /* on iphone, don't kill the initial splashscreen */ #ifndef ALLEGRO_IPHONE al_flip_display(); #endif /* Clear the backbuffer */ #ifndef ALLEGRO_GP2XWIZ if (display->extra_settings.settings[ALLEGRO_COMPATIBLE_DISPLAY]) al_clear_to_color(al_map_rgb(0, 0, 0)); #else al_clear_to_color(al_map_rgb(0, 0, 0)); #endif #ifndef ALLEGRO_IPHONE al_flip_display(); #endif al_set_window_title(al_get_appname()); return display; }