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 }))
                }
            }
        }
    }
}