serve-sim 0.1.47-beta.127.1 → 0.1.47

package/README.md

@@ -59,7 +59,7 @@ runs inside the simulator and exits with the device session.
 Duo uses one interactive RealityKit preview of the installed Xcode model, with
 live screen textures and touches mapped to each bent screen half. Apple's model
 stays in Xcode; it is not redistributed. Rotate animates the device and pose
-icons together. Motion uses a faster render target and sharpens when settled.
+icons together. Motion uses a faster 1000×900 render target and sharpens once to 1500×1350 when settled.
 Screenshots capture the active app framebuffer, including the unfolded inner display.
 
 Use the pose buttons or hold **Alt** to reveal the continuous hinge slider.

package/Sources/SimDuoRenderer/DuoRenderer.swift

@@ -8,6 +8,13 @@ import UniformTypeIdentifiers
 
 /// Renders Apple's installed V68 asset; no Apple asset is copied into the package.
 @MainActor final class DuoRenderer {
+    /// Motion target. 10:9 matches the sharpen target, so normalized anchors stay put.
+    static let previewWidth = 1000
+    static let previewHeight = 900
+    /// One-shot settle target for Retina screen text. Never 3000, and MSAA stays off:
+    /// 4× MSAA plus a 3000px idle target was the Apple Silicon CPU regression.
+    static let sharpenWidth = 1500
+    static let sharpenHeight = 1350
     private let renderer: RealityRenderer
     private let wrapper = Entity()
     private let rest = Entity()
@@ -30,7 +37,7 @@ import UniformTypeIdentifiers
     private var screenTextures: [String: TextureResource] = [:]
     private var screenFrames: [String: Data] = [:]
     private var lastAngle: Double = .nan
-    // Preserve fine screen detail on Retina displays and antialias the shell.
+    // Active target: 1000×900 while moving, 1500×1350 after the one-shot sharpen.
     var width: Int { texture.width }
     var height: Int { texture.height }
     // Use Device Hub's 36 mm sensor model with a longer lens to flatten depth.
@@ -72,11 +79,13 @@ import UniformTypeIdentifiers
         renderer.entities.append(camera)
         renderer.activeCamera = camera
         renderer.lighting.resource = EnvironmentResource.duoObjectLighting()
-        renderer.cameraSettings.antialiasing = .multisample4X
+        // Preserve screen detail after settle with a second target, not MSAA.
+        // Antialiasing the shell at 4× was too expensive for the live stream.
+        renderer.cameraSettings.antialiasing = .none
         renderer.cameraSettings.colorBackground = .color(CGColor(red: 0, green: 0, blue: 0, alpha: 0))
         // Keep both targets allocated: resizing during gestures would stall Metal.
-        targets = try [1500, 3000].map { width in
-            let descriptor = MTLTextureDescriptor.texture2DDescriptor(pixelFormat: .bgra8Unorm_srgb, width: width, height: width * 9 / 10, mipmapped: false)
+        targets = try [(Self.previewWidth, Self.previewHeight), (Self.sharpenWidth, Self.sharpenHeight)].map { width, height in
+            let descriptor = MTLTextureDescriptor.texture2DDescriptor(pixelFormat: .bgra8Unorm_srgb, width: width, height: height, mipmapped: false)
             descriptor.storageMode = .shared
             descriptor.usage = [.renderTarget, .shaderRead]
             guard let texture = device.makeTexture(descriptor: descriptor) else { throw CocoaError(.fileReadUnknown) }
@@ -86,10 +95,11 @@ import UniformTypeIdentifiers
         controller = subject.playAnimation(clip, transitionDuration: 0, startsPaused: true)
     }
 
-    func render(jpeg: Data, panel: String, angle: Double, roll: Double, fullResolution: Bool = true) async throws -> Data {
+    func render(jpeg: Data, panel: String, angle: Double, roll: Double, fullResolution: Bool = false) async throws -> Data {
+        // False is the fast motion target. True is the one-shot 1500px settle frame.
         targetIndex = fullResolution ? 1 : 0
         guard angle.isFinite, (0...180).contains(angle), roll.isFinite else { throw CocoaError(.fileReadCorruptFile) }
-        // Hinge, rotation, and idle sharpening often reuse the same framebuffer.
+        // Hinge and rotation updates often reuse the same screen image.
         // Keep both panel textures alive and skip image decoding/upload entirely.
         if screenFrames[panel] != jpeg {
             guard let source = CGImageSourceCreateWithData(jpeg as CFData, nil),

package/Sources/SimDuoRenderer/main.swift

@@ -36,7 +36,8 @@ private func readRequest() throws -> (Request, Data)? {
             guard CommandLine.arguments.count == 2 else { throw CocoaError(.fileReadInvalidFileName) }
             let renderer = try await DuoRenderer(modelURL: URL(fileURLWithPath: CommandLine.arguments[1]))
             while let (request, jpeg) = try await Task.detached(operation: { try readRequest() }).value {
-                let rendered = try await renderer.render(jpeg: jpeg, panel: request.panel, angle: request.hingeDegrees, roll: request.rollDegrees, fullResolution: request.fullResolution ?? true)
+                // Omitted fullResolution stays on the fast target. True is the 1500px settle sharpen.
+                let rendered = try await renderer.render(jpeg: jpeg, panel: request.panel, angle: request.hingeDegrees, roll: request.rollDegrees, fullResolution: request.fullResolution ?? false)
                 let header = try JSONSerialization.data(withJSONObject: [
                     "jpegLength": rendered.count, "width": renderer.width, "height": renderer.height,
                     "pieces": renderer.pieces, "hardware": renderer.hardware, "panel": request.panel, "hingeDegrees": request.hingeDegrees,