Swift SDK

// Package.swift
platforms: [.iOS(.v16), .macOS(.v13)],  // the SDK's minimums
dependencies: [
    .package(url: "https://github.com/splat3d/splat-swift-sdk", from: "1.0.0"),
],
targets: [
    .target(name: "MyApp", dependencies: [
        .product(name: "Splat3D", package: "splat-swift-sdk"),
    ]),
]

import Splat3D

let client = SplatClient(apiKey: "s3d_...")  // a key in a shipped app can be extracted from the binary
let scanner = SplatScanner()  // on the main actor

try await scanner.start()
// ... walk around the subject for at least 30 seconds ...
let capture = try await scanner.stop()

let scene = try await client.createAndProcess(
    videoURL: capture.videoURL,
    title: "Living Room",
    arkitPoses: capture.poses,
    lidarPoints: capture.lidarPoints
) { status, pct in
    print(status, pct ?? 0)  // e.g. "training 42.0"
}

import Splat3D
import SplatKit

let file = try await client.downloadScene(id: scene.id, format: .spz)

let view = SplatMetalView()  // a UIView, so add it to your view hierarchy
if view.isAvailable {
    view.loadWorld(file: file)
    view.resume()
}

view.transform = CGAffineTransform(rotationAngle: .pi)

var configuration = SplatClient.Configuration()
configuration.pollingTimeout = 4 * 60 * 60  // default 165 min
let client = SplatClient(apiKey: "s3d_...", configuration: configuration)

public func createAndProcess(
    videoURL: URL,
    title: String? = nil,
    preset: SceneParams = .standard,
    arkitPoses: [ARKitPose]? = nil,
    lidarPoints: [[Float]]? = nil,
    onProgress: (@MainActor @Sendable (SceneStatus, Double?) -> Void)? = nil,
    onSceneCreated: (@MainActor @Sendable (String) -> Void)? = nil
) async throws -> SplatScene

public func resume(
    _ interruption: SplatError.Interruption,
    onProgress: (@MainActor @Sendable (SceneStatus, Double?) -> Void)? = nil
) async throws -> SplatScene

public func resume(
    sceneID: String,
    preset: SceneParams,
    arkitPoses: [ARKitPose]?,
    lidarPoints: [[Float]]?,
    onProgress: (@MainActor @Sendable (SceneStatus, Double?) -> Void)? = nil
) async throws -> SplatScene

do {
    scene = try await client.createAndProcess(videoURL: url, arkitPoses: poses)
} catch SplatError.interrupted(let interruption) where interruption.underlying is CancellationError {
    // The task was cancelled. Keep the whole Interruption (it's Sendable): resume(_:) can
    // upload again while the presigned URL lasts (24 hours); the sceneID alone can't.
} catch SplatError.interrupted(let interruption) {
    scene = try await client.resume(interruption)
}

public struct SplatScene: Codable, Identifiable, Sendable, Equatable {
    public let id: String
    public let title: String?
    public let address: String?
    public let status: SceneStatus
    public let isPublic: Bool
    public let processingStage: String?
    public let processingPct: Double?   // 0–100
    public let numGaussians: Int?
    public let thumbnailURL: URL?       // public scenes only: for a private one use getSceneThumbnail(id:)
    public let processingError: String?
    public let viewerURL: URL?          // nil when there is no model to show
    public let downloadURL: URL?        // needs the API key: use downloadScene(id:format:)
    public let format: ModelFormat?
    public let createdAt: Date
    public let updatedAt: Date

    public var isComplete: Bool { get }   // status == .complete
    public var isFailed: Bool { get }     // status == .failed
    public var isProcessing: Bool { get } // any status that isn't terminal
}

public enum SplatError: Error, LocalizedError, Sendable {
    case unauthorized(APIError)     // 401
    case notFound(APIError)         // 404
    case rateLimited(APIError)      // 429; code "quota_exceeded": the plan's monthly limit is used up
    case requestFailed(APIError)    // any other 4xx or 5xx, e.g. conflict (409), insufficient_credits (402)
    case decodingError(Error)
    case uploadFailed(Error)        // no response, or the file is missing, unreadable or empty
    case captureFailed(Error)       // SplatScanner couldn't record
    case processingFailed(String)   // the server failed the scene
    case timeout                    // this client stopped waiting; the job may still finish
    case cancelled                  // the scene was cancelled on the server
    case notStarted                 // no job exists for this scene
    case interrupted(Interruption)  // createAndProcess stopped after creating its scene
}

@available(iOS 16.0, *)
@MainActor
public final class SplatScanner: NSObject {
    public private(set) var isRecording: Bool
    public private(set) var session: ARSession?      // attach an ARSCNView or ARView for a preview
    public private(set) var totalFrameCount: Int     // video frames written
    public var onFrameCountUpdated: ((Int) -> Void)? // poses captured so far

    public func start() async throws
    public func stop() async throws -> CaptureResult
}

public struct CaptureResult: Sendable {
    public let videoURL: URL            // H.264 video in the temporary directory
    public let poses: [ARKitPose]       // sampled at ~10 fps
    public let duration: TimeInterval
    public let lidarPoints: [[Float]]?  // [x, y, z] in ARKit world space; nil without LiDAR
}

public struct ARKitPose: Codable, Sendable, Equatable {
    public let timestamp: Double   // seconds
    public let filePath: String    // e.g. "frame_000042.jpg"
    public let transform: [Float]  // 4x4 column-major (16 floats)
    public let intrinsics: [Float] // 3x3 row-major [fx,0,cx,0,fy,cy,0,0,1] (9 floats)
    public let width: Int
    public let height: Int
}

let pose = ARKitPose(from: frame, filePath: "frame_000042.jpg")