Publish VCC Plus OSS source distribution for 3.6.2 build 60

This commit is contained in:
Brian Holman committed 2026-11-13 00:14:03 -07:00
commit c652a5276d
1192 files changed
+272368

No files matched your search

+193
View File
@@ -0,0 +1,193 @@
// 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..<height { for x in 0..<width {
let i = ((Int(area.minY) + y) * 640 + Int(area.minX) + x) * 4
let o = (y * width + x) * 4
dst[o] = src[i+2]; dst[o+1] = src[i+1]; dst[o+2] = src[i]; dst[o+3] = 255
} }
}
}
guard let provider = CGDataProvider(data: rgba as CFData),
let color = CGColorSpace(name: CGColorSpace.sRGB),
let image = CGImage(width: width, height: height, bitsPerComponent: 8, bitsPerPixel: 32,
bytesPerRow: width * 4, space: color, bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.last.rawValue),
provider: provider, decode: nil, shouldInterpolate: false, intent: .defaultIntent) else { throw Failure.encoding }
let data = NSMutableData()
guard let destination = CGImageDestinationCreateWithData(data, UTType.png.identifier as CFString, 1, nil) else { throw Failure.encoding }
CGImageDestinationAddImage(destination, image, nil)
guard CGImageDestinationFinalize(destination) else { throw Failure.encoding }
return data as Data
}
func save(to url: URL) throws { try png().write(to: url, options: .atomic) }
}
// One layout calculation for Metal and mouse joysticks. Preserve the source
// raster's proportions, with a small logical-point green inset on every edge.
struct VideoGeometry {
static let fullFrame = CGRect(x:0,y:0,width:640,height:480)
static let border: CGFloat = 4
static let surround = MTLClearColorMake(0.10, 0.14, 0.12, 1)
static func validated(_ rect: CGRect) -> 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>(Float(crop.minX/640),Float(crop.minY/480),Float(crop.width/640),Float(crop.height/480))
encoder.setFragmentBytes(&region,length:MemoryLayout<SIMD4<Float>>.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<Float>(style.scaling == .smooth ? 1 : 0, strength)
encoder.setFragmentBytes(&effects,length:MemoryLayout<SIMD2<Float>>.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
}
}