777 lines
30 KiB
Swift
777 lines
30 KiB
Swift
import AVFoundation
|
|
import Observation
|
|
import SceneKit
|
|
import SwiftUI
|
|
import UIKit
|
|
|
|
@Observable
|
|
final class InventoryStore {
|
|
enum Mode: String, CaseIterable, Identifiable {
|
|
case sunseeker = "Sunseeker"
|
|
case dreamWeaver = "Dream Weaver"
|
|
case dollhouse = "Dollhouse"
|
|
|
|
var id: String { rawValue }
|
|
}
|
|
|
|
var mode: Mode = .sunseeker
|
|
var sourceImage: UIImage?
|
|
var generatedImage: UIImage?
|
|
var isProcessing: Bool = false
|
|
var sunNodesReady: Bool = false
|
|
var dollhouseHour: Double = 12
|
|
// Error message shown in the DreamWeaver panel
|
|
var errorMessage: String?
|
|
}
|
|
|
|
struct InventoryView: View {
|
|
@State private var store = InventoryStore()
|
|
@State private var showCamera = false
|
|
@State private var sliderTickHour = 12
|
|
@State private var showShareSheet = false
|
|
@State private var shareImage: UIImage? = nil
|
|
private let haptics = UIImpactFeedbackGenerator(style: .light)
|
|
|
|
var body: some View {
|
|
VStack(alignment: .leading, spacing: 16) {
|
|
// Page header — share button sits on the same baseline as the title
|
|
HStack(alignment: .top) {
|
|
VStack(alignment: .leading, spacing: 4) {
|
|
Text("Inventory")
|
|
.font(.system(size: 28, weight: .bold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Text("Sunseeker · Dream Weaver · Dollhouse")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
}
|
|
Spacer()
|
|
if let img = store.generatedImage {
|
|
Button {
|
|
shareImage = img
|
|
showShareSheet = true
|
|
} label: {
|
|
Image(systemName: "square.and.arrow.up")
|
|
.font(.system(size: 20, weight: .medium))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
.padding(8)
|
|
}
|
|
.transition(.opacity.combined(with: .scale))
|
|
}
|
|
}
|
|
.animation(.easeInOut(duration: 0.2), value: store.generatedImage != nil)
|
|
.padding(.horizontal, 20)
|
|
.padding(.top, 20)
|
|
|
|
Picker("Mode", selection: $store.mode) {
|
|
ForEach(InventoryStore.Mode.allCases) { mode in
|
|
Text(mode.rawValue).tag(mode)
|
|
}
|
|
}
|
|
.pickerStyle(.segmented)
|
|
.padding(.horizontal, 20)
|
|
.padding(.top, 12)
|
|
|
|
Group {
|
|
switch store.mode {
|
|
case .sunseeker:
|
|
#if targetEnvironment(simulator)
|
|
SimulatorUnavailableCard(
|
|
icon: "arkit",
|
|
title: "Sunseeker requires a real device",
|
|
message: "The production build no longer renders a simulated AR sun path with fake location or heading data. Use a physical iPad to inspect the live camera-based overlay."
|
|
)
|
|
#else
|
|
SunseekerPanel(sunNodesReady: $store.sunNodesReady)
|
|
#endif
|
|
|
|
case .dreamWeaver:
|
|
// No simulator guard here — CameraPicker automatically falls back
|
|
// to the photo library when no camera is available (e.g. Simulator),
|
|
// so the full Capture → Reimagine → API flow is testable without a device.
|
|
DreamWeaverPanel(
|
|
sourceImage: $store.sourceImage,
|
|
generatedImage: $store.generatedImage,
|
|
isProcessing: $store.isProcessing,
|
|
errorMessage: $store.errorMessage,
|
|
showCamera: $showCamera
|
|
)
|
|
|
|
case .dollhouse:
|
|
DollhousePanel(hour: $store.dollhouseHour, tickHour: $sliderTickHour, haptics: haptics)
|
|
}
|
|
}
|
|
.padding(.horizontal, 20)
|
|
.padding(.bottom, 20)
|
|
.animation(.easeInOut(duration: 0.25), value: store.mode)
|
|
}
|
|
.background(VelocityTheme.background)
|
|
.simultaneousGesture(
|
|
TapGesture().onEnded {
|
|
UIApplication.shared.sendAction(
|
|
#selector(UIResponder.resignFirstResponder),
|
|
to: nil, from: nil, for: nil
|
|
)
|
|
}
|
|
)
|
|
.onAppear {
|
|
UISegmentedControl.appearance().selectedSegmentTintColor = UIColor(
|
|
red: 0.231, green: 0.510, blue: 0.965, alpha: 0.85)
|
|
UISegmentedControl.appearance().setTitleTextAttributes(
|
|
[.foregroundColor: UIColor.white], for: .selected)
|
|
UISegmentedControl.appearance().setTitleTextAttributes(
|
|
[.foregroundColor: UIColor(white: 0.62, alpha: 1)], for: .normal)
|
|
UISegmentedControl.appearance().backgroundColor = UIColor(
|
|
red: 0.031, green: 0.039, blue: 0.071, alpha: 1)
|
|
}
|
|
.sheet(isPresented: $showCamera) {
|
|
CameraPicker(isPresented: $showCamera) { captured in
|
|
// Normalise orientation immediately on capture
|
|
store.sourceImage = captured.fixedOrientation()
|
|
// Clear previous result and error when a new photo is taken
|
|
store.generatedImage = nil
|
|
store.errorMessage = nil
|
|
}
|
|
}
|
|
.sheet(item: $shareImage) { img in
|
|
ShareSheet(image: img)
|
|
.ignoresSafeArea()
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Shared simulator placeholder
|
|
|
|
private struct SimulatorUnavailableCard: View {
|
|
let icon: String
|
|
let title: String
|
|
let message: String
|
|
|
|
var body: some View {
|
|
ZStack {
|
|
VStack(spacing: 14) {
|
|
Image(systemName: icon)
|
|
.font(.system(size: 40))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
Text(title)
|
|
.font(.system(size: 16, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Text(message)
|
|
.font(.system(size: 13))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
.multilineTextAlignment(.center)
|
|
}
|
|
.padding(24)
|
|
.frame(maxWidth: .infinity, maxHeight: .infinity)
|
|
}
|
|
.background(
|
|
RoundedRectangle(cornerRadius: 16)
|
|
.fill(Color(red: 0.031, green: 0.039, blue: 0.071))
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: 16)
|
|
.stroke(VelocityTheme.borderAccent, lineWidth: 1)
|
|
)
|
|
)
|
|
}
|
|
}
|
|
|
|
// MARK: - Sunseeker
|
|
|
|
private struct SunseekerPanel: View {
|
|
@Binding var sunNodesReady: Bool
|
|
@State private var vm = SunseekerViewModel()
|
|
|
|
var body: some View {
|
|
ZStack(alignment: .topLeading) {
|
|
ARSunOverlayView(sunNodesReady: $sunNodesReady, vm: vm)
|
|
.clipShape(RoundedRectangle(cornerRadius: 20))
|
|
|
|
// Retained as a stylistic design element framing the AR view
|
|
DashedSunLine()
|
|
.stroke(Color.yellow.opacity(0.9), style: StrokeStyle(lineWidth: 3, dash: [10, 8]))
|
|
.padding(.horizontal, 24)
|
|
.padding(.vertical, 80)
|
|
|
|
VStack(alignment: .leading, spacing: 12) {
|
|
// Info block
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
Text("Sunseeker")
|
|
.font(.headline)
|
|
Text("Point the iPad toward windows to inspect yearly sun-entry path.")
|
|
.font(.subheadline)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
.padding(14)
|
|
.background {
|
|
GlassBlurView(style: .systemThinMaterial)
|
|
.clipShape(RoundedRectangle(cornerRadius: 14))
|
|
}
|
|
|
|
if !vm.isReady && vm.locationError == nil {
|
|
// Loading state
|
|
HStack(spacing: 8) {
|
|
ProgressView().tint(.white)
|
|
Text("Looking for the Sun...")
|
|
.font(.footnote)
|
|
.foregroundStyle(.white)
|
|
}
|
|
.padding(.horizontal, 14)
|
|
.padding(.vertical, 10)
|
|
.background(Color.black.opacity(0.6).clipShape(Capsule()))
|
|
}
|
|
|
|
// Error banner (e.g. Location Denied)
|
|
if let error = vm.locationError {
|
|
HStack(spacing: 12) {
|
|
Image(systemName: "exclamationmark.triangle.fill")
|
|
.foregroundStyle(.yellow)
|
|
Text(error)
|
|
.font(.subheadline)
|
|
.foregroundStyle(.white)
|
|
Spacer()
|
|
Button("Settings") {
|
|
if let url = URL(string: UIApplication.openSettingsURLString) {
|
|
UIApplication.shared.open(url)
|
|
}
|
|
}
|
|
.buttonStyle(.borderedProminent)
|
|
.tint(.white.opacity(0.2))
|
|
}
|
|
.padding(14)
|
|
.background {
|
|
RoundedRectangle(cornerRadius: 14)
|
|
.fill(Color.red.opacity(0.8))
|
|
}
|
|
}
|
|
}
|
|
.padding(20)
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Dream Weaver
|
|
|
|
/// Available room types from integration guide §2
|
|
private struct RoomType: Identifiable {
|
|
let id: String // sent as the `room_type` form field
|
|
let displayName: String
|
|
let icon: String // SF Symbol
|
|
}
|
|
|
|
private let roomTypes: [RoomType] = [
|
|
RoomType(id: "bedroom", displayName: "Bedroom", icon: "bed.double"),
|
|
RoomType(id: "living_room", displayName: "Living Rm", icon: "sofa"),
|
|
RoomType(id: "bathroom", displayName: "Bathroom", icon: "drop"),
|
|
RoomType(id: "kitchen", displayName: "Kitchen", icon: "refrigerator"),
|
|
RoomType(id: "dining_room", displayName: "Dining Rm", icon: "fork.knife"),
|
|
RoomType(id: "home_office", displayName: "Office", icon: "desktopcomputer"),
|
|
RoomType(id: "hallway", displayName: "Hallway", icon: "door.left.hand.open"),
|
|
RoomType(id: "balcony", displayName: "Balcony", icon: "sun.max"),
|
|
]
|
|
|
|
private struct DreamWeaverPanel: View {
|
|
@Binding var sourceImage: UIImage?
|
|
@Binding var generatedImage: UIImage?
|
|
@Binding var isProcessing: Bool
|
|
@Binding var errorMessage: String?
|
|
@Binding var showCamera: Bool
|
|
|
|
/// Selected room type ID — sent as `room_type` field. nil = none chosen yet.
|
|
@State private var selectedRoomType: String? = nil
|
|
/// Optional extra keywords — sent as `keywords` field (§3.2)
|
|
@State private var keywords: String = ""
|
|
/// Server health: nil = checking, true = online, false = offline
|
|
@State private var serverOnline: Bool? = nil
|
|
|
|
var body: some View {
|
|
VStack(spacing: 14) {
|
|
|
|
// ── Preview card ──────────────────────────────────────────────
|
|
ZStack {
|
|
RoundedRectangle(cornerRadius: 20)
|
|
.fill(Color.black.opacity(0.9))
|
|
|
|
if let sourceImage {
|
|
Image(uiImage: sourceImage)
|
|
.resizable()
|
|
.scaledToFit()
|
|
.clipShape(RoundedRectangle(cornerRadius: 16))
|
|
.padding(12)
|
|
} else {
|
|
ContentUnavailableView(
|
|
"No Capture",
|
|
systemImage: "camera.viewfinder",
|
|
description: Text("Tap Capture to snap a room.")
|
|
)
|
|
.foregroundStyle(.white)
|
|
}
|
|
|
|
if let generatedImage {
|
|
Image(uiImage: generatedImage)
|
|
.resizable()
|
|
.scaledToFit()
|
|
.clipShape(RoundedRectangle(cornerRadius: 16))
|
|
.padding(12)
|
|
.transition(.opacity)
|
|
}
|
|
|
|
if isProcessing { ProcessingOverlay() }
|
|
|
|
// Server health badge — top-right corner
|
|
VStack {
|
|
HStack {
|
|
Spacer()
|
|
HStack(spacing: 5) {
|
|
Circle()
|
|
.fill(serverOnline == true ? Color.green : serverOnline == false ? Color.red : Color.gray)
|
|
.frame(width: 7, height: 7)
|
|
Text(serverOnline == true ? "Server Online" : serverOnline == false ? "Server Offline" : "Checking...")
|
|
.font(.system(size: 10, weight: .medium))
|
|
.foregroundStyle(.white.opacity(0.8))
|
|
}
|
|
.padding(.horizontal, 10)
|
|
.padding(.vertical, 5)
|
|
.background(.black.opacity(0.45))
|
|
.clipShape(Capsule())
|
|
.padding(14)
|
|
}
|
|
Spacer()
|
|
}
|
|
}
|
|
.frame(maxWidth: .infinity, minHeight: 420)
|
|
.animation(.easeInOut(duration: 0.35), value: generatedImage)
|
|
|
|
// ── Error banner ──────────────────────────────────────────────
|
|
if let errorMessage {
|
|
HStack(spacing: 10) {
|
|
Image(systemName: "exclamationmark.triangle.fill")
|
|
.foregroundStyle(.yellow)
|
|
Text(errorMessage)
|
|
.font(.footnote)
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
.fixedSize(horizontal: false, vertical: true)
|
|
Spacer()
|
|
}
|
|
.padding(.horizontal, 14)
|
|
.padding(.vertical, 10)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: 12)
|
|
.fill(Color.red.opacity(0.15))
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: 12)
|
|
.stroke(Color.red.opacity(0.35), lineWidth: 1)
|
|
)
|
|
)
|
|
.transition(.move(edge: .top).combined(with: .opacity))
|
|
}
|
|
|
|
// ── Room Type picker ───────────────────────────────────────
|
|
ScrollView(.horizontal, showsIndicators: false) {
|
|
HStack(spacing: 8) {
|
|
ForEach(roomTypes) { room in
|
|
Button {
|
|
withAnimation(.spring(response: 0.3)) {
|
|
// Tap again to deselect
|
|
selectedRoomType = selectedRoomType == room.id ? nil : room.id
|
|
}
|
|
} label: {
|
|
HStack(spacing: 6) {
|
|
Image(systemName: room.icon)
|
|
.font(.system(size: 11, weight: .medium))
|
|
Text(room.displayName)
|
|
.font(.system(size: 13, weight: .medium))
|
|
}
|
|
.padding(.horizontal, 12)
|
|
.padding(.vertical, 7)
|
|
.background(
|
|
Capsule()
|
|
.fill(selectedRoomType == room.id
|
|
? Color(red: 0.231, green: 0.510, blue: 0.965)
|
|
: Color.white.opacity(0.08))
|
|
)
|
|
.foregroundStyle(selectedRoomType == room.id ? .white : .white.opacity(0.6))
|
|
.overlay(
|
|
Capsule()
|
|
.stroke(selectedRoomType == room.id
|
|
? Color.clear
|
|
: Color.white.opacity(0.12), lineWidth: 1)
|
|
)
|
|
}
|
|
.buttonStyle(.plain)
|
|
}
|
|
}
|
|
.padding(.horizontal, 2)
|
|
}
|
|
|
|
// ── Keywords input ───────────────────────────────────────────
|
|
PromptInputBar(
|
|
text: $keywords,
|
|
isDisabled: sourceImage == nil || isProcessing || serverOnline == false
|
|
) {
|
|
Task { await generate() }
|
|
}
|
|
|
|
// ── Capture / Retake ─────────────────────────────────────────
|
|
Button(sourceImage == nil ? "Capture" : "Retake") {
|
|
showCamera = true
|
|
}
|
|
.buttonStyle(.borderedProminent)
|
|
.frame(maxWidth: .infinity)
|
|
}
|
|
.padding(16)
|
|
.background {
|
|
GlassBlurView(style: .systemThinMaterial)
|
|
.clipShape(RoundedRectangle(cornerRadius: 18))
|
|
.contentShape(RoundedRectangle(cornerRadius: 18))
|
|
.onTapGesture {
|
|
UIApplication.shared.sendAction(
|
|
#selector(UIResponder.resignFirstResponder),
|
|
to: nil, from: nil, for: nil
|
|
)
|
|
}
|
|
}
|
|
.animation(.easeInOut(duration: 0.3), value: errorMessage)
|
|
.task { serverOnline = await ComfyClient.shared.checkHealth() }
|
|
}
|
|
|
|
@MainActor
|
|
private func generate() async {
|
|
guard let sourceImage, !isProcessing else { return }
|
|
if serverOnline == false {
|
|
errorMessage = "Server is currently offline. Please try again later."
|
|
return
|
|
}
|
|
isProcessing = true
|
|
errorMessage = nil
|
|
do {
|
|
let result = try await ComfyClient.shared.generateImage(
|
|
source: sourceImage,
|
|
roomType: selectedRoomType ?? roomTypes[0].id, // default: bedroom
|
|
keywords: keywords.trimmingCharacters(in: .whitespaces)
|
|
)
|
|
withAnimation(.easeInOut(duration: 0.4)) {
|
|
generatedImage = result
|
|
}
|
|
} catch {
|
|
errorMessage = error.localizedDescription
|
|
}
|
|
isProcessing = false
|
|
}
|
|
}
|
|
|
|
// MARK: - Prompt Input Bar
|
|
|
|
private struct PromptInputBar: View {
|
|
@Binding var text: String
|
|
let isDisabled: Bool
|
|
let onSubmit: () -> Void
|
|
|
|
@FocusState private var isFocused: Bool
|
|
@State private var shimmer = false
|
|
|
|
private let placeholder = "gold, marble, luxury, etc."
|
|
|
|
var body: some View {
|
|
HStack(spacing: 10) {
|
|
ZStack(alignment: .leading) {
|
|
if text.isEmpty {
|
|
Text(placeholder)
|
|
.font(.system(size: 14))
|
|
.foregroundStyle(Color.white.opacity(0.35))
|
|
.padding(.leading, 4)
|
|
.allowsHitTesting(false) // let taps pass through to the gesture below
|
|
}
|
|
TextField("", text: $text, axis: .vertical)
|
|
.font(.system(size: 14))
|
|
.foregroundStyle(Color.white)
|
|
.lineLimit(1...3)
|
|
.focused($isFocused)
|
|
.submitLabel(.send)
|
|
.onSubmit {
|
|
guard !isDisabled, !text.trimmingCharacters(in: .whitespaces).isEmpty else { return }
|
|
onSubmit()
|
|
}
|
|
.tint(Color(red: 0.231, green: 0.510, blue: 0.965))
|
|
}
|
|
.contentShape(Rectangle()) // expand hit area to full ZStack bounds
|
|
.onTapGesture { isFocused = true } // focus immediately on any tap
|
|
|
|
// Send arrow button
|
|
Button {
|
|
isFocused = false
|
|
onSubmit()
|
|
} label: {
|
|
ZStack {
|
|
Circle()
|
|
.fill(
|
|
LinearGradient(
|
|
colors: [
|
|
Color(red: 0.231, green: 0.510, blue: 0.965),
|
|
Color(red: 0.40, green: 0.25, blue: 0.95)
|
|
],
|
|
startPoint: .topLeading,
|
|
endPoint: .bottomTrailing
|
|
)
|
|
)
|
|
.frame(width: 36, height: 36)
|
|
|
|
Image(systemName: "arrow.up")
|
|
.font(.system(size: 14, weight: .bold))
|
|
.foregroundStyle(.white)
|
|
}
|
|
}
|
|
.disabled(isDisabled || text.trimmingCharacters(in: .whitespaces).isEmpty)
|
|
.opacity(isDisabled || text.trimmingCharacters(in: .whitespaces).isEmpty ? 0.4 : 1.0)
|
|
.animation(.easeInOut(duration: 0.2), value: text.isEmpty)
|
|
}
|
|
.padding(.horizontal, 14)
|
|
.padding(.vertical, 10)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: 14)
|
|
.fill(Color.white.opacity(0.06))
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: 14)
|
|
.stroke(
|
|
isFocused
|
|
? Color(red: 0.231, green: 0.510, blue: 0.965).opacity(0.8)
|
|
: Color.white.opacity(0.12),
|
|
lineWidth: 1
|
|
)
|
|
)
|
|
)
|
|
.animation(.easeInOut(duration: 0.2), value: isFocused)
|
|
}
|
|
}
|
|
|
|
// MARK: - Dollhouse
|
|
|
|
private struct DollhousePanel: View {
|
|
@Binding var hour: Double
|
|
@Binding var tickHour: Int
|
|
let haptics: UIImpactFeedbackGenerator
|
|
|
|
var body: some View {
|
|
VStack(spacing: 12) {
|
|
SceneKitDollhouseView(hour: $hour)
|
|
.clipShape(RoundedRectangle(cornerRadius: 20))
|
|
.frame(maxWidth: .infinity, minHeight: 460)
|
|
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
Text(String(format: "Time: %02d:00", Int(hour.rounded())))
|
|
.font(.headline)
|
|
Slider(value: $hour, in: 0...24, step: 0.25)
|
|
.onChange(of: hour) { _, newValue in
|
|
let rounded = Int(newValue.rounded())
|
|
if rounded != tickHour {
|
|
tickHour = rounded
|
|
haptics.impactOccurred(intensity: 0.7)
|
|
}
|
|
}
|
|
}
|
|
.padding(14)
|
|
.background {
|
|
GlassBlurView(style: .systemThinMaterial)
|
|
.clipShape(RoundedRectangle(cornerRadius: 14))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - SceneKit Dollhouse
|
|
|
|
private struct SceneKitDollhouseView: UIViewRepresentable {
|
|
@Binding var hour: Double
|
|
|
|
func makeCoordinator() -> Coordinator {
|
|
Coordinator()
|
|
}
|
|
|
|
func makeUIView(context: Context) -> SCNView {
|
|
let view = SCNView()
|
|
view.scene = context.coordinator.scene
|
|
view.autoenablesDefaultLighting = false
|
|
view.allowsCameraControl = true
|
|
view.backgroundColor = UIColor.systemBackground
|
|
context.coordinator.setupScene()
|
|
context.coordinator.updateSunLight(hour: hour)
|
|
return view
|
|
}
|
|
|
|
func updateUIView(_ uiView: SCNView, context: Context) {
|
|
context.coordinator.updateSunLight(hour: hour)
|
|
}
|
|
|
|
final class Coordinator {
|
|
let scene = SCNScene()
|
|
private let sunNode = SCNNode()
|
|
|
|
func setupScene() {
|
|
if let modelScene = SCNScene(named: "Building.usdz") ?? SCNScene(named: "Building.scn") {
|
|
let container = SCNNode()
|
|
for child in modelScene.rootNode.childNodes {
|
|
container.addChildNode(child.clone())
|
|
}
|
|
scene.rootNode.addChildNode(container)
|
|
} else {
|
|
let fallback = SCNFloor()
|
|
fallback.firstMaterial?.diffuse.contents = UIColor.secondarySystemBackground
|
|
scene.rootNode.addChildNode(SCNNode(geometry: fallback))
|
|
}
|
|
|
|
let camera = SCNCamera()
|
|
let cameraNode = SCNNode()
|
|
cameraNode.camera = camera
|
|
cameraNode.position = SCNVector3(0, 4, 10)
|
|
scene.rootNode.addChildNode(cameraNode)
|
|
|
|
let light = SCNLight()
|
|
light.type = .directional
|
|
light.intensity = 1_200
|
|
light.castsShadow = true
|
|
sunNode.light = light
|
|
scene.rootNode.addChildNode(sunNode)
|
|
|
|
let ambient = SCNLight()
|
|
ambient.type = .ambient
|
|
ambient.intensity = 200
|
|
let ambientNode = SCNNode()
|
|
ambientNode.light = ambient
|
|
scene.rootNode.addChildNode(ambientNode)
|
|
}
|
|
|
|
func updateSunLight(hour: Double) {
|
|
let normalized = (hour / 24.0) * (2 * Double.pi)
|
|
let x = Float(cos(normalized) * 8.0)
|
|
let y = Float(max(sin(normalized) * 8.0, 1.0))
|
|
let z = Float(sin(normalized + .pi / 3) * 6.0)
|
|
sunNode.position = SCNVector3(x, y, z)
|
|
sunNode.look(at: SCNVector3(0, 0, 0))
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - ProcessingOverlay
|
|
|
|
private struct ProcessingOverlay: View {
|
|
@State private var animate = false
|
|
|
|
var body: some View {
|
|
ZStack {
|
|
RoundedRectangle(cornerRadius: 16)
|
|
.fill(.black.opacity(0.45))
|
|
|
|
Text("AI Processing...")
|
|
.font(.headline.weight(.bold))
|
|
.foregroundStyle(.white)
|
|
.padding(.horizontal, 20)
|
|
.padding(.vertical, 12)
|
|
.background {
|
|
GlassBlurView(style: .systemUltraThinMaterialDark)
|
|
.clipShape(Capsule())
|
|
}
|
|
.overlay(
|
|
Rectangle()
|
|
.fill(
|
|
LinearGradient(
|
|
colors: [.clear, .white.opacity(0.6), .clear],
|
|
startPoint: .leading,
|
|
endPoint: .trailing
|
|
)
|
|
)
|
|
.rotationEffect(.degrees(18))
|
|
.offset(x: animate ? 160 : -160)
|
|
.animation(.linear(duration: 1.2).repeatForever(autoreverses: false), value: animate)
|
|
.blendMode(.screen)
|
|
.mask(Capsule().frame(height: 44))
|
|
)
|
|
}
|
|
.padding(12)
|
|
.onAppear { animate = true }
|
|
}
|
|
}
|
|
|
|
// MARK: - DashedSunLine
|
|
|
|
private struct DashedSunLine: Shape {
|
|
func path(in rect: CGRect) -> Path {
|
|
var path = Path()
|
|
path.move(to: CGPoint(x: rect.minX, y: rect.maxY * 0.75))
|
|
path.addQuadCurve(
|
|
to: CGPoint(x: rect.maxX, y: rect.maxY * 0.25),
|
|
control: CGPoint(x: rect.midX, y: rect.minY + 30)
|
|
)
|
|
return path
|
|
}
|
|
}
|
|
|
|
// MARK: - CameraPicker
|
|
|
|
/// UIImagePickerController wrapper that delivers the captured image via a callback,
|
|
/// triggering orientation fix and clearing stale state immediately on capture.
|
|
private struct CameraPicker: UIViewControllerRepresentable {
|
|
@Binding var isPresented: Bool
|
|
let onCapture: (UIImage) -> Void
|
|
|
|
func makeCoordinator() -> Coordinator {
|
|
Coordinator(self)
|
|
}
|
|
|
|
func makeUIViewController(context: Context) -> UIImagePickerController {
|
|
let picker = UIImagePickerController()
|
|
picker.delegate = context.coordinator
|
|
#if targetEnvironment(simulator)
|
|
// Newer Simulators report camera as available but the shutter never
|
|
// delivers an image. Force photo library so testing actually works.
|
|
picker.sourceType = .photoLibrary
|
|
#else
|
|
if UIImagePickerController.isSourceTypeAvailable(.camera) {
|
|
picker.sourceType = .camera
|
|
picker.cameraCaptureMode = .photo
|
|
} else {
|
|
picker.sourceType = .photoLibrary
|
|
}
|
|
#endif
|
|
return picker
|
|
}
|
|
|
|
func updateUIViewController(_ uiViewController: UIImagePickerController, context: Context) {}
|
|
|
|
final class Coordinator: NSObject, UINavigationControllerDelegate, UIImagePickerControllerDelegate {
|
|
private let parent: CameraPicker
|
|
|
|
init(_ parent: CameraPicker) {
|
|
self.parent = parent
|
|
}
|
|
|
|
func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
|
|
parent.isPresented = false
|
|
}
|
|
|
|
func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey: Any]) {
|
|
if let captured = info[.originalImage] as? UIImage {
|
|
parent.onCapture(captured)
|
|
}
|
|
parent.isPresented = false
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Share Sheet
|
|
|
|
/// Wraps UIActivityViewController to match the native iOS Photos share experience.
|
|
/// Natively includes: Save Image, AirDrop, Messages, Mail, Copy, and all installed share extensions.
|
|
private struct ShareSheet: UIViewControllerRepresentable {
|
|
let image: UIImage
|
|
|
|
func makeUIViewController(context: Context) -> UIActivityViewController {
|
|
UIActivityViewController(activityItems: [image], applicationActivities: nil)
|
|
}
|
|
|
|
func updateUIViewController(_ uvc: UIActivityViewController, context: Context) {}
|
|
}
|
|
|
|
// MARK: - UIImage + Identifiable
|
|
// Required to use UIImage as the `item` in .sheet(item:)
|
|
extension UIImage: @retroactive Identifiable {
|
|
public var id: ObjectIdentifier { ObjectIdentifier(self) }
|
|
}
|