@webspatial/platform-visionos 1.0.4 → 1.0.5

package/web-spatial/model/Spatialized2DElement.swift

@@ -0,0 +1,128 @@
+import Foundation
+import RealityKit
+import SwiftUI
+
+@Observable
+class Spatialized2DElement: SpatializedElement, ScrollAbleSpatialElementContainer {
+    var cornerRadius: CornerRadius = .init()
+
+    var backgroundMaterial = BackgroundMaterial.None
+
+    var scrollPageEnabled = false
+
+    var scrollEdgeInsetsMarginRight: CGFloat? {
+        get {
+            return spatialWebViewModel.getController().webview?.scrollView.contentInset.right
+        }
+        set(newValue) {
+            spatialWebViewModel.getController().webview?.scrollView.contentInset.right = newValue ?? 0
+        }
+    }
+
+    var _scrollOffset: Vec2 = .init(x: 0, y: 0)
+    var scrollOffset: Vec2 {
+        get {
+            return _scrollOffset
+        }
+        set(newValue) {
+            _scrollOffset = newValue
+        }
+    }
+
+    func updateDeltaScrollOffset(_ delta: Vec2) {
+        spatialWebViewModel.setScrollOffset(_scrollOffset + delta)
+    }
+
+    func stopScrolling() {
+        spatialWebViewModel.stopScrolling()
+    }
+
+    private var spatialWebViewModel: SpatialWebViewModel
+    func getWebViewModel() -> SpatialWebViewModel {
+        return spatialWebViewModel
+    }
+
+    override init() {
+        spatialWebViewModel = SpatialWebViewModel(url: nil)
+
+        super.init()
+
+        spatialWebViewModel.setBackgroundTransparent(true)
+        spatialWebViewModel.addScrollUpdateListener { _, point in
+            self._scrollOffset.x = point.x
+            self._scrollOffset.y = point.y
+        }
+        spatialWebViewModel.scrollEnabled = false
+    }
+
+    // Spatialized2DElement can hold a collection of SpatializedElement children
+    private var children = [String: SpatializedElement]()
+
+    // Called by SpatializedElement.setParent
+    func addChild(_ spatializedElement: SpatializedElement) {
+        children[spatializedElement.id] = spatializedElement
+    }
+
+    // Called by SpatializedElement.setParent
+    func removeChild(_ spatializedElement: SpatializedElement) {
+        children.removeValue(forKey: spatializedElement.id)
+    }
+
+    func getChildren() -> [String: SpatializedElement] {
+        return children
+    }
+
+    func getChildrenOfType(_ type: SpatializedElementType) -> [String: SpatializedElement] {
+        let typedChildren = children.filter {
+            switch type {
+            case .Spatialized2DElement:
+                return $0.value is Spatialized2DElement
+            case .SpatializedStatic3DElement:
+                return $0.value is SpatializedStatic3DElement
+            case .SpatializedDynamic3DElement:
+                return $0.value is SpatializedDynamic3DElement
+            }
+        }
+        return typedChildren
+    }
+
+    func loadHtml(_ html: String) {
+        spatialWebViewModel.loadHTML(html)
+    }
+
+    func load(_ url: String) {
+        spatialWebViewModel.load(url)
+    }
+
+    func getView() -> SpatialWebView {
+        return spatialWebViewModel.getView()
+    }
+
+    override func onDestroy() {
+        let spatializedElements = children.map { $0.value }
+        for spatializedElement in spatializedElements {
+            spatializedElement.destroy()
+        }
+        spatialWebViewModel.destroy()
+
+        super.onDestroy()
+    }
+
+    enum CodingKeys: String, CodingKey {
+        case cornerRadius, backgroundMaterial, children, type, scrollOffset, scrollPageEnabled, webviewIsOpaque
+    }
+
+    override func encode(to encoder: Encoder) throws {
+        try super.encode(to: encoder)
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(cornerRadius, forKey: .cornerRadius)
+        try container.encode(backgroundMaterial, forKey: .backgroundMaterial)
+        try container.encode(children, forKey: .children)
+        try container.encode(SpatializedElementType.Spatialized2DElement, forKey: .type)
+        try container.encode(scrollOffset, forKey: .scrollOffset)
+        try container.encode(scrollPageEnabled, forKey: .scrollPageEnabled)
+
+        // for debug only
+        try container.encode(spatialWebViewModel.getController().webview?.isOpaque, forKey: .webviewIsOpaque)
+    }
+}

package/web-spatial/model/SpatializedDynamic3DElement.swift

@@ -0,0 +1,34 @@
+import Foundation
+
+@Observable
+class SpatializedDynamic3DElement: SpatializedElement {
+    private var rootEntity = SpatialEntity()
+
+    func getRoot() -> SpatialEntity {
+        return rootEntity
+    }
+
+    func addEntity(_ entity: SpatialEntity) {
+        rootEntity.addChild(entity)
+    }
+
+    func removeEntity(_ entity: SpatialEntity) {
+        rootEntity.removeChild(entity)
+    }
+
+    enum CodingKeys: String, CodingKey {
+        case type, root
+    }
+
+    override func encode(to encoder: Encoder) throws {
+        try super.encode(to: encoder)
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(SpatializedElementType.SpatializedDynamic3DElement, forKey: .type)
+        try container.encode(rootEntity, forKey: .root)
+    }
+
+    override func onDestroy() {
+        rootEntity.destroy()
+        super.onDestroy()
+    }
+}

package/web-spatial/model/SpatializedElement.swift

@@ -0,0 +1,95 @@
+import Foundation
+import RealityKit
+import SwiftUI
+
+enum SpatializedElementType: String, Codable {
+    case Spatialized2DElement
+    case SpatializedStatic3DElement
+    case SpatializedDynamic3DElement
+}
+
+@Observable
+class SpatializedElement: SpatialObject {
+    var clientX: Double = 0.0
+    var clientY: Double = 0.0
+    var width: Double = 0.0
+    var height: Double = 0.0
+    var depth: Double = 0.0
+    var backOffset: Double = 0.0
+    var transform: AffineTransform3D = .identity
+    var rotationAnchor: UnitPoint3D = .center
+    var opacity: Double = 1.0
+    var visible = true
+    var scrollWithParent = true
+    var zIndex: Double = 0
+
+    var enableDragStartGesture: Bool = false
+    var enableDragGesture: Bool = false
+    var enableDragEndGesture: Bool = false
+    var enableRotateStartGesture: Bool = false
+    var enableRotateGesture: Bool = false
+    var enableRotateEndGesture: Bool = false
+    var enableMagnifyStartGesture: Bool = false
+    var enableMagnifyGesture: Bool = false
+    var enableMagnifyEndGesture: Bool = false
+    var enableTapGesture: Bool = false
+
+    var enableGesture: Bool {
+        return enableDragStartGesture || enableDragGesture || enableDragEndGesture || enableRotateStartGesture || enableRotateGesture || enableRotateEndGesture || enableMagnifyStartGesture || enableMagnifyGesture || enableMagnifyEndGesture || enableTapGesture
+    }
+
+    enum CodingKeys: String, CodingKey {
+        case clientX, clientY, width, height, depth, backOffset, transform, rotationAnchor, opacity, visible, scrollWithParent, zIndex, parent, enableGesture, enableTapGesture, enableDragGesture, enableDragEndGesture, enableRotateStartGesture, enableRotateGesture, enableRotateEndGesture, enableMagnifyStartGesture, enableMagnifyGesture, enableMagnifyEndGesture
+    }
+
+    override func encode(to encoder: Encoder) throws {
+        try super.encode(to: encoder)
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(clientX, forKey: .clientX)
+        try container.encode(clientY, forKey: .clientY)
+        try container.encode(width, forKey: .width)
+        try container.encode(height, forKey: .height)
+        try container.encode(depth, forKey: .depth)
+        try container.encode(backOffset, forKey: .backOffset)
+        try container.encode(transform, forKey: .transform)
+        try container.encode(rotationAnchor, forKey: .rotationAnchor)
+        try container.encode(opacity, forKey: .opacity)
+        try container.encode(visible, forKey: .visible)
+        try container.encode(scrollWithParent, forKey: .scrollWithParent)
+        try container.encode(zIndex, forKey: .zIndex)
+        try container.encode(parent?.id, forKey: .parent)
+        try container.encode(enableGesture, forKey: .enableGesture)
+        try container.encode(enableTapGesture, forKey: .enableTapGesture)
+        try container.encode(enableDragGesture, forKey: .enableDragGesture)
+        try container.encode(enableDragEndGesture, forKey: .enableDragEndGesture)
+        try container.encode(enableRotateStartGesture, forKey: .enableRotateStartGesture)
+        try container.encode(enableRotateGesture, forKey: .enableRotateGesture)
+        try container.encode(enableRotateEndGesture, forKey: .enableRotateEndGesture)
+        try container.encode(enableMagnifyStartGesture, forKey: .enableMagnifyStartGesture)
+        try container.encode(enableMagnifyGesture, forKey: .enableMagnifyGesture)
+        try container.encode(enableMagnifyEndGesture, forKey: .enableMagnifyEndGesture)
+    }
+
+    private(set) var parent: ScrollAbleSpatialElementContainer?
+
+    func setParent(_ parent: ScrollAbleSpatialElementContainer?) {
+        if self.parent?.id == parent?.id {
+            return
+        }
+
+        if let prevParent = self.parent {
+            prevParent.removeChild(self)
+        }
+
+        parent?.addChild(self)
+        self.parent = parent
+    }
+
+    func getParent() -> ScrollAbleSpatialElementContainer? {
+        return parent
+    }
+
+    override func onDestroy() {
+        setParent(nil)
+    }
+}

package/web-spatial/model/SpatializedStatic3DElement.swift

@@ -0,0 +1,19 @@
+import Foundation
+import SwiftUI
+
+@Observable
+class SpatializedStatic3DElement: SpatializedElement {
+    var modelURL: String = ""
+    var modelTransform: AffineTransform3D = AffineTransform3D.identity
+
+    enum CodingKeys: String, CodingKey {
+        case modelURL, type
+    }
+
+    override func encode(to encoder: Encoder) throws {
+        try super.encode(to: encoder)
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(modelURL, forKey: .modelURL)
+        try container.encode(SpatializedElementType.SpatializedStatic3DElement, forKey: .type)
+    }
+}

package/web-spatial/model/dynamic3d/Geometry.swift

@@ -0,0 +1,95 @@
+import RealityKit
+import SwiftUI
+
+@Observable
+class Geometry: SpatialObject {
+    let type: GeometryType
+
+    var _resource: MeshResource?
+    var resource: MeshResource? {
+        _resource
+    }
+
+    init(_ _type: GeometryType) {
+        type = _type
+        super.init()
+    }
+
+    override func onDestroy() {
+        _resource = nil
+    }
+}
+
+@Observable
+class BoxGeometry: Geometry {
+    let width: Float
+    let height: Float
+    let depth: Float
+    let cornerRadius: Float
+    let splitFaces: Bool
+    init(width: Float, height: Float, depth: Float, cornerRadius: Float = 0, splitFaces: Bool = false) {
+        self.width = width
+        self.height = height
+        self.depth = depth
+        self.cornerRadius = cornerRadius
+        self.splitFaces = splitFaces
+        super.init(.BoxGeometry)
+        _resource = MeshResource.generateBox(width: width, height: height, depth: depth, cornerRadius: cornerRadius, splitFaces: splitFaces)
+    }
+}
+
+@Observable
+class PlaneGeometry: Geometry {
+    let width: Float
+    let height: Float
+    let cornerRadius: Float
+    init(width: Float, height: Float, cornerRadius: Float = 0) {
+        self.width = width
+        self.height = height
+        self.cornerRadius = cornerRadius
+        super.init(.PlaneGeometry)
+        _resource = MeshResource.generatePlane(width: width, height: height, cornerRadius: cornerRadius)
+    }
+}
+
+enum GeometryType: String {
+    case BoxGeometry
+    case PlaneGeometry
+    case SphereGeometry
+    case ConeGeometry
+    case CylinderGeometry
+}
+
+@Observable
+class SphereGeometry: Geometry {
+    let radius: Float
+    init(radius: Float) {
+        self.radius = radius
+        super.init(.SphereGeometry)
+        _resource = MeshResource.generateSphere(radius: radius)
+    }
+}
+
+@Observable
+class ConeGeometry: Geometry {
+    let radius: Float
+    let height: Float
+    init(radius: Float, height: Float) {
+        self.radius = radius
+        self.height = height
+        super.init(.ConeGeometry)
+        _resource = MeshResource.generateCone(height: height, radius: radius)
+    }
+}
+
+@Observable
+class CylinderGeometry: Geometry {
+    let radius: Float
+    let height: Float
+    init(radius: Float, height: Float) {
+        self.radius = radius
+        self.height = height
+        super.init(.CylinderGeometry)
+        _resource = MeshResource.generateCylinder(height: height, radius: radius)
+    }
+}

package/web-spatial/model/dynamic3d/SpatialComponent.swift

@@ -0,0 +1,72 @@
+import SwiftUI
+import RealityKit
+
+@Observable
+class SpatialComponent: SpatialObject {
+    let type: SpatialComponentType
+    
+    
+    internal var _resource:Component? = nil
+    var resource:Component? {
+        _resource
+    }
+    
+    internal var _entity:SpatialEntity? = nil
+    var entity:SpatialEntity? {
+        _entity
+    }
+    
+    init(_ _type:SpatialComponentType){
+        type = _type
+        super.init()
+    }
+    
+    func addToEntity(entity:SpatialEntity){
+        if _entity != nil {
+            print("This component has already been added to another entity")
+            return
+        }
+        if let component = resource{
+            _entity = entity
+            entity.components.set(component)
+        }
+    }
+    
+    func removeFromEntity(entity:SpatialEntity){
+        if let component = resource,
+           self.entity == entity{
+            entity.components.remove(Swift.type(of: component))
+            _entity = nil
+        }
+    }
+}
+
+@Observable
+class SpatialModelComponent: SpatialComponent {
+    init(mesh:Geometry, mats:[SpatialMaterial]){
+        super.init(.ModelComponent)
+        var materials:[any RealityKit.Material] = []
+        mats.forEach{ item in
+            materials.append(item.resource!)
+        }
+        _resource = ModelComponent(mesh: mesh.resource!, materials: materials)
+    }
+    
+    override func addToEntity(entity:SpatialEntity){
+        super.addToEntity(entity: entity)
+        entity.generateCollisionShapes(recursive: true)
+    }
+    
+    override func removeFromEntity(entity:SpatialEntity){
+        super.removeFromEntity(entity: entity)
+        entity.generateCollisionShapes(recursive: true)
+    }
+    
+    override internal func onDestroy() {
+        _resource = nil
+    }
+}
+
+enum SpatialComponentType:String {
+    case ModelComponent = "ModelComponent"
+}

package/web-spatial/model/dynamic3d/SpatialEntity.swift

@@ -0,0 +1,211 @@
+import SwiftUI
+import RealityKit
+
+@Observable
+class SpatialEntity: Entity, SpatialObjectProtocol {
+    let spatialId: String
+    
+    private var _isDestroyed: Bool = false
+    var isDestroyed: Bool {
+        return _isDestroyed
+    }
+    internal var listeners: [String: [(_ object: Any, _ data: Any) -> Void]] = [:]
+    
+    private var _enableTap: Bool = false
+    private var _enableRotate: Bool = false
+    private var _enableRotateStart: Bool = false
+    private var _enableRotateEnd: Bool = false
+    private var _enableDrag: Bool = false
+    private var _enableDragStart: Bool = false
+    private var _enableDragEnd: Bool = false
+    private var _enableMagnify: Bool = false
+    private var _enableMagnifyStart: Bool = false
+    private var _enableMagnifyEnd: Bool = false
+    
+    internal var rotation: simd_quatd = simd_quatd()
+    internal var spatialChildren: [String:SpatialEntity] = [:]
+    internal var spatialComponents: [String: SpatialComponent] = [:]
+    
+    var enableTap: Bool {
+        return _enableTap
+    }
+    var enableRotate: Bool {
+        return _enableRotate || _enableRotateStart
+    }
+    var enableDrag: Bool {
+        return _enableDrag || _enableDragStart
+    }
+    var enableMagnify: Bool {
+        return _enableMagnify || _enableMagnifyStart
+    }
+    
+    var enableRotateEnd: Bool {
+        return _enableRotateEnd
+    }
+    var enableDragEnd: Bool {
+        return _enableDragEnd
+    }
+    var enableMagnifyEnd: Bool {
+        return _enableMagnifyEnd
+    }
+    
+    var enableInteractive: Bool {
+        return enableTap || enableRotate || enableDrag || enableMagnify || enableRotateEnd || enableDragEnd || enableMagnifyEnd
+    }
+    
+    required init() {
+        self.spatialId = UUID().uuidString
+        super.init()
+        SpatialObject.objects[spatialId] = self
+        SpatialObjectWeakRefManager.setWeakRef(spatialId, self)
+    }
+    
+    init(_ _name:String){
+        self.spatialId = UUID().uuidString
+        super.init()
+        self.name = _name
+        SpatialObject.objects[spatialId] = self
+        SpatialObjectWeakRefManager.setWeakRef(spatialId, self)
+    }
+    
+    func addChild(entity:SpatialEntity){
+        spatialChildren[entity.spatialId] = entity
+        super.addChild(entity)
+    }
+    
+    func removeChild(id:String){
+        if let entity = spatialChildren[id]{
+            super.removeChild(entity)
+            spatialChildren.removeValue(forKey: id)
+        }
+        else {
+            print("no child found")
+        }
+    }
+    
+    func removeFromParent(){
+        if let parent = parent as? SpatialEntity{
+            parent.removeChild(self)
+        }
+    }
+    
+    func addComponent(_ comp: SpatialComponent) {
+        spatialComponents[comp.type.rawValue] = comp
+        comp.addToEntity(entity: self)
+    }
+    
+    func removeComponent(_ comp: SpatialComponent) {
+        if spatialComponents[comp.type.rawValue] != nil {
+            comp.removeFromEntity(entity: self)
+            spatialComponents.removeValue(forKey: comp.type.rawValue)
+        }
+    }
+    
+    func updateTransform(_ matrix:[String:Float]){
+        transform.matrix = float4x4([matrix["0"]!, matrix["1"]!, matrix["2"]!, matrix["3"]!], [matrix["4"]!, matrix["5"]!, matrix["6"]!, matrix["7"]!], [matrix["8"]!, matrix["9"]!, matrix["10"]!, matrix["11"]!], [matrix["12"]!, matrix["13"]!, matrix["14"]!, matrix["15"]!])
+    }
+    
+    func updateGesture(_ type:String, _ isEable:Bool){
+        switch WebSpatialGestureType(rawValue: type){
+        case .spatialtap:
+            _enableTap = isEable
+        case .spatialrotate:
+            _enableRotate = isEable
+        case .spatialrotatestart:
+            _enableRotateStart = isEable
+        case .spatialrotateend:
+            _enableRotateEnd = isEable
+        case .spatialdrag:
+            _enableDrag = isEable
+        case .spatialdragstart:
+            _enableDragStart = isEable
+        case .spatialdragend:
+            _enableDragEnd = isEable
+        case .spatialmagnify:
+            _enableMagnify = isEable
+        case .spatialmagnifystart:
+            _enableMagnifyStart = isEable
+        case .spatialmagnifyend:
+            _enableMagnifyEnd = isEable
+        default:
+            return
+        }
+        
+        if enableInteractive {
+            if !components.has(InputTargetComponent.self){
+                components.set(InputTargetComponent())
+            }
+        }
+        else {
+            if components.has(InputTargetComponent.self){
+                components.remove(InputTargetComponent.self)
+            }
+        }
+    }
+    
+    static func findNearestParent(entity: Entity) -> SpatialEntity?{
+        if let parent = entity.parent as? SpatialEntity{
+            return parent
+        }
+        else if entity.parent != nil {
+            return findNearestParent(entity: entity.parent!)
+        }
+        return nil
+    }
+    
+    func setRotation(_ rotation: simd_quatd) {
+        self.rotation = rotation
+        self.transform.rotation = simd_quatf(ix: Float(rotation.imag.x), iy: Float(rotation.imag.y), iz: Float(rotation.imag.z), r: Float(rotation.real))
+    }
+    
+    // Encodable
+    enum CodingKeys: String, CodingKey {
+        case id, name, isDestroyed, children, components
+    }
+    
+    func encode(to encoder: any Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(spatialId, forKey: .id)
+        try container.encode(name, forKey: .name)
+        try container.encode(isDestroyed, forKey: .isDestroyed)
+        try container.encode(spatialChildren, forKey: .children)
+        try container.encode(spatialComponents, forKey: .components)
+    }
+    
+    // Equatable
+    static func == (lhs: SpatialEntity, rhs: SpatialEntity) -> Bool {
+        return lhs.spatialId == rhs.spatialId
+    }
+    
+    func destroy() {
+        if _isDestroyed {
+            return
+        }
+        emit(event: SpatialObject.Events.BeforeDestroyed.rawValue, data: ["object": self])
+        onDestroy()
+        _isDestroyed = true
+
+        emit(event: SpatialObject.Events.Destroyed.rawValue, data: ["object": self])
+        listeners = [:]
+        SpatialObject.objects.removeValue(forKey: spatialId)
+    }
+    
+    internal func onDestroy() {
+        if(parent != nil){
+            removeFromParent()
+        }
+        components.removeAll()
+        spatialChildren.forEach { id, child in
+            child.destroy()
+        }
+        spatialChildren = [:]
+        spatialComponents.forEach { id, components in
+            components.destroy()
+        }
+        spatialComponents = [:]
+    }
+    
+    deinit {
+        SpatialObjectWeakRefManager.removeWeakRef(spatialId)
+    }
+}

package/web-spatial/model/dynamic3d/SpatialMaterial.swift

@@ -0,0 +1,39 @@
+import SwiftUI
+import RealityKit
+
+@Observable
+class SpatialMaterial: SpatialObject {
+    let type: SpatialMaterialType
+    
+    internal var _resource:RealityKit.Material? = nil
+    var resource:RealityKit.Material? {
+        _resource
+    }
+    
+    init(_ _type:SpatialMaterialType){
+        type = _type
+        super.init()
+    }
+    
+    override func onDestroy() {
+        _resource = nil
+    }
+}
+
+@Observable
+class SpatialUnlitMaterial: SpatialMaterial{
+    let color:UIColor
+    
+    init(_ color:String, _ texture:TextureResource? = nil, _ transparent:Bool = true, _ opacity:Float = 1){
+        self.color = UIColor.init(Color(hex: color))
+        super.init(.UnlitMaterial)
+        var mat = UnlitMaterial()
+        mat.color = .init(tint:UIColor(Color.init(hex: color)), texture: texture != nil ? .init(texture!) : nil)
+        mat.blending = transparent ? .transparent(opacity: .init(scale: opacity)) : .opaque
+        _resource = mat
+    }
+}
+
+enum SpatialMaterialType: String{
+    case UnlitMaterial = "UnlitMaterial"
+}