User Profile

As part of a hobby project, I'm working on a 2D game engine that will draw each pixel every frame, using a color from a palette. I am looking for a way to do that while maintaining a reasonable frame rate (60fps being the minimum). Without any game-logic in place, I am updating the values of my pixels with some value form the palette. I'm currently taking the mod of an index, to (hopefully) prevent the compiler from doing some loop-optimisation it could do with a fixed value. My very naive implementation of updating the bytes in the pixel array goes like this. On an iPhone 12 Pro, each run of updating all pixel values takes on average 43 ms, while on a simulator running on an M1 mac, it takes 15 ms. Both unacceptable, as that would leave not for any additional game logic (which would be much more operations than taking the mod of an Int). I was planning to look into Metal and set up a surface, but clearly the bottleneck here is the CPU, so if I can optimize this code, I could go for a higher-level framework. Any suggestions on a performant way to write this many bytes much, much faster (parallelisation is not an option)? struct BGRA { let blue: UInt8 let green: UInt8 let red: UInt8 let alpha: UInt8 } let BGRAPallet = [ BGRA(blue: 124, green: 124, red: 124, alpha: 0xff), BGRA(blue: 252, green: 0, red: 0, alpha: 0xff), // ... 62 more values in my code, omitting here for brevity ] private func test() { let pixelBufferPtr = UnsafeMutableBufferPointer<BGRA>.allocate(capacity: screenWidth * screenHeight) let runCount = 1000 let start = Date.now for _ in 0 ..< runCount { for index in 0 ..< pixelBufferPtr.count { pixelBufferPtr[index] = BGRAPallet[index % BGRAPallet.count] } } let elapsed = Date.now.timeIntervalSince(start) print("Average time per run: \((Int(elapsed) * 1000) / runCount) ms") }

I'm pretty sure I'm missing something completely obvious, but I can't see what. I watched WWDC session, read the Swift evolution blog, and they all make sense, but still it doesn't click for me. Please help me out here :) . I'm diving into adopting the 'new' async/await style of coding (I know, it's old news at this point, but I could only get to it now), and so I'm all pumped to get my code to go eleven and therefore I wrote a small data-downloader class. It has one method, well two: one oldskool function with a completionHandler, and one new style async/await one. When using the oldskool one, it works as everyone would expect: print(1) dataFetcher.fetchSomeData { print(2) let data = $0 // process data ... print(3) } print(4) The output is, unsurprisingly: 1 4 2 3 Now, when I use my new style function: let data = await dataFetcher.fetchSomeData() // process data ... Xcode gives me an error: 'async' call in a function that does not support concurrency That makes sense, I am calling this in the viewDidLoad() method of a UIViewController subclass. Can't mark viewDidLoad() as await, as super's implementation is not async. No problem, let me wrap it in Task: print(1) Task { print(2) let data = await dataFetcher.fetchSomeData() // process data ... print(3) } print(4) No errors, and this code works exactly as expected, the output is: 1 4 2 3 So now I am wondering: why take the effort of changing/adding code for async/await style function that ultimately end up requiring exactly the same amount of code, and is exactly as non-linear as completionHandlers? Note that the dataFetcher only has one property, an instance ofURLSession, so I am also not even managing my own queues or threads in the oldskool method vs the new one. They just wrap URLSession's functions: func dataTask(with request: URLRequest, completionHandler: @escaping (Data?, URLResponse?, Error?) -> Void) -> URLSessionDataTask and func download(for request: URLRequest, delegate: URLSessionTaskDelegate? = nil) async throws -> (URL, URLResponse) Is async/await useful only with SwiftUI maybe? What am I missing here? Please help me see the light.

In my app, users can select from a range of UI color-palettes to customize the look of the app to suite their preference. The app's root viewcontroller is a UINavigationController (this app is not using SwiftUI, nor has it adopted UIScene yet). However, I noticed only the first time (to be specific: this is in the appDelegate's application(:didFinishLaunchingWithOptions:), so before anything is actually rendered to the screen) the appearance settings are applied, but subsequent changes do not take effect. However, the following code seems to 'fix' the issue: self.window?.rootViewController = nil self.updateAppearance() self.window?.rootViewController = navigationController This to me seems hacky/kludgy and unlikely to be a sustainable 'fix', and I think it indicates that the appearance information is only taken into account when a view(controller) gets inserted into the view(controller) hierarchy, in other words: when it gets drawn. So then the question would be: how to tell a UINavigationController / Bar to redraw using the updated appearance settings? I'm sure I'm overlooking something relatively simple (as I imagine this kind of thing is something many apps do to support darkmode), but alas, I can't seem to find it. I setup a small test-project to isolate this issue. It has only one custom viewcontroller (ContentViewController) which only sets the backgroundColor in viewDidLoad(), and an AppDelegate (code below). No storyboards, no UIScene related things. So, here is the minimal code that reproduces my issue: AppDelegate.swift: import UIKit @main class AppDelegate: UIResponder, UIApplicationDelegate { var window: UIWindow? var rootNavigationController: UINavigationController? let contentViewController = ViewController() let timer = DispatchSource.makeTimerSource(queue: DispatchQueue.main) func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool { window = UIWindow() let navigationController = UINavigationController(rootViewController: contentViewController) rootNavigationController = navigationController window?.rootViewController = navigationController window?.makeKeyAndVisible() // initial setup of appearance, this first call will take effect as expected updateAppearance() // setup a timer to repeatedly change the appearance of the navigationbar timer.setEventHandler { /// ! uncommenting this line and the one after `self.updateAppearance()` /// will cause `self.updateAppearance()` to take effect as expected // self.window?.rootViewController = nil self.updateAppearance() //self.window?.rootViewController = navigationController } timer.schedule(deadline: .now(), repeating: .seconds(2), leeway: .milliseconds(50)) timer.resume() return true } // some vars to automatically toggle between colors / textstyles var colorIndex = 0 let colors = [ UIColor.blue, UIColor.yellow] let textStyles: [UIFont.TextStyle] = [.title3, .body] func updateAppearance() { let color = colors[colorIndex] let textStyle = textStyles[colorIndex] contentViewController.title = "bgColor: \(colorIndex) \(textStyle.rawValue)" colorIndex = (colorIndex == 0) ? 1 : 0 let textColor = colors[colorIndex] self.rootNavigationController?.navigationBar.isTranslucent = false let navigationBarAppearance = UINavigationBarAppearance() navigationBarAppearance.configureWithOpaqueBackground() navigationBarAppearance.backgroundColor = color         let textAttributes: [NSAttributedString.Key : Any] =         [.font: UIFont.preferredFont(forTextStyle: textStyle),          .foregroundColor: textColor ] navigationBarAppearance.titleTextAttributes = textAttributes UINavigationBar.appearance().standardAppearance = navigationBarAppearance UINavigationBar.appearance().compactAppearance = navigationBarAppearance UINavigationBar.appearance().scrollEdgeAppearance = navigationBarAppearance } } ViewController: import UIKit class ViewController: UIViewController {     override func viewDidLoad()     {         super.viewDidLoad()         view.backgroundColor = UIColor.lightGray     } }