How to Implement Spatial Audio in SwiftUI

import SwiftUI
import PHASE

// MARK: - Audio manager

@Observable
final class SpatialAudioManager {
    private(set) var isPlaying = false
    var sourceX: Float = 0          // metres left / right
    var sourceZ: Float = -2         // metres in front of listener

    private let engine: PHASEEngine
    private var source:   PHASESource?
    private var listener: PHASEListener?
    private var activeEvent: PHASESoundEvent?
    private var mixerID = ""

    private let assetID      = "SpatialAsset"
    private let soundEventID = "SpatialEvent"

    init() { engine = PHASEEngine(updateMode: .automatic) }

    // MARK: Setup

    func start() throws {
        try engine.start()
        try registerAssets()
        try buildScene()
    }

    private func registerAssets() throws {
        guard let url = Bundle.main.url(forResource: "drone", withExtension: "caf") else {
            throw URLError(.fileDoesNotExist)
        }
        try engine.assetRegistry.registerSoundAsset(
            url: url, identifier: assetID,
            assetType: .resident, channelLayout: nil, normalizationMode: .dynamic)

        let pipeline = PHASESpatialPipeline(flags: [.directPathTransmission, .lateReverb])!
        let mixerDef = PHASESpatialMixerDefinition(spatialPipeline: pipeline)

        // Geometric rolloff – fades to silence at 20 m
        let rolloff = PHASEGeometricSpreadingDistanceModelParameters()
        rolloff.fadeOutParameters =
            PHASEDistanceModelFadeOutParameters(cullDistance: 20)
        mixerDef.distanceModelParameters = rolloff

        mixerID = mixerDef.identifier       // capture for PHASEMixerParameters

        let sampler = PHASESamplerNodeDefinition(
            soundAssetIdentifier: assetID, mixerDefinition: mixerDef)
        sampler.playbackMode = .looping

        try engine.assetRegistry.registerSoundEventAsset(
            rootNode: sampler, identifier: soundEventID)
    }

    private func buildScene() throws {
        let l = PHASEListener(engine: engine)
        l.transform = matrix_identity_float4x4
        try engine.scene.add(l)
        listener = l

        let s = PHASESource(engine: engine)
        s.transform = transform(x: sourceX, z: sourceZ)
        try engine.scene.add(s)
        source = s
    }

    // MARK: Playback

    func play() throws {
        guard let source, let listener else { return }
        let params = PHASEMixerParameters()
        params.addSpatialMixerParameters(
            identifier: mixerID, source: source, listener: listener)
        let event = try PHASESoundEvent(
            engine: engine, assetIdentifier: soundEventID, mixerParameters: params)
        try event.start()
        activeEvent = event
        isPlaying = true
    }

    func stopPlayback() {
        activeEvent?.stopAndInvalidate()
        activeEvent = nil
        isPlaying = false
    }

    /// Call after changing sourceX / sourceZ to update 3D position live.
    func commitPosition() {
        source?.transform = transform(x: sourceX, z: sourceZ)
    }

    // MARK: Helpers

    private func transform(x: Float, z: Float) -> simd_float4x4 {
        var m = matrix_identity_float4x4
        m.columns.3 = SIMD4<Float>(x, 0, z, 1)
        return m
    }
}

// MARK: - SwiftUI view

struct SpatialAudioView: View {
    @State private var audio = SpatialAudioManager()
    @State private var setupError: String?

    var body: some View {
        VStack(spacing: 28) {
            Text("Spatial Audio")
                .font(.title2.bold())

            // 2D drag pad — drag dot = audio source position
            GeometryReader { geo in
                ZStack {
                    RoundedRectangle(cornerRadius: 16)
                        .fill(Color(.systemGray6))
                    crosshair
                    Circle()
                        .fill(Color.accentColor)
                        .frame(width: 36, height: 36)
                        .shadow(radius: 4)
                        .offset(dotOffset(in: geo.size))
                        .accessibilityLabel("Audio source")
                }
                .gesture(
                    DragGesture(minimumDistance: 0)
                        .onChanged { v in
                            let w = Float(geo.size.width), h = Float(geo.size.height)
                            audio.sourceX = clamp((Float(v.location.x) / w - 0.5) * 10, -5, 5)
                            audio.sourceZ = clamp((Float(v.location.y) / h - 0.5) * 10, -5, 5)
                            audio.commitPosition()
                        }
                )
            }
            .frame(height: 260)

            Button(audio.isPlaying ? "Stop" : "Play Spatial Sound") {
                if audio.isPlaying { audio.stopPlayback() }
                else { try? audio.play() }
            }
            .buttonStyle(.borderedProminent)
            .accessibilityHint(audio.isPlaying ? "Stops looping drone" : "Starts looping drone at current 3D position")

            Text("Drag the dot to move the sound source · Use headphones")
                .font(.caption)
                .foregroundStyle(.secondary)
        }
        .padding()
        .task {
            do { try audio.start() }
            catch { setupError = error.localizedDescription }
        }
        .alert("PHASE Error", isPresented: .constant(setupError != nil)) {
            Button("OK") { setupError = nil }
        } message: { Text(setupError ?? "") }
    }

    private var crosshair: some View {
        Image(systemName: "person.fill")
            .foregroundStyle(.tertiary)
            .font(.title)
            .accessibilityLabel("Listener — you")
    }

    private func dotOffset(in size: CGSize) -> CGSize {
        CGSize(
            width:  Double(audio.sourceX / 5) * size.width  / 2,
            height: Double(audio.sourceZ / 5) * size.height / 2
        )
    }

    private func clamp(_ v: Float, _ lo: Float, _ hi: Float) -> Float {
        min(max(v, lo), hi)
    }
}

#Preview {
    SpatialAudioView()
}