#import "allegroAppDelegate.h" #import "EAGLView.h" #import #include #include "allegro5/allegro_opengl.h" #include "allegro5/allegro_iphone.h" #include "allegro5/internal/aintern_opengl.h" ALLEGRO_DEBUG_CHANNEL("iphone") void _al_iphone_run_user_main(void); static allegroAppDelegate *global_delegate; static UIApplication *app = NULL; static volatile bool waiting_for_program_halt = false; static bool disconnect_wait = false; static UIScreen *airplay_screen = NULL; static bool airplay_connected = false; ALLEGRO_MUTEX *_al_iphone_display_hotplug_mutex = NULL; /* Screen handling */ @interface iphone_screen : NSObject { @public int adapter; UIScreen *screen; UIWindow *window; ViewController *vc; EAGLView *view; ALLEGRO_DISPLAY *display; } @end @implementation iphone_screen @end void _al_iphone_disconnect(ALLEGRO_DISPLAY *display) { (void)display; disconnect_wait = false; } static NSMutableArray *iphone_screens; static int iphone_get_adapter(ALLEGRO_DISPLAY *display) { ALLEGRO_DISPLAY_IPHONE *d = (ALLEGRO_DISPLAY_IPHONE *)display; return d->extra->adapter; } static iphone_screen *iphone_get_screen_by_adapter(int adapter) { al_lock_mutex(_al_iphone_display_hotplug_mutex); int num = [iphone_screens count]; int i; iphone_screen *ret = NULL; for (i = 0; i < num; i++) { iphone_screen *scr = [iphone_screens objectAtIndex:i]; if (scr->adapter == adapter) { ret = scr; break; } } al_unlock_mutex(_al_iphone_display_hotplug_mutex); return ret; } static iphone_screen *iphone_get_screen(ALLEGRO_DISPLAY *display) { int adapter = iphone_get_adapter(display); return iphone_get_screen_by_adapter(adapter); } bool _al_iphone_is_display_connected(ALLEGRO_DISPLAY *display) { iphone_screen *scr = iphone_get_screen(display); return scr && (scr->display == display); } static void iphone_remove_screen(UIScreen *screen) { al_lock_mutex(_al_iphone_display_hotplug_mutex); int num_screens = [iphone_screens count]; int i; for (i = 1; i < num_screens; i++) { iphone_screen *scr = iphone_get_screen_by_adapter(i); if (scr->screen == screen) { [iphone_screens removeObjectAtIndex:i]; [scr release]; break; } } al_unlock_mutex(_al_iphone_display_hotplug_mutex); } void _al_iphone_destroy_screen(ALLEGRO_DISPLAY *display) { ALLEGRO_DISPLAY_IPHONE *d = (ALLEGRO_DISPLAY_IPHONE *)display; if (d->extra->adapter == 0) { global_delegate->main_display = NULL; } al_free(d->extra); } // create iphone_screen for all currently attached screens static void iphone_create_screens(void) { iphone_screens = [[NSMutableArray alloc] init]; _al_iphone_display_hotplug_mutex = al_create_mutex_recursive(); if ([UIScreen respondsToSelector:NSSelectorFromString(@"screens")]) { int num_screens; int i; num_screens = [[UIScreen screens] count];; for (i = 0; i < num_screens && i < 2; i++) { if (i == 1) { airplay_screen = [[UIScreen screens] objectAtIndex:i]; continue; } [global_delegate add_screen:[[UIScreen screens] objectAtIndex:i]]; } } else { [global_delegate add_screen:[UIScreen mainScreen]]; } } /* Function: al_iphone_get_window */ UIWindow *al_iphone_get_window(ALLEGRO_DISPLAY *display) { al_lock_mutex(_al_iphone_display_hotplug_mutex); iphone_screen *scr = iphone_get_screen(display); if (scr == NULL) { al_unlock_mutex(_al_iphone_display_hotplug_mutex); return NULL; } al_unlock_mutex(_al_iphone_display_hotplug_mutex); return scr->window; } /* Function: al_iphone_get_view */ UIView *al_iphone_get_view(ALLEGRO_DISPLAY *display) { iphone_screen *scr = iphone_get_screen(display); if (scr == NULL) { return NULL; } return scr->vc.view; } static int iphone_orientation_to_allegro(UIDeviceOrientation orientation) { switch (orientation) { case UIDeviceOrientationPortrait: return ALLEGRO_DISPLAY_ORIENTATION_0_DEGREES; case UIDeviceOrientationPortraitUpsideDown: return ALLEGRO_DISPLAY_ORIENTATION_180_DEGREES; case UIDeviceOrientationLandscapeRight: return ALLEGRO_DISPLAY_ORIENTATION_90_DEGREES; case UIDeviceOrientationLandscapeLeft: return ALLEGRO_DISPLAY_ORIENTATION_270_DEGREES; case UIDeviceOrientationFaceUp: return ALLEGRO_DISPLAY_ORIENTATION_FACE_UP; case UIDeviceOrientationFaceDown: return ALLEGRO_DISPLAY_ORIENTATION_FACE_DOWN; default: return ALLEGRO_DISPLAY_ORIENTATION_UNKNOWN; } } static void iphone_send_orientation_event(ALLEGRO_DISPLAY* display, int orientation) { _al_event_source_lock(&display->es); if (_al_event_source_needs_to_generate_event(&display->es)) { ALLEGRO_EVENT event; event.display.type = ALLEGRO_EVENT_DISPLAY_ORIENTATION; event.display.timestamp = al_get_time(); event.display.source = display; event.display.orientation = orientation; _al_event_source_emit_event(&display->es, &event); } _al_event_source_unlock(&display->es); } void _al_iphone_acknowledge_drawing_halt(ALLEGRO_DISPLAY *display) { (void)display; waiting_for_program_halt = false; } /* Function: al_iphone_set_statusbar_orientation */ void al_iphone_set_statusbar_orientation(int o) { UIInterfaceOrientation orientation = UIInterfaceOrientationPortrait; if (o == ALLEGRO_IPHONE_STATUSBAR_ORIENTATION_PORTRAIT) orientation = UIInterfaceOrientationPortrait; else if (o == ALLEGRO_IPHONE_STATUSBAR_ORIENTATION_PORTRAIT_UPSIDE_DOWN) orientation = UIInterfaceOrientationPortraitUpsideDown; else if (o == ALLEGRO_IPHONE_STATUSBAR_ORIENTATION_LANDSCAPE_RIGHT) orientation = UIInterfaceOrientationLandscapeRight; else if (o == ALLEGRO_IPHONE_STATUSBAR_ORIENTATION_LANDSCAPE_LEFT) orientation = UIInterfaceOrientationLandscapeLeft; [app setStatusBarOrientation:orientation animated:NO]; } bool _al_iphone_add_view(ALLEGRO_DISPLAY *display) { ALLEGRO_DISPLAY_IPHONE *d = (ALLEGRO_DISPLAY_IPHONE *)display; d->extra = al_calloc(1, sizeof(ALLEGRO_DISPLAY_IPHONE_EXTRA)); int adapter = al_get_new_display_adapter(); if (adapter < 0) adapter = 0; d->extra->adapter = adapter; /* This is the same as * [global_delegate.view add_view]; * except it will run in the main thread. */ [global_delegate performSelectorOnMainThread: @selector(add_view:) withObject: [NSValue valueWithPointer:display] waitUntilDone: YES]; if (d->extra->failed) { return false; } /* There are two ways to get orientation information under ios - but they seem * to be mutually exclusive (just my experience, the documentation never says * they are). * One method has 6 orientations including face up and face down and is * independent of the screen orientations, just directly using the accelerometer * to determine how the device is positioned relative to gravity. The other * method has 4 orientations and simply tells how the view controller thinks * the user interface should be rotated. * * Supporting both at the same time is a) slightly confusing since we'd need * two sets of query functions and events and b) does not seem to work due to * the mutual exclusivity. * * Now normally using just the 4-orientation way would appear to be the best * choice as you can always use the accelerometer anyway to get the actual * 3d orientation and otherwise are likely more concerned with the orientation * things are being displayed at right now (instead of just seeing FACE_UP which * would not tell you). * * But to stay compatible with how things worked at first we still support the * 6-orientations way as well - but only if the display has a sole supported * orientation of ALLEGRO_DISPLAY_ORIENTATION_0_DEGREES. */ ALLEGRO_EXTRA_DISPLAY_SETTINGS *options = &display->extra_settings; int supported = options->settings[ALLEGRO_SUPPORTED_ORIENTATIONS]; if (supported == ALLEGRO_DISPLAY_ORIENTATION_0_DEGREES) { [[UIDevice currentDevice] beginGeneratingDeviceOrientationNotifications]; } return true; } void _al_iphone_make_view_current(ALLEGRO_DISPLAY *display) { iphone_screen *scr = iphone_get_screen(display); if (scr) [scr->view make_current]; } void _al_iphone_recreate_framebuffer(ALLEGRO_DISPLAY *display) { iphone_screen *scr = iphone_get_screen(display); if (scr) { EAGLView *view = scr->view; [view destroyFramebuffer]; [view createFramebuffer]; display->w = view.backingWidth; display->h = view.backingHeight; _al_ogl_resize_backbuffer(display->ogl_extras->backbuffer, display->w, display->h); } } void _al_iphone_flip_view(ALLEGRO_DISPLAY *display) { iphone_screen *scr = iphone_get_screen(display); if (scr) [scr->view flip]; } void _al_iphone_reset_framebuffer(ALLEGRO_DISPLAY *display) { iphone_screen *scr = iphone_get_screen(display); if (scr) [scr->view reset_framebuffer]; } /* Use a frequency to start receiving events at the freuqency, 0 to shut off * the accelerometer (according to Apple, it drains a bit of battery while on). */ void _al_iphone_accelerometer_control(int frequency) { if (frequency) { [[UIAccelerometer sharedAccelerometer] setUpdateInterval:(1.0 / frequency)]; [[UIAccelerometer sharedAccelerometer] setDelegate:global_delegate]; } else { [[UIAccelerometer sharedAccelerometer] setDelegate:nil]; } } int _al_iphone_get_num_video_adapters(void) { if (![UIScreen respondsToSelector:NSSelectorFromString(@"screens")]) { return 1; } return [[UIScreen screens] count]; } void _al_iphone_get_screen_size(int adapter, int *w, int *h) { iphone_screen *scr = iphone_get_screen_by_adapter(adapter); UIScreen *screen = scr->screen; if (NULL != screen) { CGRect bounds = [screen bounds]; CGFloat scale = 1.0f; if (adapter == 0 && [screen respondsToSelector:NSSelectorFromString(@"scale")]) { scale = [screen scale]; } *w = (int)(bounds.size.width * scale); *h = (int)(bounds.size.height * scale); } else { ASSERT("You should never see this message, unless Apple changed their policy and allows for removing screens from iDevices." && false); } } int _al_iphone_get_orientation(ALLEGRO_DISPLAY *display) { if (display) { ALLEGRO_EXTRA_DISPLAY_SETTINGS *options = &display->extra_settings; int supported = options->settings[ALLEGRO_SUPPORTED_ORIENTATIONS]; if (supported != ALLEGRO_DISPLAY_ORIENTATION_0_DEGREES) { iphone_screen *scr = iphone_get_screen(display); UIInterfaceOrientation o = scr->vc.interfaceOrientation; UIDeviceOrientation od = (int)o; /* They are compatible. */ return iphone_orientation_to_allegro(od); } } UIDevice* device = [UIDevice currentDevice]; if (NULL != device) return iphone_orientation_to_allegro([device orientation]); else return ALLEGRO_DISPLAY_ORIENTATION_UNKNOWN; } @implementation allegroAppDelegate + (void)run:(int)argc:(char **)argv { UIApplicationMain(argc, argv, nil, @"allegroAppDelegate"); } - (void)orientation_change:(NSNotification *)notification { (void)notification; int orientation = _al_iphone_get_orientation(NULL); if (main_display == NULL) return; iphone_send_orientation_event(main_display, orientation); } - (void)applicationDidFinishLaunching:(UIApplication *)application { ALLEGRO_INFO("App launched.\n"); global_delegate = self; app = application; iphone_create_screens(); // Register for device orientation notifications // Note: The notifications won't be generated unless they are enabled, which // we do elsewhere. [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(orientation_change:) name:UIDeviceOrientationDidChangeNotification object:nil]; // Register for screen connect/disconnect notifications [self setupScreenConnectionNotificationHandlers]; _al_iphone_run_user_main(); } /* This may never get called on iOS 4 */ - (void)applicationWillTerminate:(UIApplication *)application { (void)application; ALLEGRO_EVENT event; ALLEGRO_DISPLAY *d = main_display; ALLEGRO_SYSTEM_IPHONE *iphone = (void *)al_get_system_driver(); iphone->wants_shutdown = true; ALLEGRO_INFO("Terminating.\n"); [[UIDevice currentDevice] endGeneratingDeviceOrientationNotifications]; _al_event_source_lock(&d->es); if (_al_event_source_needs_to_generate_event(&d->es)) { event.display.type = ALLEGRO_EVENT_DISPLAY_CLOSE; event.display.timestamp = al_get_time(); _al_event_source_emit_event(&d->es, &event); } _al_event_source_unlock(&d->es); /* When this method returns, the application terminates - so lets wait a bit * so the user app can shutdown properly, e.g. to save state as is usually * required by iphone apps. */ _al_iphone_await_termination(); } - (void)applicationWillResignActive:(UIApplication *)application { ALLEGRO_DISPLAY *d = main_display; ALLEGRO_EVENT event; (void)application; ALLEGRO_INFO("Application becoming inactive.\n"); _al_event_source_lock(&d->es); if (_al_event_source_needs_to_generate_event(&d->es)) { event.display.type = ALLEGRO_EVENT_DISPLAY_SWITCH_OUT; event.display.timestamp = al_current_time(); _al_event_source_emit_event(&d->es, &event); } _al_event_source_unlock(&d->es); } - (void)applicationDidBecomeActive:(UIApplication *)application { ALLEGRO_DISPLAY *d = main_display; ALLEGRO_EVENT event; (void)application; ALLEGRO_INFO("Application becoming active.\n"); if (!d) return; _al_event_source_lock(&d->es); if (_al_event_source_needs_to_generate_event(&d->es)) { event.display.type = ALLEGRO_EVENT_DISPLAY_SWITCH_IN; event.display.timestamp = al_current_time(); _al_event_source_emit_event(&d->es, &event); } _al_event_source_unlock(&d->es); } - (void)applicationDidEnterBackground:(UIApplication *)application { ALLEGRO_DISPLAY *d = main_display; ALLEGRO_EVENT event; (void)application; ALLEGRO_INFO("Application entering background.\n"); waiting_for_program_halt = true; _al_event_source_lock(&d->es); if (_al_event_source_needs_to_generate_event(&d->es)) { event.display.type = ALLEGRO_EVENT_DISPLAY_HALT_DRAWING; event.display.timestamp = al_current_time(); _al_event_source_emit_event(&d->es, &event); } _al_event_source_unlock(&d->es); while (waiting_for_program_halt) { // do nothing, this should be quick al_rest(0.001); } } - (void)applicationWillEnterForeground:(UIApplication *)application { ALLEGRO_DISPLAY *d = main_display; ALLEGRO_EVENT event; (void)application; ALLEGRO_INFO("Application coming back to foreground.\n"); _al_event_source_lock(&d->es); if (_al_event_source_needs_to_generate_event(&d->es)) { event.display.type = ALLEGRO_EVENT_DISPLAY_RESUME_DRAWING; event.display.timestamp = al_current_time(); _al_event_source_emit_event(&d->es, &event); } _al_event_source_unlock(&d->es); } /* Note: This must be called from the main thread. Ask Apple why - but I tried * it and otherwise things simply don't work (the screen just stays black). */ - (void)add_view:(NSValue *)value { ALLEGRO_DISPLAY *d = [value pointerValue]; ALLEGRO_DISPLAY_IPHONE *disp = (ALLEGRO_DISPLAY_IPHONE *)d; int adapter = iphone_get_adapter(d); if (adapter == 0) { main_display = d; } iphone_screen *scr = iphone_get_screen_by_adapter(adapter); scr->display = d; ViewController *vc = scr->vc; vc->display = d; EAGLView *view = (EAGLView *)vc.view; [view set_allegro_display:d]; [scr->window addSubview:view]; if (adapter == 0) { [view becomeFirstResponder]; [scr->window makeKeyAndVisible]; } else { scr->window.hidden = NO; } disp->extra->failed = false; disp->extra->vc = vc; disp->extra->window = scr->window; } - (void)accelerometer:(UIAccelerometer*)accelerometer didAccelerate:(UIAcceleration*)acceleration { (void)accelerometer; _al_iphone_generate_joystick_event(acceleration.x, acceleration.y, acceleration.z); } - (void)setupScreenConnectionNotificationHandlers { /* Screen connect/disconnect notifications were added in iOS 3.2 */ NSString *reqSysVer = @"3.2"; NSString *currSysVer = [[UIDevice currentDevice] systemVersion]; BOOL osVersionSupported = ([currSysVer compare:reqSysVer options:NSNumericSearch] != NSOrderedAscending); if (osVersionSupported) { NSNotificationCenter* center = [NSNotificationCenter defaultCenter]; [center addObserver:self selector:@selector(handleScreenConnectNotification:) name:UIScreenDidConnectNotification object:nil]; [center addObserver:self selector:@selector(handleScreenDisconnectNotification:) name:UIScreenDidDisconnectNotification object:nil]; } } - (void)handleScreenConnectNotification:(NSNotification*)aNotification { airplay_screen = [aNotification object]; ALLEGRO_DISPLAY *display = main_display; if (!display) return; _al_event_source_lock(&display->es); if (_al_event_source_needs_to_generate_event(&display->es)) { ALLEGRO_EVENT event; event.display.type = ALLEGRO_EVENT_DISPLAY_CONNECTED; event.display.timestamp = al_get_time(); event.display.source = display; _al_event_source_emit_event(&display->es, &event); } _al_event_source_unlock(&display->es); } - (void)handleScreenDisconnectNotification:(NSNotification*)aNotification { ALLEGRO_DISPLAY *display = main_display; ALLEGRO_DISPLAY_IPHONE *idisplay = (ALLEGRO_DISPLAY_IPHONE *)display; ALLEGRO_DISPLAY_IPHONE_EXTRA *extra; if (!display) return; extra = idisplay->extra; extra->disconnected = true; disconnect_wait = true; _al_event_source_lock(&display->es); if (_al_event_source_needs_to_generate_event(&display->es)) { ALLEGRO_EVENT event; event.display.type = ALLEGRO_EVENT_DISPLAY_DISCONNECTED; event.display.timestamp = al_get_time(); event.display.source = display; _al_event_source_emit_event(&display->es, &event); } _al_event_source_unlock(&display->es); if (airplay_connected) { // wait for user to destroy display while (disconnect_wait) al_rest(0.001); iphone_remove_screen([aNotification object]); airplay_connected = false; } } - (void)dealloc { [super dealloc]; } - (void)add_screen:(UIScreen *)screen { int i; if (screen == [UIScreen mainScreen]) { i = 0; } else { for (i = 0; i < (int)[[UIScreen screens] count]; i++) { if ([[UIScreen screens] objectAtIndex:i] == screen) break; } } if (i != 0) { if ([screen respondsToSelector:NSSelectorFromString(@"availableModes")]) { NSArray *a = [screen availableModes]; int j; UIScreenMode *largest = NULL; for (j = 0; j < (int)[a count]; j++) { UIScreenMode *m = [a objectAtIndex:j]; float w = m.size.width; float h = m.size.height; if ((largest == NULL) || (w+h > largest.size.width+largest.size.height)) { largest = m; } } if (largest) { screen.currentMode = largest; } } } iphone_screen *scr = iphone_get_screen_by_adapter(i); bool add = scr == NULL; UIWindow *window = [[UIWindow alloc] initWithFrame:[screen bounds]]; if ([window respondsToSelector:NSSelectorFromString(@"screen")]) { window.screen = screen; } ViewController *vc = [[ViewController alloc] init]; vc->adapter = i; [vc create_view]; // Doesn't work on iOS < 4. NSString *reqSysVer = @"4.0"; NSString *currSysVer = [[UIDevice currentDevice] systemVersion]; BOOL osVersionSupported = ([currSysVer compare:reqSysVer options:NSNumericSearch] != NSOrderedAscending); if (osVersionSupported) { window.rootViewController = vc; } if (add) scr = [[iphone_screen alloc] init]; scr->adapter = i; scr->screen = screen; scr->window = window; scr->vc = vc; scr->view = (EAGLView *)vc.view; scr->display = NULL; if (add) { al_lock_mutex(_al_iphone_display_hotplug_mutex); [iphone_screens addObject:scr]; al_unlock_mutex(_al_iphone_display_hotplug_mutex); } } @end void _al_iphone_connect_airplay(void) { [global_delegate performSelectorOnMainThread: @selector(add_screen:) withObject:airplay_screen waitUntilDone:TRUE]; airplay_connected = true; }