visionOS: Windows, Volumes, Immersive Spaces and RealityKit

// FieldNotes/FieldNotesApp.swift (updated excerpt: the visionOS scenes)
import SwiftUI
import FieldNotesModel
import FieldNotesServices

@main
struct FieldNotesApp: App {
    @State private var store = AppServices.shared.store   // the single owner, see Background Execution
    @AppStorage("mapFocusMode", store: .fieldNotesShared)   // the App inherits no scene's default store
    private var mapFocusMode = false

    var body: some Scene {
        WindowGroup {
            ContentView()
                #if os(visionOS)
                .ornament(attachmentAnchor: .scene(.bottom)) {
                    NoteOrnament()
                }
                #endif
                .environment(store)            // after .ornament, so the ornament gets the store too
        }
        .defaultAppStorage(.fieldNotesShared)  // as on Preferences, Files and Document-Based Apps

        WindowGroup(id: "note", for: Note.ID.self) { $noteID in   // from the iPadOS page
            NoteWindow(noteID: noteID)
                .environment(store)
        }
        .defaultAppStorage(.fieldNotesShared)

        #if os(visionOS)
        WindowGroup(id: "field-site") {
            FieldSiteVolume()
                .environment(store)
        }
        .defaultAppStorage(.fieldNotesShared)
        .windowStyle(.volumetric)
        .defaultSize(width: 0.6, height: 0.35, depth: 0.6, in: .meters)
        .defaultWindowPlacement { _, context in
            if let main = context.windows.first {
                return WindowPlacement(.trailing(main))   // next to the main window
            }
            return WindowPlacement()
        }

        ImmersiveSpace(id: "map") {
            NotesMapSpace()
                .environment(store)
        }
        .defaultAppStorage(.fieldNotesShared)
        .immersionStyle(selection: mapImmersion, in: .mixed, .progressive(0.2...1.0, initialAmount: 0.5))
        #endif
    }

    #if os(visionOS)
    /// Mixed shows the room; progressive ("focus mode") replaces part of it, the amount set by the Digital Crown.
    private var mapImmersion: Binding<any ImmersionStyle> {
        Binding(
            get: { mapFocusMode ? .progressive(0.2...1.0, initialAmount: 0.5) : .mixed },
            set: { mapFocusMode = $0 is ProgressiveImmersionStyle }
        )
    }
    #endif
}

// FieldNotes/Vision/NoteOrnament.swift
#if os(visionOS)
import SwiftUI

struct NoteOrnament: View {
    @Environment(\.openWindow) private var openWindow
    @State private var isComposing = false

    var body: some View {
        HStack(spacing: 16) {
            CaptureButton(action: { isComposing = true })
            Button("Field Site", systemImage: "mountain.2") {
                openWindow(id: "field-site")
            }
            OpenMapSpaceButton()
        }
        .labelStyle(.iconOnly)
        .padding(12)
        .glassBackgroundEffect()
        .sheet(isPresented: $isComposing) {
            NoteComposer(notebookID: nil)        // reads NoteStore from the environment
        }
    }
}
#endif

// FieldNotes/Vision/FieldSiteVolume.swift
#if os(visionOS)
import SwiftUI
import RealityKit
import RealityKitContent
import OSLog
import FieldNotesModel
import FieldNotesServices

struct FieldSiteVolume: View {
    @Environment(NoteStore.self) private var store
    @Environment(\.openWindow) private var openWindow
    @State private var selectedNoteID: Note.ID?

    private static let log = Logger(subsystem: "com.example.fieldnotes", category: "ui")

    var body: some View {
        RealityView { content, attachments in
            let site = Entity()
            site.name = "FieldSite"
            do {
                site.addChild(try await Entity(named: "FieldSiteTerrain", in: realityKitContentBundle))
            } catch {
                Self.log.error("FieldSiteTerrain failed to load: \(error.localizedDescription)")  // pins still show
            }
            Self.reconcilePins(in: site, with: store.notes)
            site.position.y = -0.15                              // rest on the volume's floor
            content.add(site)
        } update: { content, attachments in
            guard let site = content.entities.first(where: { $0.name == "FieldSite" }) else { return }
            Self.reconcilePins(in: site, with: store.notes)     // reading store.notes reruns update on every change
            guard let card = attachments.entity(for: "note-card") else { return }
            if let noteID = selectedNoteID, let pin = site.findEntity(named: noteID.uuidString) {
                site.addChild(card)
                card.position = pin.position + [0, 0.09, 0]
                card.isEnabled = true
            } else {
                card.isEnabled = false
            }
        } attachments: {
            Attachment(id: "note-card") {
                if let noteID = selectedNoteID, let note = store.notes.first(where: { $0.id == noteID }) {
                    FieldSiteNoteCard(note: note) {
                        openWindow(id: "note", value: note.id)
                    }
                }
            }
        }
        .gesture(
            SpatialTapGesture()
                .targetedToAnyEntity()
                .onEnded { value in
                    guard let pin = value.entity.components[NotePinComponent.self],
                          store.notes.contains(where: { $0.id == pin.noteID }) else { return }  // deleted meanwhile
                    selectedNoteID = selectedNoteID == pin.noteID ? nil : pin.noteID
                }
        )
        .onChange(of: store.notes.map(\.id)) {
            // The selected note was deleted, here or in another window: drop the card.
            if let id = selectedNoteID, !store.notes.contains(where: { $0.id == id }) {
                selectedNoteID = nil
            }
        }
        .volumeBaseplateVisibility(.visible)
    }

    /// Makes the site's pins match the located notes, keyed by note ID: removes the pins of deleted (or no longer
    /// located) notes, rebuilds a pin whose pinned state or title changed, adds pins for new notes and moves the rest, since
    /// the layout's origin is the first located note. Only x and z are set: NotePinSystem owns y, for the bobbing.
    private static func reconcilePins(in site: Entity, with notes: [Note]) {
        let layout = NotesMapLayout.positions(for: notes, tableSize: 0.5)
        let wanted = Dictionary(uniqueKeysWithValues: layout.map { ($0.note.id, $0) })
        var kept: [Note.ID: Entity] = [:]
        for child in Array(site.children) {                  // a copy, because the loop removes children
            guard let pin = child.components[NotePinComponent.self] else { continue }   // the terrain
            if let entry = wanted[pin.noteID], entry.note.isPinned == pin.isPinned,
               labelText(of: child) == entry.note.title {
                kept[pin.noteID] = child
            } else {
                child.removeFromParent()
            }
        }
        for (id, entry) in wanted {
            if let pin = kept[id] {
                pin.position.x = entry.position.x
                pin.position.z = entry.position.z
            } else {
                let pin = NotePinFactory.makePin(for: entry.note, at: entry.position)
                pin.components.set(HoverEffectComponent())  // highlights the pin the person looks at
                site.addChild(pin)
            }
        }
    }

    /// The title a pin shows, read back from its label's TextComponent (see NotePinFactory).
    private static func labelText(of pin: Entity) -> String? {
        guard let text = pin.children.lazy.compactMap({ $0.components[TextComponent.self]?.text }).first else {
            return nil
        }
        return String(text.characters)
    }
}

/// The SwiftUI card shown above the selected pin.
struct FieldSiteNoteCard: View {
    let note: Note
    let open: () -> Void

    var body: some View {
        VStack(alignment: .leading, spacing: 6) {
            Text(note.title).font(.headline)
            Text(note.body).font(.caption).lineLimit(3)
            Button("Open Note", systemImage: "arrow.up.forward.app", action: open)
        }
        .padding()
        .frame(width: 260)
        .glassBackgroundEffect()
        .hoverEffect(.highlight)
    }
}
#endif

// FieldNotes/Vision/FieldSitePreview.swift
#if os(visionOS)
import SwiftUI
import RealityKit
import RealityKitContent

struct FieldSitePreview: View {
    var body: some View {
        Model3D(named: "FieldSiteTerrain", bundle: realityKitContentBundle) { model in
            model
                .resizable()
                .scaledToFit()
        } placeholder: {
            ProgressView()
        }
        .frame(width: 220, height: 160)
        .frame(depth: 60)
    }
}
#endif

// Inside FieldSiteVolume's make closure: a small title tag above every pinned note, visionOS 26 and later
for (note, position) in NotesMapLayout.positions(for: store.notes.filter(\.isPinned), tableSize: 0.5) {
    let tag = Entity()
    tag.components.set(ViewAttachmentComponent(rootView: Text(note.title).font(.caption).padding(6)
        .glassBackgroundEffect()))
    tag.position = position + [0, 0.12, 0]
    site.addChild(tag)
}

// FieldNotes/Views/NoteEditor.swift (excerpt: the toolbar's attach menu)
Menu("Attach", systemImage: "paperclip") {
    Button("Photo Library", systemImage: "photo.on.rectangle") { showPhotoPicker = true }
    #if os(iOS)
    Button("Take Photo", systemImage: "camera") { showCamera = true }   // CameraCaptureModel, iPhone and iPad only
    #endif
}

// FieldNotesWidgets/PinnedNotes/PinnedNotesWidget.swift (sketch: the visionOS families)
#if os(visionOS)
static var visionFamilies: [WidgetFamily] {
    var families: [WidgetFamily] = [.systemSmall, .systemMedium, .systemLarge, .systemExtraLargePortrait]
    if #available(visionOS 27, *) {
        families += [.accessoryCircular, .accessoryRectangular]
    }
    return families
}
#endif