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