ARKit2.0-Prototype | ARKit | Augmented Reality library

import UIKit

#if canImport(RealityKit)
import RealityKit
import Combine

@available(iOS 13.0, *)
class ViewController: UIViewController {
    
    var arView = ARView(frame: .zero)
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        arView.frame = self.view.frame
        self.view.addSubview(arView)
                
        let entity = ModelEntity(mesh: .generateBox(size: 0.1))
        let anchor = AnchorEntity(world: [0,0,-2])
        anchor.addChild(entity)
        arView.scene.anchors.append(anchor)
    }
}

#else
import SceneKit

#endif

-weak_framework RealityKit -weak_framework Combine

OTHER_LDFLAGS = -weak_framework RealityFoundation

$(SRCROOT)

struct ARViewContainer: UIViewRepresentable {
    
    func makeUIView(context: Context) -> ARView {
        
        let arView = ARView(frame: .zero)
        let entity = ModelEntity(mesh: .generateBox(size: 0.1))
        let anchor = AnchorEntity(.image(group: "AR Resources", 
                                          name: "image.png"))
        entity.setParent(anchor)
        arView.scene.anchors.append(anchor)
        return arView
    }
    func updateUIView(_ uiView: ARView, context: Context) { }
}

import ARKit
import RealityKit

class ViewController: UIViewController {
    
    @IBOutlet var arView: ARView!
    var anchor: AnchorEntity!
    
    override func viewDidLoad() {
        super.viewDidLoad()

        self.anchor = AnchorEntity(world: [0,0,-1])
        
        let ball: MeshResource = .generateSphere(radius: 0.25)
        
        var material = UnlitMaterial()
        
        if #available(iOS 15.0, *) {

            material.color = try! .init(tint: .white,
                                     texture: .init(.load(named: "img", 
                                                             in: nil)))
        }
        
        let ballEntity = ModelEntity(mesh: ball, materials: [material])
        
        self.anchor.addChild(ballEntity)
        
        self.arView.scene.anchors.append(self.anchor)
    }
}

import UIKit
import RealityKit

class ViewController: UIViewController {
    
    @IBOutlet var arView: ARView!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        let url = URL(string: "https://developer.apple.com/augmented-reality/quick-look/models/cosmonaut/CosmonautSuit_en.reality")
        let documents = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
        let destination = documents.appendingPathComponent(url!.lastPathComponent)
        let session = URLSession(configuration: .default,
                                      delegate: nil,
                                 delegateQueue: nil)
        
        var request = URLRequest(url: url!)
        request.httpMethod = "GET"
        
        let downloadTask = session.downloadTask(with: request, completionHandler: { (location: URL?,
                                  response: URLResponse?,
                                     error: Error?) -> Void in
            
            let fileManager = FileManager.default
                
            if fileManager.fileExists(atPath: destination.path) {
                try! fileManager.removeItem(atPath: destination.path)
            }
            try! fileManager.moveItem(atPath: location!.path,
                                      toPath: destination.path)
                
            DispatchQueue.main.async {
                do {
                    let model = try Entity.loadAnchor(contentsOf: destination)
                    self.arView.scene.addAnchor(model)
                } catch {
                    print("Fail loading entity.")
                }
            }
        })
        downloadTask.resume()
    }
}

[1569,     0,    931]
[   0,  1569,    723]
[   0,     0,      1] 

F(mm) = F(pixels) * SensorWidth(mm) / ImageWidth(pixels)

@IBOutlet var arView: ARSCNView!

DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
        
    let imageRez = (self.arView.session.currentFrame?.camera.imageResolution)!
    let intrinsics = (self.arView.session.currentFrame?.camera.intrinsics)!
    let viewportSize = self.arView.frame.size
    let screenSize = self.arView.snapshot().size
                    
    print(imageRez as Any)
    print(intrinsics as Any)
    print(viewportSize as Any)
    print(screenSize as Any)
}

(1920.0, 1440.0)

simd_float3x3([[1665.0, 0.0, 0.0],     // first column
               [0.0, 1665.0, 0.0],     // second column
               [963.8, 718.3, 1.0]])   // third column

(375.0, 812.0)

(1125.0, 2436.0)

import SwiftUI
import ARKit

struct ContentView : View {
    
    @State var addBox: Int = 3
    @State var reset: Bool = false
    @State var node: SCNNode = SCNNode()
    
    var body: some View {
        return SceneKitView(addBox: $addBox,
                             reset: $reset,
                              node: $node).edgesIgnoringSafeArea(.all)
    }
}

struct SceneKitView: UIViewRepresentable {
    
    let arView = ARSCNView(frame: .zero)
    let config = ARWorldTrackingConfiguration()
    @Binding var addBox: Int
    @Binding var reset: Bool
    @Binding var node: SCNNode
    
    fileprivate func addShapes() {
        let letBall1Geo = SCNSphere(radius: 0.05)
        letBall1Geo.firstMaterial?.diffuse.contents = UIColor.red
        letBall1Geo.firstMaterial?.specular.contents = UIColor.white
        let ball1 = SCNNode(geometry: letBall1Geo)
        ball1.position = SCNVector3(0, 0, -1)
        self.arView.scene.rootNode.addChildNode(ball1)
                
        let letBall2Geo = SCNSphere(radius: 0.05)
        letBall2Geo.firstMaterial?.diffuse.contents = UIColor.green
        letBall2Geo.firstMaterial?.specular.contents = UIColor.white
        let ball2 = SCNNode(geometry: letBall2Geo)
        ball1.position = SCNVector3(0, 0.2, -1)
        self.arView.scene.rootNode.addChildNode(ball2)
        
        let stickGeo = SCNCapsule(capRadius: 0.05, height: 0.1)
        stickGeo.firstMaterial?.diffuse.contents = UIColor.blue
        stickGeo.firstMaterial?.specular.contents = UIColor.white
        let stick = SCNNode(geometry: stickGeo)
        stick.position = SCNVector3(0, 0.4, -1)
        self.arView.scene.rootNode.addChildNode(stick)            
    }

    func makeUIView(context: Context) -> ARSCNView {
        arView.scene = SCNScene()
        arView.autoenablesDefaultLighting = true
        arView.debugOptions = [.showFeaturePoints, .showWorldOrigin]
        arView.session.run(self.config)
        return arView
    }
    
    func updateUIView(_ uiView: ARSCNView, context: Context) {
        if addBox > 0 {
            self.addShapes()
        }
    }
}

var anchorsArray = [ARMeshAnchor]()
    
let frame = arView.session.currentFrame
    
let meshAnchors = frame?.anchors.compactMap { $0 as? ARMeshAnchor }
    
anchorsArray += meshAnchors!

anchorsArray[0].geometry.faces.buffer
anchorsArray[0].geometry.vertices.buffer
anchorsArray[0].geometry.normals.buffer
anchorsArray[0].geometry.classification?.buffer