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

@@ -0,0 +1,141 @@
// SPDX-License-Identifier: GPL-3.0-or-later
import AppKit
import Combine
@MainActor
final class GraphicsPreviewModel: ObservableObject {
enum Source: String, CaseIterable { case current = "Current Video Page", address = "At Address" }
enum Mode: Int, CaseIterable {
case sg4, pmode0, pmode1, pmode2, pmode3, pmode4, hscreen1, hscreen2, hscreen3, hscreen4
var label: String {
if self == .sg4 { return "Text / SG4" }
if rawValue <= Self.pmode4.rawValue { return "PMODE \(rawValue - 1)" }
return "HSCREEN \(rawValue - 5)"
}
var supportsColorSet: Bool { rawValue >= Self.pmode0.rawValue && rawValue <= Self.pmode4.rawValue }
}
struct Request: Equatable {
var source = Source.current
var physical = false
var address: UInt32 = 0x0e00
var mode = Mode.pmode1
var alternate = false
}
struct Pixel: Equatable { var x = 0; var y = 0 }
struct Frame {
let capture: VCCDebugGraphicsCapture
let image: CGImage
let highlights: CGImage?
let changes: Int?
}
@Published var request = Request()
@Published var addressText = "0E00"
@Published var addressError: String?
@Published private(set) var frame: Frame?
@Published private(set) var error: String?
@Published var selection = Pixel()
private var epoch: UInt64 = 0
func readyToStep(machine: MachineModel) -> Bool {
if error != nil { return true }
guard let snapshot = frame?.capture.machine else { return false }
return snapshot.state == .paused && snapshot.generation == machine.basicDebug.generation &&
snapshot.cycles == machine.basicDebug.cycles
}
func inspectAddress(_ address: UInt32, physical: Bool) {
addressText = DebuggerModel.hex(address, width: physical ? 6 : 4)
addressError = nil
request.physical = physical
request.address = address
request.source = .address
}
func applyAddress() {
guard let value = DebuggerModel.hexadecimalAddress(addressText, maximum: request.physical ? 0x7fffff : 0xffff) else {
addressError = request.physical ? "Enter a physical address from $000000 to $7FFFFF." : "Enter a CPU address from $0000 to $FFFF."
return
}
inspectAddress(value, physical: request.physical)
}
private static func image(_ rgba: Data, width: Int, height: Int) -> CGImage? {
guard width > 0, height > 0, rgba.count == width * height * 4,
let provider = CGDataProvider(data: rgba as CFData) else { return nil }
return CGImage(width: width, height: height, bitsPerComponent: 8, bitsPerPixel: 32,
bytesPerRow: width * 4, space: CGColorSpaceCreateDeviceRGB(),
bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.last.rawValue),
provider: provider, decode: nil, shouldInterpolate: false, intent: .defaultIntent)
}
// A translucent overlay preserves the colors underneath. Work is bounded
// by one native raster and is only performed for an observed single step.
static func differences(_ before: Data, _ after: Data) -> (Data, Int) {
guard before.count == after.count, after.count.isMultiple(of: 4) else { return (Data(), 0) }
var mask = Data(count: after.count)
var changes = 0
before.withUnsafeBytes { (old: UnsafeRawBufferPointer) in
after.withUnsafeBytes { (new: UnsafeRawBufferPointer) in
mask.withUnsafeMutableBytes { (out: UnsafeMutableRawBufferPointer) in
for i in stride(from: 0, to: new.count, by: 4) {
if old[i] != new[i] || old[i+1] != new[i+1] || old[i+2] != new[i+2] || old[i+3] != new[i+3] {
out[i] = 255; out[i+1] = 94; out[i+2] = 190; out[i+3] = 210
changes += 1
}
}
}
}
}
return (mask, changes)
}
func poll(machine: MachineModel) async {
let intent = request
epoch &+= 1
let token = epoch
frame = nil
error = nil
var lastRead: (epoch: UInt64, snapshot: VCCMachineSnapshot)?
while !Task.isCancelled, token == epoch, intent == request {
// Repeated polling of an unchanged paused machine needs no extra
// bitmap. Commands increment inputEpoch, including paused RAM edits.
if machine.canQuickLoad, machine.state == .running || lastRead?.snapshot.state != .paused ||
lastRead?.epoch != machine.inputEpoch || lastRead?.snapshot.cycles != machine.basicDebug.cycles ||
lastRead?.snapshot.generation != machine.basicDebug.generation {
let inputEpoch = machine.inputEpoch
let sample = await machine.readGraphicsPreview(currentPage: intent.source == .current,
address: intent.address, physical: intent.physical, mode: intent.mode.rawValue,
alternatePalette: intent.mode.supportsColorSet && intent.alternate)
guard !Task.isCancelled, epoch == token, request == intent else { return }
if let sample, inputEpoch == machine.inputEpoch, sample.machine.generation == machine.basicDebug.generation {
lastRead = (inputEpoch, sample.machine)
accept(sample, step: machine.lastDebuggerStep)
}
}
do { try await Task.sleep(for: .milliseconds(250)) } catch { return }
}
}
private func accept(_ sample: VCCDebugGraphicsCapture, step: (generation: UInt64, before: UInt64, after: UInt64)?) {
if let message = sample.errorMessage {
error = message; frame = nil
return
}
guard let bitmap = Self.image(sample.rgba, width: sample.width, height: sample.height) else {
error = "This page could not be rendered."; frame = nil
return
}
var highlights: CGImage?
var changes: Int?
if let previous = frame, let step, previous.capture.machine.state == .paused, sample.machine.state == .paused,
sample.machine.generation == step.generation, sample.machine.cycles == step.after,
previous.capture.machine.cycles == step.before, sample.hasSameLayout(as: previous.capture) {
let (mask, count) = Self.differences(previous.capture.rgba, sample.rgba)
changes = count
if count > 0 { highlights = Self.image(mask, width: sample.width, height: sample.height) }
}
if selection.x >= sample.width || selection.y >= sample.height { selection = Pixel() }
error = nil
frame = Frame(capture: sample, image: bitmap, highlights: highlights, changes: changes)
}
}