@interface ViewController () <ARSCNViewDelegate>
//AR view: displays the 3D interface
@property (nonatomic, strong) IBOutlet ARSCNView *sceneView;

@end

    
@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    //Scene delegate
    self.sceneView.delegate = self;
    
    // Display frame rate
    self.sceneView.showsStatistics = YES;
    
    // Create a scene
    SCNScene *scene = [SCNScene sceneNamed:@"art.scnassets/ship.scn"];
    
    // Set the scene to the view
    self.sceneView.scene = scene;
}

- (void)viewWillAppear:(BOOL)animated {
    [super viewWillAppear:animated];
    
    // World coordinate system configuration
    ARWorldTrackingSessionConfiguration *configuration = [ARWorldTrackingSessionConfiguration new];
    
    // Run the 3D scene session
    [self.sceneView.session runWithConfiguration:configuration];
}

- (void)viewWillDisappear:(BOOL)animated {
    [super viewWillDisappear:animated];
    
    // Pause
    [self.sceneView.session pause];
}

- (void)didReceiveMemoryWarning {
    [super didReceiveMemoryWarning];
    // Release any cached data, images, etc that aren't in use.
}

#pragma mark - ARSCNViewDelegate


// Create a node for the current anchor (think of a node as a UIView)
/*
// Override to create and configure nodes for anchors added to the view's session.
- (SCNNode *)renderer:(id<SCNSceneRenderer>)renderer nodeForAnchor:(ARAnchor *)anchor {
    SCNNode *node = [SCNNode new];
 
    // Add geometry to the node...
 
    return node;
}
*/

//Session error
- (void)session:(ARSession *)session didFailWithError:(NSError *)error {
    // Present an error message to the user
    
}

//Interrupted, similar to audio playback being interrupted, e.g., foreground/background switching, phone calls, Siri
- (void)sessionWasInterrupted:(ARSession *)session {
    // Inform the user that the session has been interrupted, for example, by presenting an overlay
    
}

//Session ended
- (void)sessionInterruptionEnded:(ARSession *)session {
    // Reset tracking and/or remove existing anchors if consistent tracking is required
    
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    //1. Use the scene to load the scn file
    
    SCNScene *scene = [SCNScene sceneNamed:@"Models.scnassets/vase/vase.scn"];
    SCNNode *plantNode = scene.rootNode.childNodes[0];
    
    //2. Adjust the position and add the node to the current screen
    plantNode.position = SCNVector3Make(0, -1, -1);
    
    
    //3. Add the airplane node to the current screen
    [self.arSceneView.scene.rootNode addChildNode:plantNode];
    
}

[self.view addSubview:xxx];

[scene.rootNode addChildNode:xxxNode];

@interface ARAnchor : NSObject <NSCopying>

//Unique identifier of the anchor
@property (nonatomic, readonly) NSUUID *identifier;

//The anchor's rotation/transform matrix, defining the anchor's rotation, position, and scale. A 4x4 matrix.
@property (nonatomic, readonly) matrix_float4x4 transform;

//Initializer — generally we don't need to call it. When adding a 3D object, ARKit notifies us of the object's anchor via its delegate
- (instancetype)initWithTransform:(matrix_float4x4)transform;

FOUNDATION_EXTERN NSString *const ARErrorDomain;

typedef NS_ERROR_ENUM(ARErrorDomain, ARErrorCode) {
    /** Unsupported session configuration. */
    ARErrorCodeUnsupportedConfiguration   = 100,
    
    /** A sensor required to run the session is not available. */
    ARErrorCodeSensorUnavailable          = 101,
    
    /** A sensor failed to provide the required input. */
    ARErrorCodeSensorFailed               = 102,
    
    /** App does not have permission to use the camera. The user may change this in settings. */
    ARErrorCodeCameraUnauthorized         = 103,
    
    /** World tracking has encountered a fatal error. */
    ARErrorCodeWorldTrackingFailed        = 200,
};

@interface ARFrame : NSObject <NSCopying>

//Timestamp
@property (nonatomic, readonly) NSTimeInterval timestamp;

//Image frame
@property (nonatomic, readonly) CVPixelBufferRef capturedImage;

//Camera (indicates which camera this ARFrame belongs to — the iPhone 7 Plus has two cameras)
@property (nonatomic, copy, readonly) ARCamera *camera;

//Returns the anchor data captured by the current camera (when a 3D virtual model is added to ARKit, the anchor is the model's position in AR)
@property (nonatomic, copy, readonly) NSArray<ARAnchor *> *anchors;

//Lighting, referring to light intensity, generally 0–2000, default 1000
@property (nonatomic, strong, nullable, readonly) ARLightEstimate *lightEstimate;

//Feature points (should be for detecting planes or faces — Apple has built-in face recognition). Only available with world tracking configuration
@property (nonatomic, strong, nullable, readonly) ARPointCloud *rawFeaturePoints;

//Searches for a 3D model based on a 2D coordinate point. This method is typically used when we tap a point on the phone screen to capture the 3D model at that point. Why does it return an array? Easy to understand: the phone screen is a rectangle — a 2D space — while the camera captures a rectangular frustum projected outward from this 2D space. Tapping a point on the screen is like shooting a ray from the edge of this frustum, and there may be multiple 3D object models along that ray.
point：2D坐标点（手机屏幕某一点）
ARHitTestResultType：捕捉类型  点还是面
(NSArray<ARHitTestResult *> *)：追踪结果数组

- (NSArray<ARHitTestResult *> *)hitTest:(CGPoint)point types:(ARHitTestResultType)types;

//Coordinate transform of the camera's window (can be used to adapt to camera rotation in portrait/landscape)
-(CGAffineTransform)displayTransformWithViewportSize:(CGSize)viewportSize orientation:(UIInterfaceOrientation)orientation;

@end

@interface ARAnchor (Unavailable)

- (instancetype)init NS_UNAVAILABLE;
+ (instancetype)new NS_UNAVAILABLE;
@end

typedef NS_OPTIONS(NSUInteger, ARHitTestResultType) {
    //Point
    ARHitTestResultTypeFeaturePoint              = (1 << 0),
	//Horizontal plane, y is 0.    
    ARHitTestResultTypeEstimatedHorizontalPlane  = (1 << 1),
    
    //Existing plane
    ARHitTestResultTypeExistingPlane             = (1 << 3),
    
    //Existing anchor and plane
    ARHitTestResultTypeExistingPlaneUsingExtent  = (1 << 4),
} NS_SWIFT_NAME(ARHitTestResult.ResultType);

@interface ARHitTestResult : NSObject

//Capture type
@property (nonatomic, readonly) ARHitTestResultType type;

//Distance between the 3D virtual object and the camera (in meters)
@property (nonatomic, readonly) CGFloat distance;

//Local coordinate matrix (world coordinates are relative to the camera as the scene origin, while each 3D object has its own scene, and local coordinates are relative to that scene). Similar to the difference between frame and bounds
@property (nonatomic, readonly) matrix_float4x4 localTransform;

//World coordinate matrix
@property (nonatomic, readonly) matrix_float4x4 worldTransform;

//Anchor (a 3D virtual object has a position in the virtual world, given by SCNVector3: a 3D vector in SceneKit), while the anchor is the object's position in the AR real scene — a 4x4 matrix
@property (nonatomic, strong, nullable, readonly) ARAnchor *anchor;

@end

@interface ARLightEstimate : NSObject

//Ambient light intensity, range 0–2000, default 1000
@property (nonatomic, readonly) CGFloat ambientIntensity;

//Ambient color temperature
@property (nonatomic, readonly) CGFloat ambientColorTemperature;

@end

@interface ARPlaneAnchor : ARAnchor

//Plane type — currently only one: the horizontal plane 
@property (nonatomic, readonly) ARPlaneAnchorAlignment alignment;

//3-axis vector struct, the center point of the plane  x/y/z
@property (nonatomic, readonly) vector_float3 center;

//3-axis vector struct, the size of the plane (width and height)  x/y/z
@property (nonatomic, readonly) vector_float3 extent;

@end

@interface ARPointCloud : NSObject <NSCopying>

//Point count
@property (nonatomic, readonly) NSUInteger count;

//The collection of each point's position (a struct with * means an array of structs)
@property (nonatomic, readonly) const vector_float3 *points;

@end

//Tracking alignment
typedef NS_ENUM(NSInteger, ARWorldAlignment) {
    /* Camera position vector (0, -1, 0) /
    ARWorldAlignmentGravity,
    /* Camera position and orientation. vector (0, -1, 0)    heading: (0, 0, -1) */
    ARWorldAlignmentGravityAndHeading,
    /* Camera orientation. */
    ARWorldAlignmentCamera
} ;

typedef NS_OPTIONS(NSUInteger, ARPlaneDetection) {
    ARPlaneDetectionNone        = 0,
    ARPlaneDetectionHorizontal  = (1 << 0), //探测平面是水平横向
} ;


@interface ARConfiguration : NSObject <NSCopying>

//Whether the current device supports it — generally devices below the A9 chip don't
@property(class, nonatomic, readonly) BOOL isSupported;

//World coordinate alignment 
@property (nonatomic, readwrite) ARWorldAlignment worldAlignment;

//Whether to enable adaptive lighting, default is YES
@property (nonatomic, readwrite, getter=isLightEstimationEnabled) BOOL lightEstimationEnabled;

@end

//World session tracking configuration. Apple recommends using this class. It has only one property, which helps us track planes captured by the camera
@interface ARWorldTrackingSessionConfiguration : ARConfiguration

//Detection type
@property (nonatomic, readwrite) ARPlaneDetection planeDetection;

@end

@interface ARSCNView : SCNView

//Delegate
@property (nonatomic, weak, nullable) id<ARSCNViewDelegate> delegate;

//AR session
@property (nonatomic, strong) ARSession *session;

//Scene
@property(nonatomic, strong) SCNScene *scene;

//Whether to automatically adapt lighting
@property(nonatomic) BOOL automaticallyUpdatesLighting;

//Returns the anchor for the corresponding node. A node is a 3D virtual object whose coordinates are in the virtual scene, while the ARAnchor is the real-world coordinate in ARKit
- (nullable ARAnchor *)anchorForNode:(SCNNode *)node;

//Returns the node for the corresponding anchor
- (nullable SCNNode *)nodeForAnchor:(ARAnchor *)anchor;

/**


 */
- (NSArray<ARHitTestResult *> *)hitTest:(CGPoint)point types:(ARHitTestResultType)types;

@end

//The delegate internally implements SCNSceneRendererDelegate (the SceneKit delegate) and ARSessionObserver (ARSession observation, KVO mechanism)
#pragma mark - ARSCNViewDelegate
@protocol ARSCNViewDelegate <SCNSceneRendererDelegate, ARSessionObserver>
@optional

//The anchor for a custom node
- (nullable SCNNode *)renderer:(id <SCNSceneRenderer>)renderer nodeForAnchor:(ARAnchor *)anchor;

//Called when a node is added. Through this delegate method, we can learn the anchor (AR real-world coordinate) where a virtual object is added to the AR scene
- (void)renderer:(id <SCNSceneRenderer>)renderer didAddNode:(SCNNode *)node forAnchor:(ARAnchor *)anchor;

//The node is about to be updated
- (void)renderer:(id <SCNSceneRenderer>)renderer willUpdateNode:(SCNNode *)node forAnchor:(ARAnchor *)anchor;

//The node has been updated
- (void)renderer:(id <SCNSceneRenderer>)renderer didUpdateNode:(SCNNode *)node forAnchor:(ARAnchor *)anchor;

//Remove node
- (void)renderer:(id <SCNSceneRenderer>)renderer didRemoveNode:(SCNNode *)node forAnchor:(ARAnchor *)anchor;

@end

@interface ARSession : NSObject

//Delegate
@property (nonatomic, weak) id <ARSessionDelegate> delegate;

//Specifies the queue on which the delegate is called (the main queue has no delay; background queues do). Defaults to the main queue if not specified
@property (nonatomic, strong, nullable) dispatch_queue_t delegateQueue;

//The camera's current position (computed by the session tracking configuration)
@property (nonatomic, copy, nullable, readonly) ARFrame *currentFrame;

//Session configuration
@property (nonatomic, copy, nullable, readonly) ARConfiguration *configuration;

//Run the session (this line of code is the key to starting AR)
- (void)runWithConfiguration:(ARConfiguration *)configuration NS_SWIFT_UNAVAILABLE("Use run(_:options:) instead");

//Run the session, but with an extra parameter ARSessionRunOptions: it defines the behavior when the session disconnects and reconnects.
- (void)runWithConfiguration:(ARConfiguration *)configuration options:(ARSessionRunOptions)options NS_SWIFT_NAME(run(_:options:));

//Pause the session
- (void)pause;

//Add an anchor
- (void)addAnchor:(ARAnchor *)anchor NS_SWIFT_NAME(add(anchor:));

//Remove an anchor
- (void)removeAnchor:(ARAnchor *)anchor NS_SWIFT_NAME(remove(anchor:));

@end

typedef NS_OPTIONS(NSUInteger, ARSessionRunOptions) {
	 //Reset tracking
    ARSessionRunOptionResetTracking           = (1 << 0),
    
    //Remove existing anchors
    ARSessionRunOptionRemoveExistingAnchors   = (1 << 1)
};

@protocol ARSessionObserver <NSObject>

@optional

//Session failed
- (void)session:(ARSession *)session didFailWithError:(NSError *)error;

//The camera's tracking state changed
- (void)session:(ARSession *)session cameraDidChangeTrackingState:(ARCamera *)camera;

//Session unexpectedly interrupted (after starting ARSession, moving the app to the background can cause the session to be interrupted)
- (void)sessionWasInterrupted:(ARSession *)session;

//Session resumed after interruption (briefly going to the background and returning to the app resumes automatically)
- (void)sessionInterruptionEnded:(ARSession *)session;

//Session output an audio data `CMSampleBufferRef` 
- (void)session:(ARSession *)session didOutputAudioSampleBuffer:(CMSampleBufferRef)audioSampleBuffer;

@end

相机位置发生改变 就是相机的位置有变动
- (void)session:(ARSession *)session didUpdateFrame:(ARFrame *)frame;

// Anchors added
- (void)session:(ARSession *)session didAddAnchors:(NSArray<ARAnchor*>*)anchors;

//Update anchors
- (void)session:(ARSession *)session didUpdateAnchors:(NSArray<ARAnchor*>*)anchors;

//Remove anchors
- (void)session:(ARSession *)session didRemoveAnchors:(NSArray<ARAnchor*>*)anchors;

@end

@interface ARCamera : NSObject <NSCopying>

//4x4 matrix representing the camera's position, similar to an anchor
@property (nonatomic, readonly) matrix_float4x4 transform;

//The vector Euler angles of the camera's orientation (rotation), for x/y/z respectively
@property (nonatomic, readonly) vector_float3 eulerAngles;

//Camera tracking state (the enum values are introduced below)
@property (nonatomic, readonly) ARTrackingState trackingState NS_REFINED_FOR_SWIFT;

//Tracking reason
@property (nonatomic, readonly) ARTrackingStateReason trackingStateReason NS_REFINED_FOR_SWIFT;

//Camera intrinsics, a 3x3 matrix  
@property (nonatomic, readonly) matrix_float3x3 intrinsics;

//Camera resolution
@property (nonatomic, readonly) CGSize imageResolution;

//Projection matrix
@property (nonatomic, readonly) matrix_float4x4 projectionMatrix;


//Create camera using x, y, z position 
- (CGPoint)projectPoint:(vector_float3)point orientation:(UIInterfaceOrientation)orientation viewportSize:(CGSize)viewportSize;
 
//Create the camera projection matrix — near plane distance, far plane distance
- (matrix_float4x4)projectionMatrixForOrientation:(UIInterfaceOrientation)orientation viewportSize:(CGSize)viewportSize zNear:(CGFloat)zNear zFar:(CGFloat)zFar;

//Create the camera projection matrix
- (matrix_float4x4)viewMatrixForOrientation:(UIInterfaceOrientation)orientation;

@end

//Camera tracking state enum
typedef NS_ENUM(NSInteger, ARTrackingState) {
	 /* Not available */
    ARTrackingStateNotAvailable,
    
    /* Limited */
    ARTrackingStateLimited,
    
    /* Normal. */
    ARTrackingStateNormal,
};

//Tracking reason
typedef NS_ENUM(NSInteger, ARTrackingStateReason) {
    /* None. */
    ARTrackingStateReasonNone,
    
    //Initializing
    ARTrackingStateReasonInitializing,
    
    /* Excessive motion. */
    ARTrackingStateReasonExcessiveMotion,
    
    /** Insufficient features. */
    ARTrackingStateReasonInsufficientFeatures,
}

#pragma mark -
#pragma mark - ARSCNViewDelegate 代理

- (void)renderer:(id <SCNSceneRenderer>)renderer didAddNode:(SCNNode *)node forAnchor:(ARAnchor *)anchor{
    if ([anchor isMemberOfClass:[ARPlaneAnchor class]]) {
        NSLog(@"捕捉到平地");
        //Add a 3D plane model. ARKit only has detection capability; an anchor is a spatial position. To see this space more clearly, we need to add a 3D plane model to render it
        //1. Get the detected plane anchor
        ARPlaneAnchor *planeAnchor = (ARPlaneAnchor *)anchor;
        //2. Create a 3D object model (the plane detected by the system is an irregularly sized rectangle; here we turn it into a rectangle and scale the plane)
        //Create a box — parameters: width, height, length, chamfer radius
        SCNBox *plane = [SCNBox boxWithWidth:planeAnchor.extent.x * 0.3 height:0 length:planeAnchor.extent.x * 0.3 chamferRadius:0];
        //3. Render the 3D model with a material — the default model is white
        plane.firstMaterial.diffuse.contents = [UIColor cyanColor];
        
        //4. Create a node based on the 3D object model
        SCNNode *planeNode = [SCNNode nodeWithGeometry:plane];
        //5. Set the node's position to the anchor and center of the detected plane. In SceneKit, a node's position is a vector coordinate SCNVector3Make based on the 3D coordinate system
        planeNode.position = SCNVector3Make(planeAnchor.center.x, 0, planeAnchor.center.z);
        
        [node addChildNode:planeNode];
        
        //6. When a plane is detected, add a 3D model onto the plane 2 seconds later
        
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            //1. Create a vase scene
            SCNScene *scene = [SCNScene sceneNamed:@"Models.scnassets/vase/vase.scn"];
            //2. Get the vase node (a scene can have multiple nodes; here, the vase node is simply the first child node of the scene)
            //Every scene has one and only one root node; all other nodes are children of the root node
            SCNNode *vaseNode = scene.rootNode.childNodes[0];
            
            //4. Set the vase node's position to the detected plane's position; if not set, it defaults to the origin, i.e., the camera position
            vaseNode.position = SCNVector3Make(planeAnchor.center.x, 0, planeAnchor.center.z);
            
            //5. Add the vase node to the current screen
            //!!!Important: the vase node is added to the node captured by the delegate, not to the AR view's root node, because the detected plane anchor is in a local coordinate system, not the world coordinate system
            [node addChildNode:vaseNode];
        });
    }
}