// SPDX-License-Identifier: GPL-3.0-or-later import MetalKit import Combine import ImageIO import UniformTypeIdentifiers enum DisplayScaling: String, CaseIterable { case sharp, smooth, integer var label: String { switch self { case .sharp: return "Sharp — Fit Window" case .smooth: return "Smooth — Fit Window" case .integer: return "Integer Pixels" } } } struct DisplayStyle: Equatable { var scaling: DisplayScaling = .smooth var scanlines = false } // Host presentation preferences deliberately stay outside machine profiles. // Separate observation prevents emulator polls from rebuilding open controls. @MainActor final class DisplayPreferences: ObservableObject { @Published var style: DisplayStyle { didSet { defaults.set(style.scaling.rawValue, forKey: "displayScaling") defaults.set(style.scanlines, forKey: "displayScanlines") } } private let defaults: UserDefaults init(defaults: UserDefaults) { self.defaults = defaults style = DisplayStyle(scaling: DisplayScaling(rawValue: defaults.string(forKey: "displayScaling") ?? "") ?? .smooth, scanlines: defaults.bool(forKey: "displayScanlines")) } } // Immutable pixels and their matching active bounds, captured together before // the save panel opens. Encoding and file writing need no emulator commands. struct ScreenCapture: Sendable { let pixels: Data let area: CGRect enum Failure: LocalizedError { case noFrame, encoding var errorDescription: String? { self == .noFrame ? "No CoCo picture is available to save yet." : "The CoCo picture could not be encoded as a PNG." } } init(pixels: Data?, area: CGRect) throws { guard let pixels, pixels.count == 640 * 480 * 4 else { throw Failure.noFrame } self.pixels = pixels; self.area = VideoGeometry.validated(area).integral } func png() throws -> Data { let width = Int(area.width), height = Int(area.height) var rgba = Data(count: width * height * 4) rgba.withUnsafeMutableBytes { output in pixels.withUnsafeBytes { input in let src = input.bindMemory(to: UInt8.self), dst = output.bindMemory(to: UInt8.self) for y in 0.. CGRect { guard [rect.origin.x,rect.origin.y,rect.width,rect.height].allSatisfy({ $0.isFinite }), rect.width > 0, rect.height > 0 else { return fullFrame } let clipped = rect.intersection(fullFrame) return clipped.isNull || clipped.isEmpty ? fullFrame : clipped } static func picture(in size: CGSize, source: CGRect, inset: CGFloat = border, scaling: DisplayScaling = .sharp) -> CGRect { let source = validated(source) let available = CGSize(width:max(0,size.width-2*inset),height:max(0,size.height-2*inset)) let fit = min(available.width/source.width,available.height/source.height) let scale = scaling == .integer && fit >= 1 ? floor(fit) : fit let width = source.width*scale, height = source.height*scale let x = (size.width-width)/2, y = (size.height-height)/2 return CGRect(x:scaling == .integer && fit >= 1 ? floor(x) : x, y:scaling == .integer && fit >= 1 ? floor(y) : y,width:width,height:height) } static func mouse(_ point: CGPoint, in size: CGSize, source: CGRect, scaling: DisplayScaling = .sharp, backing: CGFloat = 1, drawableSize: CGSize? = nil) -> CGPoint? { guard size.width > 0, size.height > 0 else { return nil } let physical = drawableSize ?? CGSize(width:size.width*max(1,backing),height:size.height*max(1,backing)) guard physical.width > 0, physical.height > 0 else { return nil } // Use the actual drawable dimensions: fractional SwiftUI layouts can // round backing pixels differently from bounds * screen scale. let r = picture(in:physical,source:source,inset:border*physical.width/size.width,scaling:scaling) // Metal's viewport starts at the top; AppKit mouse coordinates at bottom. let pixel = CGPoint(x:point.x*physical.width/size.width,y:(size.height-point.y)*physical.height/size.height) guard r.width > 0, r.height > 0, r.contains(pixel) else { return nil } return CGPoint(x:(pixel.x-r.minX)/r.width,y:(pixel.y-r.minY)/r.height) } } // All CPU-side access is on the main thread. Each submission owns its upload // texture until the GPU finishes; no texture is overwritten while in flight. final class MetalRenderer { let device: MTLDevice private let queue: MTLCommandQueue private let pipeline: MTLRenderPipelineState private let inFlight = DispatchSemaphore(value: 3) enum Failure: LocalizedError { case unavailable, shaders, resources var errorDescription: String? { switch self { case .unavailable: return "Metal is unavailable on this Mac." case .shaders: return "The app’s display shaders could not be loaded. Rebuild the app in Xcode." case .resources: return "The Mac could not allocate the display resources." } } } static func library(device: MTLDevice, bundle: Bundle) throws -> MTLLibrary { guard let url = bundle.url(forResource: "DisplayShader", withExtension: "txt") else { throw Failure.shaders } return try device.makeLibrary(source: String(contentsOf: url, encoding: .utf8), options: nil) } init(device: MTLDevice, library: MTLLibrary) throws { self.device = device guard let queue = device.makeCommandQueue() else { throw Failure.resources } self.queue = queue let descriptor = MTLRenderPipelineDescriptor() descriptor.vertexFunction = library.makeFunction(name: "vccVertex") descriptor.fragmentFunction = library.makeFunction(name: "vccFragment") guard descriptor.vertexFunction != nil, descriptor.fragmentFunction != nil else { throw Failure.shaders } descriptor.colorAttachments[0].pixelFormat = .bgra8Unorm pipeline = try device.makeRenderPipelineState(descriptor: descriptor) } func encode(pixels: Data?, target: MTLTexture, drawable: CAMetalDrawable? = nil, activeArea: CGRect = VideoGeometry.fullFrame, inset: CGFloat = VideoGeometry.border, style: DisplayStyle = DisplayStyle()) throws -> MTLCommandBuffer? { guard inFlight.wait(timeout: .now()) == .success else { return nil } var submitted = false defer { if !submitted { inFlight.signal() } } guard let command = queue.makeCommandBuffer() else { throw Failure.resources } let pass = MTLRenderPassDescriptor() pass.colorAttachments[0].texture = target pass.colorAttachments[0].loadAction = .clear pass.colorAttachments[0].storeAction = .store pass.colorAttachments[0].clearColor = VideoGeometry.surround var source: MTLTexture? if let pixels, pixels.count == 640 * 480 * 4 { let descriptor = MTLTextureDescriptor.texture2DDescriptor(pixelFormat: .bgra8Unorm, width: 640, height: 480, mipmapped: false) descriptor.storageMode = device.hasUnifiedMemory ? .shared : .managed; descriptor.usage = .shaderRead guard let texture = device.makeTexture(descriptor: descriptor) else { throw Failure.resources } pixels.withUnsafeBytes { data in texture.replace(region: MTLRegionMake2D(0, 0, 640, 480), mipmapLevel: 0, withBytes: data.baseAddress!, bytesPerRow: 640 * 4) } source = texture } guard let encoder = command.makeRenderCommandEncoder(descriptor: pass) else { throw Failure.resources } if let source, CGFloat(target.width) > 2*inset, CGFloat(target.height) > 2*inset { let crop = VideoGeometry.validated(activeArea) let r = VideoGeometry.picture(in:CGSize(width:target.width,height:target.height),source:crop,inset:inset,scaling:style.scaling) encoder.setViewport(MTLViewport(originX:Double(r.minX),originY:Double(r.minY),width:Double(r.width),height:Double(r.height),znear:0,zfar:1)) var region = SIMD4(Float(crop.minX/640),Float(crop.minY/480),Float(crop.width/640),Float(crop.height/480)) encoder.setFragmentBytes(®ion,length:MemoryLayout>.stride,index:0) // Fade out at small sizes, where scanlines would alias or hide rows. let strength: Float = style.scanlines ? 0.25 * Float(min(1,max(0,r.height/crop.height-1))) : 0 var effects = SIMD2(style.scaling == .smooth ? 1 : 0, strength) encoder.setFragmentBytes(&effects,length:MemoryLayout>.stride,index:1) encoder.setRenderPipelineState(pipeline) encoder.setFragmentTexture(source, index: 0) encoder.drawPrimitives(type: .triangle, vertexStart: 0, vertexCount: 3) } encoder.endEncoding() if let drawable { command.present(drawable) } let semaphore = inFlight command.addCompletedHandler { _ in semaphore.signal() } command.commit(); submitted = true return command } }