Sources/FaceMaker/RootView.swift
Swift source for Making faces, 575 lines. Raw file
import AppKit
import CoreImage
import SwiftUI
import UniformTypeIdentifiers
/// The whole window: a grid of generated faces on top, generation controls
/// below. Clicking a face opens it in a separate non-modal viewer window.
struct RootView: View {
@Environment(AppModel.self) private var model
@Environment(\.openWindow) private var openWindow
@Environment(\.colorScheme) private var colorScheme
/// Fixed on-screen size of each card, in points. Smaller/Larger step it.
@State private var cardSize: Double = Theme.faceCardDefaultSize
@State private var dropTargeted = false
var body: some View {
@Bindable var model = model
VSplitView {
grid
.frame(maxWidth: .infinity, maxHeight: .infinity)
.frame(minHeight: 240)
controls
.frame(maxWidth: .infinity, maxHeight: .infinity)
.frame(minHeight: 200)
}
.persistSplitPosition("facemaker.mainSplit")
.frame(maxWidth: .infinity, maxHeight: .infinity)
.frame(minWidth: Theme.windowMinWidth, minHeight: Theme.windowMinHeight)
.overlay {
if dropTargeted && model.supportsFinder {
RoundedRectangle(cornerRadius: 8)
.strokeBorder(Color.accentColor, lineWidth: 3)
.allowsHitTesting(false)
}
}
.onDrop(of: [.image, .fileURL], isTargeted: $dropTargeted) { providers, _ in
handleDrop(providers)
}
.onReceive(NotificationCenter.default.publisher(for: .faceMakerOpenImage)) { note in
guard model.supportsFinder, let url = note.object as? URL,
let image = CIImage(contentsOf: url) else { return }
model.findVector(from: image)
}
.persistWindowFrame("FaceMakerMainWindow")
.task(id: model.generation) {
// Debounce rapid slider drags before regenerating.
try? await Task.sleep(for: .milliseconds(350))
guard !Task.isCancelled else { return }
await model.regenerate()
}
// Photos opened with the app come to this window, rather than opening a new one.
.handlesExternalEvents(preferring: ["*"], allowing: ["*"])
}
// MARK: - Grid
private var grid: some View {
VStack(spacing: 0) {
if let notice = model.notice {
Label(notice, systemImage: "exclamationmark.triangle")
.font(.callout)
.foregroundStyle(.secondary)
.padding(8)
}
ScrollView {
LazyVGrid(columns: columns, spacing: Theme.gridSpacing) {
ForEach(model.slots) { slot in
FaceCard(
slot: slot,
onOpen: { open(slot) },
onReroll: { model.reroll(slot.id) },
onSaveAs: { saveAs(slot) },
onCopy: { copy(slot) },
onCopySeed: { copySeed(slot) },
onUseVector: { useVector(slot) },
onSaveVector: { saveVector(slot) })
}
}
.padding(Theme.gridSpacing)
.frame(maxWidth: .infinity)
}
// Plain white (light) / black (dark) canvas behind the tiles.
.background(canvas)
}
}
private var canvas: Color { colorScheme == .dark ? .black : .white }
private var columns: [GridItem] {
[GridItem(.adaptive(minimum: cardSize, maximum: cardSize), spacing: Theme.gridSpacing)]
}
/// Row directly under the cards: face count + Regenerate on the left,
/// card-size steppers on the right. (Seed now lives in the blobs below.)
private var cardToolbar: some View {
@Bindable var model = model
return HStack(spacing: 10) {
LabeledContent("Faces") {
TextField("8", value: Binding(
get: { model.faceCount },
set: { model.faceCount = min(100, max(4, $0)) }),
format: .number)
.frame(width: 52)
.textFieldStyle(.roundedBorder)
}
.fixedSize()
Button("Regenerate", systemImage: "arrow.clockwise") {
model.forceRegenerate()
}
.accessibilityLabel("Regenerate")
if let timing = model.timing {
Text(timing)
.font(.callout)
.foregroundStyle(.secondary)
.monospacedDigit()
}
Spacer(minLength: 12)
Button("Smaller", systemImage: "minus.magnifyingglass") {
cardSize = max(Theme.faceCardMinSize, cardSize - Theme.faceCardStep)
}
.accessibilityLabel("Smaller")
.disabled(cardSize <= Theme.faceCardMinSize)
Button("Larger", systemImage: "plus.magnifyingglass") {
cardSize = min(Theme.faceCardMaxSize, cardSize + Theme.faceCardStep)
}
.accessibilityLabel("Larger")
.disabled(cardSize >= Theme.faceCardMaxSize)
}
.labelStyle(.titleAndIcon)
.padding(.horizontal, 12)
.padding(.vertical, 8)
}
// MARK: - Controls
private var controls: some View {
@Bindable var model = model
return VStack(alignment: .leading, spacing: 0) {
cardToolbar
Divider()
// Model picker stays pinned; the blob parameters below scroll.
modelRow
.padding(.horizontal, 16)
.padding(.top, 14)
.padding(.bottom, 10)
Divider()
parameters
}
}
/// Model picker on the left; the drop strategy dropdown + drop hint / live
/// match status (with a Stop button while refining) on the right.
private var modelRow: some View {
@Bindable var model = model
return HStack(spacing: 12) {
Picker("Model", selection: $model.selectedModelID) {
ForEach(model.models) { faceModel in
Text(faceModel.menuTitle).tag(faceModel.id)
}
}
.fixedSize()
Spacer(minLength: 12)
if model.supportsFinder {
Picker("Strategy", selection: $model.strategy) {
ForEach(model.availableStrategies) { strategy in
Text(strategy.name).tag(strategy)
}
}
.labelsHidden()
.fixedSize()
.help("Quick: instant nearest match. Search: refine toward the dropped face.")
}
finderStatusView
}
}
@ViewBuilder
private var finderStatusView: some View {
if model.isSearching {
HStack(spacing: 8) {
ProgressView().controlSize(.small)
Text(model.finderStatus ?? "Refining…")
.font(.caption.monospacedDigit())
.foregroundStyle(.secondary)
Button("Stop") { model.stopSearch() }
.controlSize(.small)
}
} else if let status = model.finderStatus {
HStack(spacing: 6) {
ProgressView().controlSize(.small)
Text(status).font(.caption).foregroundStyle(.secondary)
}
} else if model.supportsFinder {
Label("Drop an image to find vector", systemImage: "photo.on.rectangle.angled")
.font(.caption)
.foregroundStyle(.secondary)
}
}
/// The scrollable white/black parameters canvas: seed + vector blobs, then
/// one blob per model parameter (grouped, with optional-group toggles).
private var parameters: some View {
ScrollView {
VStack(alignment: .leading, spacing: 18) {
Text(model.selectedModel.note)
.font(.caption)
.foregroundStyle(.secondary)
LazyVGrid(columns: blobColumns, alignment: .leading, spacing: 12) {
SeedBlob()
VectorBlob()
}
modelParameterBlobs
}
.frame(maxWidth: .infinity, alignment: .leading)
.padding(16)
}
.background(canvas)
}
private var blobColumns: [GridItem] {
[GridItem(.adaptive(minimum: 260), spacing: 12, alignment: .top)]
}
@ViewBuilder
private var modelParameterBlobs: some View {
let faceModel = model.selectedModel
if faceModel.controls.isEmpty {
Text("This model samples a random face and has no edit parameters.")
.font(.callout)
.foregroundStyle(.secondary)
} else {
ForEach(faceModel.controls) { group in
ParameterGroup(group: group, columns: blobColumns)
}
}
}
// MARK: - Actions
private func open(_ slot: FaceSlot) {
guard let data = slot.pngData else { return }
let url = FileManager.default.temporaryDirectory
.appendingPathComponent("facemaker-\(slot.seed ?? 0)-\(slot.id).png")
try? data.write(to: url)
let details = model.recipeDetails().map {
ViewerFace.Detail(label: $0.label, value: $0.value)
}
let face = ViewerFace(
id: slot.id, pngPath: url.path, seed: slot.seed ?? 0,
modelID: model.selectedModelID,
sliderValues: model.sliderValues,
enabledGroups: model.enabledGroups,
vector: slot.wplus ?? slot.vector ?? [],
details: details)
openWindow(id: "viewer", value: face)
}
private func saveAs(_ slot: FaceSlot) {
guard let data = slot.pngData else { return }
FaceExport.saveAs(pngData: data, suggestedName: "Face-\(slot.seed ?? 0)")
}
private func copy(_ slot: FaceSlot) {
guard let image = slot.image else { return }
NSPasteboard.general.clearContents()
NSPasteboard.general.writeObjects([image])
}
private func copySeed(_ slot: FaceSlot) {
guard let seed = slot.seed else { return }
NSPasteboard.general.clearContents()
NSPasteboard.general.setString(String(seed), forType: .string)
}
private func saveVector(_ slot: FaceSlot) {
guard let values = slot.wplus ?? slot.vector else { return }
FaceExport.saveVector(
values, model: model.selectedModelID,
suggestedName: slot.seed.map { "Face-\($0)" } ?? "Face-vector")
}
private func useVector(_ slot: FaceSlot) {
if let wplus = slot.wplus {
model.useWPlus(wplus)
} else if let vector = slot.vector {
model.useVector(vector)
}
}
// MARK: - Drop an image to find its vector
private func handleDrop(_ providers: [NSItemProvider]) -> Bool {
guard model.supportsFinder, let first = providers.first else { return false }
// The provider is only read inside imageData(from:), so handing it over is safe.
nonisolated(unsafe) let provider = first
Task { @MainActor in
guard let data = await RootView.imageData(from: provider),
let image = CIImage(data: data) else { return }
model.findVector(from: image)
}
return true
}
/// Load a dropped item as image bytes (Sendable) off the main actor.
/// Finder drops arrive as a file URL; browser/app drops as image data.
nonisolated private static func imageData(from provider: NSItemProvider) async -> Data? {
if provider.hasItemConformingToTypeIdentifier(UTType.fileURL.identifier),
let url = await loadURL(provider), let data = try? Data(contentsOf: url) {
return data
}
return await loadTIFF(provider)
}
nonisolated private static func loadURL(_ provider: NSItemProvider) async -> URL? {
await withCheckedContinuation { continuation in
_ = provider.loadObject(ofClass: URL.self) { url, _ in
continuation.resume(returning: url)
}
}
}
nonisolated private static func loadTIFF(_ provider: NSItemProvider) async -> Data? {
guard provider.canLoadObject(ofClass: NSImage.self) else { return nil }
return await withCheckedContinuation { continuation in
_ = provider.loadObject(ofClass: NSImage.self) { object, _ in
continuation.resume(returning: (object as? NSImage)?.tiffRepresentation)
}
}
}
}
// MARK: - Numeric field
/// A compact text box to the right of a slider. Accepts only digits, `-` and
/// `.`; commits to the bound value as you type, and mirrors slider drags.
struct NumberField: View {
@Binding var value: Double
@State private var text: String = ""
var body: some View {
TextField("", text: $text)
.frame(width: 58)
.multilineTextAlignment(.trailing)
.textFieldStyle(.roundedBorder)
.font(.caption.monospacedDigit())
.onAppear { text = Self.format(value) }
.onChange(of: value) { _, newValue in
if Double(text) != newValue { text = Self.format(newValue) }
}
.onChange(of: text) { _, newText in
let filtered = String(newText.filter { "0123456789.-".contains($0) })
if filtered != newText { text = filtered; return }
if let parsed = Double(filtered), parsed != value { value = parsed }
}
}
private static func format(_ value: Double) -> String {
String(format: "%g", value)
}
}
// MARK: - Blob container
/// The grey rounded card every parameter sits in. The enclosing area is the
/// white/black canvas; the blobs are light/dark grey.
private struct Blob<Content: View>: View {
@Environment(\.colorScheme) private var colorScheme
@ViewBuilder var content: Content
var body: some View {
VStack(alignment: .leading, spacing: 8) {
content
}
.padding(12)
.frame(maxWidth: .infinity, alignment: .leading)
.background(fill, in: RoundedRectangle(cornerRadius: 10))
}
private var fill: Color {
colorScheme == .dark ? Color(white: 0.17) : Color(white: 0.91)
}
}
/// A small radio dot + label used to pick seed vs vector.
private struct RadioLabel: View {
let title: String
let selected: Bool
let action: () -> Void
var body: some View {
Button(action: action) {
HStack(spacing: 6) {
Image(systemName: selected ? "largecircle.fill.circle" : "circle")
.foregroundStyle(selected ? Color.accentColor : Color.secondary)
Text(title).font(.headline)
}
}
.buttonStyle(.plain)
.accessibilityLabel(title)
.accessibilityAddTraits(selected ? [.isSelected] : [])
}
}
// MARK: - Seed blob
private struct SeedBlob: View {
@Environment(AppModel.self) private var model
var body: some View {
let isSeed = model.mode == .seed
Blob {
RadioLabel(title: "Seed", selected: isSeed) { model.mode = .seed }
TextField("Random", text: Binding(
get: { model.seedText },
set: { model.seedText = $0 }))
.font(.body.monospacedDigit())
.textFieldStyle(.roundedBorder)
.disabled(!isSeed)
}
}
}
// MARK: - Vector blob
private struct VectorBlob: View {
@Environment(AppModel.self) private var model
@Environment(\.openWindow) private var openWindow
var body: some View {
let isVector = model.mode == .vector
Blob {
RadioLabel(title: "Vector", selected: isVector) { model.mode = .vector }
HStack {
Button("Edit…") { openWindow(id: "vector-editor") }
Button("From seed") { model.resetVectorToSeed() }
Button("Import…") { importLatent() }
.help("Load a latent from a JSON file: {\"data\": [512 or 9216 numbers]}")
Button("Export…") {
FaceExport.saveVector(
model.baseLatent, model: model.selectedModelID, suggestedName: "Face-vector")
}
.help("Save this vector as JSON, to import again later")
}
.controlSize(.small)
.disabled(!isVector)
VStack(alignment: .leading, spacing: 2) {
Text("Radius").font(.callout)
HStack(spacing: 8) {
Slider(value: Binding(
get: { model.radius },
set: { model.radius = $0 }), in: 0...1.5)
NumberField(value: Binding(
get: { model.radius },
set: { model.radius = $0 }))
}
}
.disabled(!isVector)
VStack(alignment: .leading, spacing: 2) {
Text("Realism").font(.callout)
HStack(spacing: 8) {
Slider(value: Binding(
get: { model.realism },
set: { model.realism = $0 }), in: 0...1)
NumberField(value: Binding(
get: { model.realism },
set: { model.realism = $0 }))
}
}
.disabled(!isVector)
.help("Pull radius neighbours toward the average face — more realistic and sharper (imported/encoder faces).")
Toggle("Coherent", isOn: Binding(
get: { model.coherentPerturb },
set: { model.coherentPerturb = $0 }))
.toggleStyle(.checkbox)
.font(.callout)
.disabled(!isVector)
.help("Vary neighbours along one W-direction so they stay face-like.")
}
}
private func importLatent() {
let panel = NSOpenPanel()
panel.allowedContentTypes = [.json]
panel.allowsMultipleSelection = false
panel.message = "Choose a latent JSON: {\"data\": [512 or 9216 numbers]}"
if panel.runModal() == .OK, let url = panel.url {
model.importLatent(from: url)
}
}
}
// MARK: - Parameter group + slider blobs
/// One control group: an optional-group toggle (if any) then its slider blobs.
private struct ParameterGroup: View {
@Environment(AppModel.self) private var model
let group: FaceControlGroup
let columns: [GridItem]
var body: some View {
VStack(alignment: .leading, spacing: 10) {
if group.optional {
Toggle(group.name, isOn: Binding(
get: { model.isGroupEnabled(group) },
set: { model.enabledGroups[group.id] = $0 }))
.toggleStyle(.checkbox)
.font(.headline)
} else {
Text(group.name).font(.headline)
}
if model.isGroupEnabled(group) {
LazyVGrid(columns: columns, alignment: .leading, spacing: 12) {
ForEach(group.sliders) { slider in
SliderBlob(slider: slider)
}
}
}
}
}
}
/// One parameter: name + value slider, a Range checkbox, and (when on) the
/// second slider that sets the far end of the sampled range.
private struct SliderBlob: View {
@Environment(AppModel.self) private var model
let slider: FaceSlider
var body: some View {
let rangeOn = model.isRangeOn(slider)
Blob {
Text(slider.name).font(.headline)
HStack(spacing: 8) {
Slider(value: Binding(
get: { model.value(for: slider) },
set: { model.sliderValues[slider.id] = $0 }),
in: slider.minimum...slider.maximum)
NumberField(value: Binding(
get: { model.value(for: slider) },
set: { model.sliderValues[slider.id] = $0 }))
}
Toggle("Range", isOn: Binding(
get: { model.isRangeOn(slider) },
set: { model.rangeEnabled[slider.id] = $0 }))
.toggleStyle(.checkbox)
.font(.callout)
if rangeOn {
HStack(spacing: 8) {
Text("to").font(.caption).foregroundStyle(.secondary)
Slider(value: Binding(
get: { model.rangeEndValue(for: slider) },
set: { model.rangeEnd[slider.id] = $0 }),
in: slider.minimum...slider.maximum)
NumberField(value: Binding(
get: { model.rangeEndValue(for: slider) },
set: { model.rangeEnd[slider.id] = $0 }))
}
}
}
}
}