From 5a079a2d114f96d4847d1ee305d5b7c16eeec50e Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Sat, 27 Dec 2025 12:03:39 -0800 Subject: Initial commit --- contrib/SDL-3.2.8/src/video/uikit/SDL_uikitmodes.m | 543 +++++++++++++++++++++ 1 file changed, 543 insertions(+) create mode 100644 contrib/SDL-3.2.8/src/video/uikit/SDL_uikitmodes.m (limited to 'contrib/SDL-3.2.8/src/video/uikit/SDL_uikitmodes.m') diff --git a/contrib/SDL-3.2.8/src/video/uikit/SDL_uikitmodes.m b/contrib/SDL-3.2.8/src/video/uikit/SDL_uikitmodes.m new file mode 100644 index 0000000..d3247db --- /dev/null +++ b/contrib/SDL-3.2.8/src/video/uikit/SDL_uikitmodes.m @@ -0,0 +1,543 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +#ifdef SDL_VIDEO_DRIVER_UIKIT + +#include "SDL_uikitmodes.h" + +#include "../../events/SDL_events_c.h" + +#import + +@implementation SDL_UIKitDisplayData + +#ifndef SDL_PLATFORM_VISIONOS +- (instancetype)initWithScreen:(UIScreen *)screen +{ + if (self = [super init]) { + self.uiscreen = screen; + } + return self; +} +@synthesize uiscreen; +#endif + +@end + +@implementation SDL_UIKitDisplayModeData + +#ifndef SDL_PLATFORM_VISIONOS +@synthesize uiscreenmode; +#endif + +@end + +@interface SDL_DisplayWatch : NSObject +@end + +#ifndef SDL_PLATFORM_VISIONOS +@implementation SDL_DisplayWatch + ++ (void)start +{ + NSNotificationCenter *center = [NSNotificationCenter defaultCenter]; + + [center addObserver:self + selector:@selector(screenConnected:) + name:UIScreenDidConnectNotification + object:nil]; + [center addObserver:self + selector:@selector(screenDisconnected:) + name:UIScreenDidDisconnectNotification + object:nil]; +} + ++ (void)stop +{ + NSNotificationCenter *center = [NSNotificationCenter defaultCenter]; + + [center removeObserver:self + name:UIScreenDidConnectNotification + object:nil]; + [center removeObserver:self + name:UIScreenDidDisconnectNotification + object:nil]; +} + ++ (void)screenConnected:(NSNotification *)notification +{ + UIScreen *uiscreen = [notification object]; + UIKit_AddDisplay(uiscreen, true); +} + ++ (void)screenDisconnected:(NSNotification *)notification +{ + UIScreen *uiscreen = [notification object]; + UIKit_DelDisplay(uiscreen, true); +} + +@end +#endif + +#ifndef SDL_PLATFORM_VISIONOS +static bool UIKit_AllocateDisplayModeData(SDL_DisplayMode *mode, + UIScreenMode *uiscreenmode) +{ + SDL_UIKitDisplayModeData *data = nil; + + if (uiscreenmode != nil) { + // Allocate the display mode data + data = [[SDL_UIKitDisplayModeData alloc] init]; + if (!data) { + return SDL_OutOfMemory(); + } + + data.uiscreenmode = uiscreenmode; + } + + mode->internal = (void *)CFBridgingRetain(data); + + return true; +} +#endif + +static void UIKit_FreeDisplayModeData(SDL_DisplayMode *mode) +{ + if (mode->internal != NULL) { + CFRelease(mode->internal); + mode->internal = NULL; + } +} + +#ifndef SDL_PLATFORM_VISIONOS +static float UIKit_GetDisplayModeRefreshRate(UIScreen *uiscreen) +{ + return (float)uiscreen.maximumFramesPerSecond; +} + +static bool UIKit_AddSingleDisplayMode(SDL_VideoDisplay *display, int w, int h, + UIScreen *uiscreen, UIScreenMode *uiscreenmode) +{ + SDL_DisplayMode mode; + + SDL_zero(mode); + if (!UIKit_AllocateDisplayModeData(&mode, uiscreenmode)) { + return false; + } + + mode.w = w; + mode.h = h; + mode.pixel_density = uiscreen.nativeScale; + mode.refresh_rate = UIKit_GetDisplayModeRefreshRate(uiscreen); + mode.format = SDL_PIXELFORMAT_ABGR8888; + + if (SDL_AddFullscreenDisplayMode(display, &mode)) { + return true; + } else { + UIKit_FreeDisplayModeData(&mode); + return false; + } +} + +static bool UIKit_AddDisplayMode(SDL_VideoDisplay *display, int w, int h, + UIScreen *uiscreen, UIScreenMode *uiscreenmode, bool addRotation) +{ + if (!UIKit_AddSingleDisplayMode(display, w, h, uiscreen, uiscreenmode)) { + return false; + } + + if (addRotation) { + // Add the rotated version + if (!UIKit_AddSingleDisplayMode(display, h, w, uiscreen, uiscreenmode)) { + return false; + } + } + + return true; +} + +static CGSize GetUIScreenModeSize(UIScreen *uiscreen, UIScreenMode *mode) +{ + /* For devices such as iPhone 6/7/8 Plus, the UIScreenMode reported by iOS + * isn't the physical pixels of the display, but rather the point size times + * the scale. For example, on iOS 12.2 on iPhone 8 Plus the physical pixel + * resolution is 1080x1920, the size reported by mode.size is 1242x2208, + * the size in points is 414x736, the scale property is 3.0, and the + * nativeScale property is ~2.6087 (ie 1920.0 / 736.0). + * + * What we want for the mode size is the point size, and the pixel density + * is the native scale. + * + * Note that the iOS Simulator doesn't have this behavior for those devices. + * https://github.com/libsdl-org/SDL/issues/3220 + */ + CGSize size = mode.size; + + size.width = SDL_round(size.width / uiscreen.scale); + size.height = SDL_round(size.height / uiscreen.scale); + + return size; +} + +bool UIKit_AddDisplay(UIScreen *uiscreen, bool send_event) +{ + UIScreenMode *uiscreenmode = uiscreen.currentMode; + CGSize size = GetUIScreenModeSize(uiscreen, uiscreenmode); + SDL_VideoDisplay display; + SDL_DisplayMode mode; + + // Make sure the width/height are oriented correctly + if (UIKit_IsDisplayLandscape(uiscreen) != (size.width > size.height)) { + CGFloat height = size.width; + size.width = size.height; + size.height = height; + } + + SDL_zero(mode); + mode.w = (int)size.width; + mode.h = (int)size.height; + mode.pixel_density = uiscreen.nativeScale; + mode.format = SDL_PIXELFORMAT_ABGR8888; + mode.refresh_rate = UIKit_GetDisplayModeRefreshRate(uiscreen); + + if (!UIKit_AllocateDisplayModeData(&mode, uiscreenmode)) { + return false; + } + + SDL_zero(display); +#ifndef SDL_PLATFORM_TVOS + if (uiscreen == [UIScreen mainScreen]) { + // The natural orientation (used by sensors) is portrait + display.natural_orientation = SDL_ORIENTATION_PORTRAIT; + } else +#endif + if (UIKit_IsDisplayLandscape(uiscreen)) { + display.natural_orientation = SDL_ORIENTATION_LANDSCAPE; + } else { + display.natural_orientation = SDL_ORIENTATION_PORTRAIT; + } + display.desktop_mode = mode; + + display.HDR.SDR_white_level = 1.0f; + display.HDR.HDR_headroom = 1.0f; + +#ifndef SDL_PLATFORM_TVOS + if (@available(iOS 16.0, *)) { + if (uiscreen.currentEDRHeadroom > 1.0f) { + display.HDR.HDR_headroom = uiscreen.currentEDRHeadroom; + } else { + display.HDR.HDR_headroom = uiscreen.potentialEDRHeadroom; + } + } +#endif // !SDL_PLATFORM_TVOS + + // Allocate the display data +#ifdef SDL_PLATFORM_VISIONOS + SDL_UIKitDisplayData *data = [[SDL_UIKitDisplayData alloc] init]; +#else + SDL_UIKitDisplayData *data = [[SDL_UIKitDisplayData alloc] initWithScreen:uiscreen]; +#endif + if (!data) { + UIKit_FreeDisplayModeData(&display.desktop_mode); + return SDL_OutOfMemory(); + } + + display.internal = (SDL_DisplayData *)CFBridgingRetain(data); + if (SDL_AddVideoDisplay(&display, send_event) == 0) { + return false; + } + return true; +} +#endif + +#ifdef SDL_PLATFORM_VISIONOS +bool UIKit_AddDisplay(bool send_event){ + CGSize size = CGSizeMake(SDL_XR_SCREENWIDTH, SDL_XR_SCREENHEIGHT); + SDL_VideoDisplay display; + SDL_DisplayMode mode; + + SDL_zero(mode); + mode.w = (int)size.width; + mode.h = (int)size.height; + mode.pixel_density = 1; + mode.format = SDL_PIXELFORMAT_ABGR8888; + mode.refresh_rate = 60.0f; + + display.natural_orientation = SDL_ORIENTATION_LANDSCAPE; + + display.desktop_mode = mode; + + SDL_UIKitDisplayData *data = [[SDL_UIKitDisplayData alloc] init]; + + if (!data) { + UIKit_FreeDisplayModeData(&display.desktop_mode); + return SDL_OutOfMemory(); + } + + display.internal = (SDL_DisplayData *)CFBridgingRetain(data); + if (SDL_AddVideoDisplay(&display, send_event) == 0) { + return false; + } + return true; +} +#endif + +#ifndef SDL_PLATFORM_VISIONOS + +void UIKit_DelDisplay(UIScreen *uiscreen, bool send_event) +{ + SDL_DisplayID *displays; + int i; + + displays = SDL_GetDisplays(NULL); + if (displays) { + for (i = 0; displays[i]; ++i) { + SDL_VideoDisplay *display = SDL_GetVideoDisplay(displays[i]); + SDL_UIKitDisplayData *data = (__bridge SDL_UIKitDisplayData *)display->internal; + + if (data && data.uiscreen == uiscreen) { + CFRelease(display->internal); + display->internal = NULL; + SDL_DelVideoDisplay(displays[i], send_event); + break; + } + } + SDL_free(displays); + } +} + +bool UIKit_IsDisplayLandscape(UIScreen *uiscreen) +{ +#ifndef SDL_PLATFORM_TVOS + if (uiscreen == [UIScreen mainScreen]) { + return UIInterfaceOrientationIsLandscape([UIApplication sharedApplication].statusBarOrientation); + } else +#endif // !SDL_PLATFORM_TVOS + { + CGSize size = uiscreen.bounds.size; + return (size.width > size.height); + } +} +#endif +bool UIKit_InitModes(SDL_VideoDevice *_this) +{ + @autoreleasepool { +#ifdef SDL_PLATFORM_VISIONOS + UIKit_AddDisplay(false); +#else + for (UIScreen *uiscreen in [UIScreen screens]) { + if (!UIKit_AddDisplay(uiscreen, false)) { + return false; + } + } +#endif + +#if !defined(SDL_PLATFORM_TVOS) && !defined(SDL_PLATFORM_VISIONOS) + SDL_OnApplicationDidChangeStatusBarOrientation(); +#endif + +#ifndef SDL_PLATFORM_VISIONOS + [SDL_DisplayWatch start]; +#endif + } + + return true; +} + +bool UIKit_GetDisplayModes(SDL_VideoDevice *_this, SDL_VideoDisplay *display) +{ +#ifndef SDL_PLATFORM_VISIONOS + @autoreleasepool { + SDL_UIKitDisplayData *data = (__bridge SDL_UIKitDisplayData *)display->internal; + + bool isLandscape = UIKit_IsDisplayLandscape(data.uiscreen); + bool addRotation = (data.uiscreen == [UIScreen mainScreen]); + NSArray *availableModes = nil; + +#ifdef SDL_PLATFORM_TVOS + addRotation = false; + availableModes = @[ data.uiscreen.currentMode ]; +#else + availableModes = data.uiscreen.availableModes; +#endif + + for (UIScreenMode *uimode in availableModes) { + CGSize size = GetUIScreenModeSize(data.uiscreen, uimode); + int w = (int)size.width; + int h = (int)size.height; + + // Make sure the width/height are oriented correctly + if (isLandscape != (w > h)) { + int tmp = w; + w = h; + h = tmp; + } + + UIKit_AddDisplayMode(display, w, h, data.uiscreen, uimode, addRotation); + } + } +#endif + return true; +} + +bool UIKit_SetDisplayMode(SDL_VideoDevice *_this, SDL_VideoDisplay *display, SDL_DisplayMode *mode) +{ +#ifndef SDL_PLATFORM_VISIONOS + @autoreleasepool { + SDL_UIKitDisplayData *data = (__bridge SDL_UIKitDisplayData *)display->internal; + +#ifndef SDL_PLATFORM_TVOS + SDL_UIKitDisplayModeData *modedata = (__bridge SDL_UIKitDisplayModeData *)mode->internal; + [data.uiscreen setCurrentMode:modedata.uiscreenmode]; +#endif + + if (data.uiscreen == [UIScreen mainScreen]) { + /* [UIApplication setStatusBarOrientation:] no longer works reliably + * in recent iOS versions, so we can't rotate the screen when setting + * the display mode. */ + if (mode->w > mode->h) { + if (!UIKit_IsDisplayLandscape(data.uiscreen)) { + return SDL_SetError("Screen orientation does not match display mode size"); + } + } else if (mode->w < mode->h) { + if (UIKit_IsDisplayLandscape(data.uiscreen)) { + return SDL_SetError("Screen orientation does not match display mode size"); + } + } + } + } +#endif + return true; +} + +bool UIKit_GetDisplayUsableBounds(SDL_VideoDevice *_this, SDL_VideoDisplay *display, SDL_Rect *rect) +{ + @autoreleasepool { + SDL_UIKitDisplayData *data = (__bridge SDL_UIKitDisplayData *)display->internal; +#ifdef SDL_PLATFORM_VISIONOS + CGRect frame = CGRectMake(0, 0, SDL_XR_SCREENWIDTH, SDL_XR_SCREENHEIGHT); +#else + CGRect frame = data.uiscreen.bounds; +#endif + + /* the default function iterates displays to make a fake offset, + as if all the displays were side-by-side, which is fine for iOS. */ + if (!SDL_GetDisplayBounds(display->id, rect)) { + return false; + } + + rect->x += (int)frame.origin.x; + rect->y += (int)frame.origin.y; + rect->w = (int)frame.size.width; + rect->h = (int)frame.size.height; + } + + return true; +} + +void UIKit_QuitModes(SDL_VideoDevice *_this) +{ +#ifndef SDL_PLATFORM_VISIONOS + [SDL_DisplayWatch stop]; +#endif + + // Release Objective-C objects, so higher level doesn't free() them. + int i, j; + @autoreleasepool { + for (i = 0; i < _this->num_displays; i++) { + SDL_VideoDisplay *display = _this->displays[i]; + + UIKit_FreeDisplayModeData(&display->desktop_mode); + for (j = 0; j < display->num_fullscreen_modes; j++) { + SDL_DisplayMode *mode = &display->fullscreen_modes[j]; + UIKit_FreeDisplayModeData(mode); + } + + if (display->internal != NULL) { + CFRelease(display->internal); + display->internal = NULL; + } + } + } +} + +#if !defined(SDL_PLATFORM_TVOS) && !defined(SDL_PLATFORM_VISIONOS) +void SDL_OnApplicationDidChangeStatusBarOrientation(void) +{ + BOOL isLandscape = UIInterfaceOrientationIsLandscape([UIApplication sharedApplication].statusBarOrientation); + SDL_VideoDisplay *display = SDL_GetVideoDisplay(SDL_GetPrimaryDisplay()); + + if (display) { + SDL_DisplayMode *mode = &display->desktop_mode; + SDL_DisplayOrientation orientation = SDL_ORIENTATION_UNKNOWN; + int i; + + /* The desktop display mode should be kept in sync with the screen + * orientation so that updating a window's fullscreen state to + * fullscreen desktop keeps the window dimensions in the + * correct orientation. */ + if (isLandscape != (mode->w > mode->h)) { + SDL_DisplayMode new_mode; + SDL_copyp(&new_mode, mode); + new_mode.w = mode->h; + new_mode.h = mode->w; + + // Make sure we don't free the current display mode data + mode->internal = NULL; + + SDL_SetDesktopDisplayMode(display, &new_mode); + } + + // Same deal with the fullscreen modes + for (i = 0; i < display->num_fullscreen_modes; ++i) { + mode = &display->fullscreen_modes[i]; + if (isLandscape != (mode->w > mode->h)) { + int height = mode->w; + mode->w = mode->h; + mode->h = height; + } + } + + switch ([UIApplication sharedApplication].statusBarOrientation) { + case UIInterfaceOrientationPortrait: + orientation = SDL_ORIENTATION_PORTRAIT; + break; + case UIInterfaceOrientationPortraitUpsideDown: + orientation = SDL_ORIENTATION_PORTRAIT_FLIPPED; + break; + case UIInterfaceOrientationLandscapeLeft: + // Bug: UIInterfaceOrientationLandscapeLeft/Right are reversed - http://openradar.appspot.com/7216046 + orientation = SDL_ORIENTATION_LANDSCAPE_FLIPPED; + break; + case UIInterfaceOrientationLandscapeRight: + // Bug: UIInterfaceOrientationLandscapeLeft/Right are reversed - http://openradar.appspot.com/7216046 + orientation = SDL_ORIENTATION_LANDSCAPE; + break; + default: + break; + } + SDL_SendDisplayEvent(display, SDL_EVENT_DISPLAY_ORIENTATION, orientation, 0); + } +} +#endif // !SDL_PLATFORM_TVOS + +#endif // SDL_VIDEO_DRIVER_UIKIT -- cgit v1.2.3