@webspatial/platform-visionos 1.0.4 → 1.0.5

package/web-spatial/WebSpatialApp.swift

@@ -0,0 +1,111 @@
+import typealias RealityKit.Attachment
+import typealias RealityKit.Entity
+import typealias RealityKit.MeshResource
+import typealias RealityKit.Model3D
+import typealias RealityKit.ModelEntity
+import typealias RealityKit.RealityView
+import typealias RealityKit.SimpleMaterial
+import SwiftUI
+
+func getCGFloat(_ val: Double?) -> CGFloat? {
+    if let v = val {
+        return CGFloat(v)
+    } else {
+        return nil
+    }
+}
+
+@main
+struct WebSpatialApp: App {
+    @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
+
+    @State var app = SpatialApp.Instance
+
+    func getDefaultSize() -> CGSize {
+        let ans = CGSize(
+            width: app
+                .getSceneOptions().defaultSize!.width,
+            height: app
+                .getSceneOptions().defaultSize!.height
+        )
+
+        return ans
+    }
+
+    func getDefaultSize3D() -> Size3D {
+        let ans = Size3D(
+            width: app
+                .getSceneOptions().defaultSize!.width,
+            height: app
+                .getSceneOptions().defaultSize!.height,
+            depth: app.getSceneOptions().defaultSize!.depth ?? 0
+        )
+
+        return ans
+    }
+
+    var body: some Scene {
+        WindowGroup(
+            id: SpatialScene.WindowStyle.window.rawValue,
+            for: String.self
+        ) { $windowData in
+            let spatialScene = SpatialApp.Instance.getScene(windowData)
+            SpatialSceneView(spatialScene: spatialScene!)
+        }
+        defaultValue: {
+            let scene = SpatialApp.Instance.createScene(
+                startURL,
+                .window,
+                .visible,
+                app.getSceneOptions()
+            )
+
+            return scene.id
+        }
+        .windowStyle(.plain)
+        .defaultSize(
+            getDefaultSize()
+        ).windowResizability(
+            app.getSceneOptions().windowResizability!
+        )
+
+        WindowGroup(id: SpatialScene.WindowStyle.volume.rawValue, for: String.self) { $windowData in
+            let spatialScene = SpatialApp.Instance.getScene(windowData)
+            SpatialSceneView(spatialScene: spatialScene!)
+                .frame(
+                    minWidth: getCGFloat(
+                        app.getSceneOptions(windowData)?.resizeRange?.minWidth),
+                    maxWidth: getCGFloat(
+                        app.getSceneOptions(windowData)?.resizeRange?.maxWidth),
+                    minHeight: getCGFloat(
+                        app.getSceneOptions(windowData)?.resizeRange?.minHeight),
+                    maxHeight: getCGFloat(
+                        app.getSceneOptions(windowData)?.resizeRange?.maxHeight)
+                )
+        }
+        defaultValue: {
+            let scene = SpatialApp.Instance.createScene(
+                startURL,
+                .volume,
+                .visible,
+                app.getSceneOptions()
+            )
+
+            return scene.id
+        }
+        .windowStyle(.volumetric)
+        .defaultSize(
+            getDefaultSize3D(),
+            in: .meters
+        ).windowResizability(
+            app.getSceneOptions().windowResizability!
+        )
+        .defaultWorldScaling(app.getSceneOptions().worldScaling)
+        .volumeWorldAlignment(app.getSceneOptions().worldAlignment)
+
+        WindowGroup(id: "loading", for: String.self) { _ in
+            LoadingView()
+        }
+        .defaultSize(CGSize(width: 400, height: 400))
+    }
+}

package/web-spatial/{libs/uiKitDelegate/Window.swift → Window.swift}

@@ -8,6 +8,7 @@ class SceneDelegate: NSObject, ObservableObject, UIWindowSceneDelegate {
     func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
         guard let windowScene = scene as? UIWindowScene else { return }
         window = windowScene.keyWindow // << store !!!
+        window?.overrideUserInterfaceStyle = .light
     }
 
     // do memory cleanup after scene removed, otherwise windowContainer cannot destroy content after being dismissed

package/web-spatial/manager/Dynamic3DManager.swift

@@ -0,0 +1,114 @@
+import Foundation
+import RealityKit
+
+enum GeometryCreationError: LocalizedError {
+    case invalidType(String)
+    case missingFields(String, [String])
+
+    var errorDescription: String? {
+        switch self {
+        case let .invalidType(t):
+            return "invalid geometry type: \(t)"
+        case let .missingFields(type, fields):
+            return "missing required fields for \(type): " + fields.joined(separator: ", ")
+        }
+    }
+}
+
+class Dynamic3DManager {
+    static func createEntity(_ props: CreateSpatialEntity) -> SpatialEntity {
+        let entity = SpatialEntity()
+        entity.name = props.name ?? ""
+        return entity
+    }
+
+    static func createModelComponent(mesh: Geometry, mats: [SpatialMaterial]) -> SpatialModelComponent {
+        return SpatialModelComponent(mesh: mesh, mats: mats)
+    }
+
+    static func createGeometry(_ props: CreateGeometryProperties) throws -> Geometry {
+        guard let type = GeometryType(rawValue: props.type) else {
+            throw GeometryCreationError.invalidType(props.type)
+        }
+        switch type {
+        case .BoxGeometry:
+            var missing: [String] = []
+            if props.width == nil { missing.append("width") }
+            if props.height == nil { missing.append("height") }
+            if props.depth == nil { missing.append("depth") }
+            if !missing.isEmpty { throw GeometryCreationError.missingFields("BoxGeometry", missing) }
+            return BoxGeometry(width: props.width!, height: props.height!, depth: props.depth!, cornerRadius: props.cornerRadius ?? 0, splitFaces: props.splitFaces ?? false)
+        case .PlaneGeometry:
+            var missing: [String] = []
+            if props.width == nil { missing.append("width") }
+            if props.height == nil { missing.append("height") }
+            if !missing.isEmpty { throw GeometryCreationError.missingFields("PlaneGeometry", missing) }
+            return PlaneGeometry(width: props.width!, height: props.height!, cornerRadius: props.cornerRadius ?? 0)
+        case .SphereGeometry:
+            var missing: [String] = []
+            if props.radius == nil { missing.append("radius") }
+            if !missing.isEmpty { throw GeometryCreationError.missingFields("SphereGeometry", missing) }
+            return SphereGeometry(radius: props.radius!)
+        case .ConeGeometry:
+            var missing: [String] = []
+            if props.radius == nil { missing.append("radius") }
+            if props.height == nil { missing.append("height") }
+            if !missing.isEmpty { throw GeometryCreationError.missingFields("ConeGeometry", missing) }
+            return ConeGeometry(radius: props.radius!, height: props.height!)
+        case .CylinderGeometry:
+            var missing: [String] = []
+            if props.radius == nil { missing.append("radius") }
+            if props.height == nil { missing.append("height") }
+            if !missing.isEmpty { throw GeometryCreationError.missingFields("CylinderGeometry", missing) }
+            return CylinderGeometry(radius: props.radius!, height: props.height!)
+        }
+    }
+
+    // Error messages are thrown from createGeometry using GeometryCreationError
+
+    static func createUnlitMaterial(_ props: CreateUnlitMaterial, _ tex: TextureResource? = nil) -> SpatialUnlitMaterial {
+        return SpatialUnlitMaterial(props.color ?? "#FFFFFF", tex, props.transparent ?? true, props.opacity ?? 1)
+    }
+
+    static func loadResourceToLocal(_ urlString: String, loadComplete: @escaping (Result<URL, Error>) -> Void) {
+        guard let url = URL(string: urlString) else {
+            loadComplete(.failure(NSError(domain: "Invalid URL", code: 0, userInfo: [NSLocalizedDescriptionKey: "Failed to create URL from string: \(urlString)"])))
+            return
+        }
+        var documentsUrl = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
+        documentsUrl.appendPathComponent(url.lastPathComponent)
+        let session = URLSession(configuration: URLSessionConfiguration.default)
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        print("start load")
+        let task = session.downloadTask(with: request, completionHandler: { location, response, error in
+            if let error = error {
+                loadComplete(.failure(error))
+                return
+            }
+            if let httpResponse = response as? HTTPURLResponse, !(200 ... 299).contains(httpResponse.statusCode) {
+                let error = NSError(domain: "HTTP Error", code: httpResponse.statusCode, userInfo: [NSLocalizedDescriptionKey: "HTTP Error \(httpResponse.statusCode)"])
+                loadComplete(.failure(error))
+                return
+            }
+            guard let location = location else {
+                loadComplete(.failure(NSError(domain: "Download Error", code: 0, userInfo: [NSLocalizedDescriptionKey: "Download location is nil"])))
+                return
+            }
+            let fileManager = FileManager.default
+            do {
+                if fileManager.fileExists(atPath: documentsUrl.path) {
+                    try fileManager.removeItem(atPath: documentsUrl.path)
+                }
+                try fileManager.moveItem(at: location, to: documentsUrl)
+                print("load complete")
+                loadComplete(.success(documentsUrl))
+            } catch {
+                print("File operation error: \(error)")
+                loadComplete(.failure(error))
+            }
+
+        })
+        task.resume()
+    }
+}

package/web-spatial/manager/JSBManager.swift

@@ -0,0 +1,148 @@
+import Foundation
+
+protocol CommandDataProtocol: Decodable {
+    static var commandType: String { get }
+}
+
+protocol ReplyDataProtocol: Encodable {
+    static var dataType: String { get }
+}
+
+struct JsbErrorData: Encodable {
+    var code: ReplyCode?
+    var message: String?
+}
+
+enum ReplyCode: Encodable {
+    case TypeError
+    case CommandError
+    case InvalidSpatialObject
+    case InvalidMatrix
+}
+
+struct JsbError: Error, Encodable {
+    let code: ReplyCode
+    let message: String
+}
+
+class JSBManager {
+    typealias ResolveHandler<T> = (Result<T?, JsbError>) -> Void
+
+    private var typeMap = [String: CommandDataProtocol.Type]()
+    private var actionWithDataMap: [String: (_ data: CommandDataProtocol, _ event: @escaping ResolveHandler<Encodable>) -> Void] = [:]
+    private var actionWithoutDataMap: [String: (@escaping ResolveHandler<Encodable>) -> Void] = [:]
+
+    private let encoder = JSONEncoder()
+
+    func register<T: CommandDataProtocol>(_ type: T.Type) {
+        typeMap[T.commandType] = type
+    }
+
+    func register<T: CommandDataProtocol>(_ type: T.Type, _ event: @escaping (T, @escaping ResolveHandler<Encodable>) -> Void) {
+        typeMap[T.commandType] = type
+        actionWithDataMap[T.commandType] = { data, result in
+            event(data as! T, result)
+        }
+    }
+
+    func register<T: CommandDataProtocol>(_ type: T.Type, _ event: @escaping (@escaping ResolveHandler<Encodable>) -> Void) {
+        typeMap[T.commandType] = type
+        actionWithoutDataMap[T.commandType] = event
+    }
+
+    func remove<T: CommandDataProtocol>(_ type: T.Type) {
+        typeMap.removeValue(forKey: T.commandType)
+        actionWithDataMap.removeValue(forKey: T.commandType)
+        actionWithoutDataMap.removeValue(forKey: T.commandType)
+    }
+
+    func clear() {
+        typeMap = [String: CommandDataProtocol.Type]()
+        actionWithDataMap = [:]
+        actionWithoutDataMap = [:]
+    }
+
+    func handlerMessage(_ message: String, _ replyHandler: ((Any?, String?) -> Void)? = nil) {
+        do {
+            let jsbInfo = message.components(separatedBy: "::")
+            let actionKey = jsbInfo[0]
+            let hasData = jsbInfo.count == 2 && jsbInfo[1] != ""
+
+            if hasData {
+                let data = try deserialize(cmdType: actionKey, cmdContent: jsbInfo[1])
+                if let action = actionWithDataMap[actionKey] {
+                    handleAction(action: { callback in
+                        action(data!, callback)
+                    }, replyHandler: replyHandler)
+                } else {
+                    print("Invalid JSB!!!", message)
+                    replyHandler?(nil, "Invalid JSB!!! \(message)")
+                }
+            } else {
+                if let action = actionWithoutDataMap[actionKey] {
+                    handleAction(action: action, replyHandler: replyHandler)
+                } else {
+                    print("Invalid JSB!!!", message)
+                    replyHandler?(nil, "Invalid JSB!!! \(message)")
+                }
+            }
+        } catch {}
+    }
+
+    private func handleAction(action: @escaping (@escaping ResolveHandler<Encodable>) -> Void,
+                              replyHandler: ((Any?, String?) -> Void)?)
+    {
+        Task { @MainActor in
+            action { result in
+                switch result {
+                case let .success(data):
+                    if data == nil {
+                        replyHandler?("", nil)
+                    } else {
+                        replyHandler?(try? data?.toDictionary() ?? "", nil)
+                    }
+
+                case let .failure(error):
+                    let resultString = self.parseData(JsbErrorData(
+                        code: error.code,
+                        message: error.message
+                    ))
+                    replyHandler?(nil, resultString)
+                }
+            }
+        }
+    }
+
+    private func deserialize(cmdType: String, cmdContent: String?) throws -> CommandDataProtocol? {
+        let decoder = JSONDecoder()
+
+        guard let type = typeof(for: cmdType) else {
+            print("unknownType")
+            return nil
+        }
+        if cmdContent == nil {
+            return nil
+        }
+        let concreteData = try decoder.decode(type.self, from: cmdContent!.data(using: .utf8)!)
+        return concreteData
+    }
+
+    private func typeof(for key: String) -> CommandDataProtocol.Type? {
+        return typeMap[key]
+    }
+
+    private func parseData(_ data: Encodable) -> String? {
+        if let jsonData = try? encoder.encode(data) {
+            let jsonString = String(data: jsonData, encoding: .utf8)
+            return jsonString!
+        }
+        return nil
+    }
+}
+
+extension Encodable {
+    func toDictionary() throws -> [String: Any] {
+        let data = try JSONEncoder().encode(self)
+        return try JSONSerialization.jsonObject(with: data, options: .allowFragments) as! [String: Any]
+    }
+}

package/web-spatial/manager/WKWebViewManager.swift

@@ -0,0 +1,39 @@
+import SwiftUI
+@preconcurrency import WebKit
+
+class WKWebViewManager {
+    static let Instance = WKWebViewManager()
+
+    private init() {}
+
+    func create(controller: SpatialWebController, configuration: WKWebViewConfiguration? = nil, spatialId: String? = "") -> WKWebView {
+        let userContentController = WKUserContentController()
+        // TODO: get native api instead of PACKAGE_VERSION
+        let userScript = WKUserScript(source: "window.WebSpatailEnabled = true; window.WebSpatailNativeVersion = 'PACKAGE_VERSION';", injectionTime: .atDocumentStart, forMainFrameOnly: false)
+        userContentController.addUserScript(userScript)
+//        userContentController.add(controller, name: "bridge")
+        userContentController.addScriptMessageHandler(controller, contentWorld: .page, name: "bridge")
+        let myConfig = (configuration != nil) ? configuration! : WKWebViewConfiguration()
+        myConfig.userContentController = userContentController
+        myConfig.preferences.javaScriptCanOpenWindowsAutomatically = true
+        myConfig.preferences.setValue(true, forKey: "allowFileAccessFromFileURLs")
+        if myConfig.urlSchemeHandler(forURLScheme: "file") == nil {
+            myConfig.setURLSchemeHandler(controller, forURLScheme: "file")
+        }
+        controller.webview = WKWebView(frame: .zero, configuration: myConfig)
+        let configUA = myConfig.applicationNameForUserAgent ?? ""
+        // change webview ua
+        let ua = controller.webview!.value(forKey: "userAgent") as? String ?? ""
+        let webviewVersion = ua.split(separator: configUA)[0].split(separator: "AppleWebKit")[1]
+        // TODO: get native api instead of PACKAGE_VERSION
+        controller.webview!.customUserAgent = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7; wv) AppleWebKit\(webviewVersion)WebSpatial/\("PACKAGE_VERSION") SpatialID/\(spatialId!)"
+        controller.webview!.uiDelegate = controller
+        controller.webview!.allowsBackForwardNavigationGestures = true
+        controller.webview!.isInspectable = true
+        controller.webview!.allowsLinkPreview = true
+        controller.webview!.navigationDelegate = controller
+        controller.webview!.scrollView.delegate = controller
+        controller.startObserving()
+        return controller.webview!
+    }
+}

package/web-spatial/{libs/webView/manifest.swift → manifest.swift}

@@ -5,7 +5,8 @@ var pwaManager = PWAManager()
 
 struct PWAManager: Codable {
     var isLocal: Bool = false
-    var start_url: String = "http://localhost:5173/"
+    var start_url: String = "http://localhost:5173/src/reality/gestures"
+
     var scope: String = ""
     var id: String = "com.webspatial.pico"
 
@@ -16,12 +17,22 @@ struct PWAManager: Codable {
     var display: PWADisplayMode = .minimal
     var display_override: [PWADisplayMode] = []
     var protocol_handlers: [PWAProtocol] = [PWAProtocol(protocolValue: "web+spatial", url: "./?cmd=%s")]
-    var mainScene: WindowContainerOptions = .init(
+    var mainScene: XSceneOptionsJSB = .init(
         defaultSize: .init(
-            width: 1280,
-            height: 720
+            width: 1024,
+            height: 768,
+            depth: 0.1
+        ),
+        type: nil,
+        resizability: ResizeRange(
+            minWidth: 0.5 * 1360,
+            minHeight: 0.5 * 1360,
+            maxWidth: 2 * 1360,
+            maxHeight: 2 * 1360
         ),
-        resizability: nil
+        worldScaling: nil,
+        worldAlignment: nil,
+        baseplateVisibility: nil
     )
     var useMainScene: Bool = true
     private var version: String = "PACKAGE_VERSION"

package/web-spatial/model/SpatialApp.swift

@@ -0,0 +1,190 @@
+import Foundation
+import SwiftUI
+
+let logger = Logger()
+
+// To load a local path, remove http:// eg.  "static-web/"
+let nativeAPIVersion = pwaManager.getVersion()
+
+// start URL
+let startURL = pwaManager.start_url
+
+let DefaultPlainWindowContainerSize = CGSize(width: 1280, height: 720)
+
+enum XLoadingMethod: String, Decodable, Encodable, Hashable {
+    case show
+    case hide
+}
+
+struct XLoadingViewData: Decodable, Hashable, Encodable {
+    let sceneID: String
+    let method: XLoadingMethod
+    let windowStyle: String?
+}
+
+struct SceneOptions {
+    var defaultSize: Size?
+    var windowResizability: WindowResizability?
+    var resizeRange: ResizeRange?
+    var worldScaling: WorldScalingBehavior
+    var worldAlignment: WorldAlignmentBehavior
+    var baseplateVisibility: Visibility
+}
+
+struct Size: Codable {
+    var width: Double
+    var height: Double
+    var depth: Double?
+}
+
+
+extension SceneOptions {
+    init(_ options: XSceneOptionsJSB) {
+        defaultSize = Size(
+            width: options.defaultSize?.width ?? DefaultPlainWindowContainerSize.width,
+            height: options.defaultSize?.height ?? DefaultPlainWindowContainerSize.height,
+            depth: options.defaultSize?.depth ?? 0
+        )
+        windowResizability = decodeWindowResizability(nil)
+        resizeRange = options.resizability
+        /// volume only
+        worldScaling = options.worldScaling?.toSDK ?? .automatic
+        worldAlignment = options.worldAlignment?.toSDK ?? .automatic
+        baseplateVisibility = options.baseplateVisibility?.toSDK ?? .automatic
+    }
+}
+
+func decodeWindowResizability(_ windowResizability: String?) -> WindowResizability {
+    switch windowResizability {
+        case "automatic":
+            return .automatic
+        case "contentSize":
+            return .contentSize
+        case "contentMinSize":
+            return .contentMinSize
+        default:
+            return .automatic
+    }
+}
+
+@Observable
+class SpatialApp {
+    private var scenes = [String: SpatialScene]()
+    
+    // delegate properties to pwaManager
+    var name: String { pwaManager.name }
+    var scope: String { pwaManager.scope }
+    var displayMode: PWADisplayMode { pwaManager.display }
+    var version: String { pwaManager.getVersion() }
+    var startURL: String { pwaManager.start_url }
+    
+    // used to cache scene config
+    private var sceneOptions: SceneOptions
+
+
+    static let Instance: SpatialApp = .init()
+
+    init() {
+        // init pwa manager
+        pwaManager._init()
+
+        Logger.initLogger()
+
+        sceneOptions = SceneOptions(pwaManager.mainScene);
+        
+        print("plainSceneOptions",sceneOptions)
+        
+        logger.debug("WebSpatial App Started -------- rootURL: " + startURL)
+    }
+    
+
+
+    func createScene(_ url: String, _ style: SpatialScene.WindowStyle, _ state: SpatialScene.SceneStateKind, _ sceneOptions: SceneOptions? = nil) -> SpatialScene {
+        var scene = SpatialScene(url, style, state, sceneOptions)
+        scenes[scene.id] = scene
+        scene
+            .on(event: SpatialObject.Events.Destroyed.rawValue, listener: onSceneDestroyed)
+
+        
+        return scene
+    }
+    
+    private func onSceneDestroyed(_ object: Any, _ data: Any) {
+        var spatialObject = object as! SpatialObject
+        spatialObject
+            .off(event: SpatialObject.Events.Destroyed.rawValue, listener: onSceneDestroyed)
+        
+        scenes.removeValue(forKey: spatialObject.id)
+    }
+
+    func getScene(_ id: String) -> SpatialScene? {
+        return scenes[id]
+    }
+
+    
+    func getSceneOptions() -> SceneOptions {
+        return sceneOptions
+    }
+    
+    func getSceneOptions(_ sceneId:String) -> SceneOptions? {
+        let spatialScene = getScene(sceneId)
+        return spatialScene?.sceneConfig
+    }
+    
+    
+    // used form window.open logic
+    public func openWindowGroup(
+        _ targetSpatialScene: SpatialScene,
+        _ sceneData: SceneOptions
+    ) {
+        if let activeScene = firstActiveScene {
+            // cache scene config
+            sceneOptions = sceneData
+                        
+            DispatchQueue.main.async() {
+                activeScene.openWindowData.send(targetSpatialScene.id)
+            }
+
+        }
+    }
+    
+    public func closeWindowGroup(_ targetSpatialScene: SpatialScene) {
+        if let activeScene = firstActiveScene {
+            activeScene.closeWindowData
+                .send(targetSpatialScene.id)
+        }
+    }
+    
+    // used form window.open logic with loading ui
+    public func openLoadingUI(_ targetSpatialScene: SpatialScene,_ open: Bool) {
+        let lwgdata = XLoadingViewData(
+            sceneID: targetSpatialScene.id,
+            method: open ? .show : .hide,
+            windowStyle: nil
+        )
+        
+        if let activeScene = firstActiveScene {
+            activeScene.setLoadingWindowData.send(lwgdata)
+        }
+    }
+    
+    private var firstActiveScene: SpatialScene? {
+        get {
+            let activeKV = scenes.first() { kv in
+                kv.value.state == .visible
+            }
+            return (activeKV?.value)
+        }
+    }
+    
+    public func focusScene(_ targetSpatialScene: SpatialScene) {
+        // only work when fully visible
+        if targetSpatialScene.state != .visible {
+            return
+        }
+
+        if let activeScene = firstActiveScene {
+            activeScene.openWindowData.send(targetSpatialScene.id)
+        }
+    }
+}