Novidades do RealityKit

4:33 - Set up SpatialTrackingSession

// Set up SpatialTrackingSession
@State var spatialTrackingSession = SpatialTrackingSession()

RealityView { content in
             
    let configuration = SpatialTrackingSession.Configuration(
        tracking: [.plane]
    )
		// Run the configuration
    if let unavailableCapabilities = await spatialTrackingSession.run(configuration) {
        // Handle errors
    }
}

4:34 - Set up PlaneAnchor

// Set up PlaneAnchor
RealityView { content in

		// Set up the SpatialTrackingSession

    // Add a PlaneAnchor
    let planeAnchor = AnchorEntity(.plane(.horizontal,
                                          classification: .table,
                                          minimumBounds: [0.15, 0.15]))
    content.add(planeAnchor)
}

5:48 - Handle DidAnchor event

// Handle DidAnchor event

		didAnchor = content.subscribe(to: AnchorStateEvents.DidAnchor.self) { event in

		guard let anchorComponent =
           event.entity.components[ARKitAnchorComponent.self] else { return }


		guard let planeAnchor = anchorComponent.anchor as? PlaneAnchor else { return }

		let worldSpaceFromExtent =
    planeAnchor.originFromAnchorTransform *
    planeAnchor.geometry.extent.anchorFromExtentTransform

    gameRoot.transform = Transform(matrix: worldSpaceFromExtent)

    // Add game objects to gameRoot 
}

7:38 - Set up ManipulationComponent

// Set up ManipulationComponent
extension Entity {
    static func loadModelAndSetUp(modelName: String,
                                  in bundle: Bundle) async throws -> Entity {

        let entity = // Load model and assign PhysicsBodyComponent
        let shapes = // Generate convex shape that fits the entity model

        // Initialize manipulation
        ManipulationComponent.configureEntity(entity, collisionShapes: [shapes])
        var manipulationComponent = ManipulationComponent()
        manipulationComponent.releaseBehavior = .stay
        entity.components.set(manipulationComponent)

        // Continue entity set up
    }
}

9:28 - Subscribe to willBegin ManipulationEvent

// Subscribe to ManipulationEvents

// Update the PhysicsBodyComponent to support movement
willBegin = content.subscribe(to: ManipulationEvents.WillBegin.self) { event in
    if var physicsBody = event.entity.components[PhysicsBodyComponent.self] {
        physicsBody.mode = .kinematic
        event.entity.components.set(physicsBody)
    }
}

9:29 - Subscribe to willEnd ManipulationEvent

// Subscribe to ManipulationEvents
                
// Update the PhysicsBodyComponent to be a dynamic object
willEnd = content.subscribe(to: ManipulationEvents.WillEnd.self) { event in
    if var physicsBody = event.entity.components[PhysicsBodyComponent.self] {
        physicsBody.mode = .dynamic
        event.entity.components.set(physicsBody)
    }
}

10:52 - Set up Scene understanding mesh collision and physics​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​

// Set up Scene understanding mesh collision/physics

let configuration = SpatialTrackingSession.Configuration(
    tracking: [.plane],
    sceneUnderstanding: [.collision, .physics]
)

11:56 - Set up EnvironmentBlendingComponent

// Set up EnvironmentBlendingComponent

entity.components.set(
    EnvironmentBlendingComponent(preferredBlendingMode: .occluded(by: .surroundings))​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​
)

14:20 - Set up MeshInstancesComponent

// Set up MeshInstancesComponent entity

let entity = try await ModelEntity(named:"PebbleStriped.usdz")
var meshInstancesComponent = MeshInstancesComponent()
let instances = try LowLevelInstanceData(instanceCount: 20)
meshInstancesComponent[partIndex: 0] = instances
    
instances.withMutableTransforms { transforms in
    for i in 0..<20 { 
        let scale: Float = .random(in:0.018...0.025)
        let angle: Float = .random(in:0..<2) * .pi
        let position = randomPoint(in: inArea, with: scene)
        let transform = Transform(scale: .init(repeating: scale),
                                  rotation: .init(angle: angle,axis: [0, 1, 0]),
                                  translation: position)
        transforms[i] = transform.matrix
    }
}
        
entity.components.set(meshInstancesComponent)

17:36 - Load and display a 2D photo

// Load and display a 2D photo
    
guard let url = Bundle.main.url(forResource: "my2DPhoto", withExtension: "heic") else {a​​​​​​​​​​​​​​​​​​​​​​​​​​
    return
}

let component = try await ImagePresentationComponent(contentsOf: url)

let entity = Entity()
entity.components.set(component)

17:57 - Load and display a spatial photo with windowed presentation

// Load and display a spatial photo with windowed presentation
    
guard let url = Bundle.main.url(forResource: "mySpatialPhoto", withExtension: "heic") else {
    return
}

var component = try await ImagePresentationComponent(contentsOf: url)

// Discover if the component supports windowed spatial photo presentation.
if component.availableViewingModes.contains(.spatialStereo) {
    component.desiredViewingMode = .spatialStereo
}

entity.components.set(component)

18:22 - Load and display a spatial photo with immserive presentation

// Load and display a spatial photo with immersive presentation
    
guard let url = Bundle.main.url(forResource: "mySpatialPhoto", withExtension: "heic") else {
    return
}

var component = try await ImagePresentationComponent(contentsOf: url)

// Discover if the component supports immersive spatial photo presentation.
if component.availableViewingModes.contains(.spatialStereoImmersive) {
    component.desiredViewingMode = .spatialStereoImmersive
}

entity.components.set(component)

18:56 - Load a spatial photo and use it to generate and present a spatial scene

// Load a spatial photo and use it to generate and present a spatial scene
    
guard let url = Bundle.main.url(forResource: "mySpatialPhoto", withExtension: "heic") else {
    return
}

let spatial3DImage = try await ImagePresentationComponent.Spatial3DImage(contentsOf: url)
var component = ImagePresentationComponent(spatial3DImage: spatial3DImage)

try await spatial3DImage.generate()

// Discover if the component supports windowed spatial scene presentation.
if component.availableViewingModes.contains(.spatial3D) {
    component.desiredViewingMode = .spatial3D
}

entity.components.set(component)

20:06 - Generating a spatial scene as needed

// Load a spatial photo and use it to generate and present a spatial scene
    
guard let url = Bundle.main.url(forResource: "mySpatialPhoto", withExtension: "heic") else {
    return
}

let spatial3DImage = try await ImagePresentationComponent.Spatial3DImage(contentsOf: url)
var component = ImagePresentationComponent(spatial3DImage: spatial3DImage)

component.desiredViewingMode = .spatial3D // (or .spatial3DImmersive)

entity.components.set(component)

try await spatial3DImage.generate()

23:35 - Load entity from Data object​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​

// Load entity from Data object
    
if let (data, response) = try? await URLSession.shared.data(from: url) {
    if let entity = try? await Entity(from: data) {
        content.add(entity)
    }
}