Adding ViroKit. Needs AWSCore :(

mobile/ios/ViroKit.framework/Headers/VROARSession.h

@@ -0,0 +1,253 @@
+//
+//  VROARSession.h
+//  ViroKit
+//
+//  Created by Raj Advani on 6/6/17.
+//  Copyright © 2017 Viro Media. All rights reserved.
+//
+
+#ifndef VROARSession_h
+#define VROARSession_h
+
+#include <memory>
+#include <set>
+#include "VROLog.h"
+#include "VROMatrix4f.h"
+
+class VROARAnchor;
+class VROARFrame;
+class VROTexture;
+class VROViewport;
+class VROScene;
+class VROARNode;
+class VRONode;
+class VROARSessionDelegate;
+class VROARImageTarget;
+enum class VROCameraOrientation; //defined in VROCameraTexture.h
+
+/*
+ Determines if the AR session tracks orientation only, or
+ tracks position and orientation.
+ */
+enum class VROTrackingType {
+    DOF3,
+    DOF6
+};
+
+/*
+ The types of objects the AR session should scan each frame 
+ to detect. A VROARAnchor is created for each detected object.
+ */
+enum class VROAnchorDetection {
+    None,
+    PlanesHorizontal,
+    PlanesVertical
+};
+
+/*
+ The world alignment chosen at the start of the AR Session.
+ */
+enum class VROWorldAlignment {
+    Gravity,
+    GravityAndHeading,
+    Camera
+};
+
+/*
+ The video quality that the ARSession should *attempt* to use.
+ */
+enum class VROVideoQuality {
+    Low,
+    High
+};
+
+/*
+ The implementation of image tracking to use.
+ */
+enum class VROImageTrackingImpl {
+    ARKit,
+    Viro // not available for devs to use yet.
+};
+
+/*
+ Manages the device camera and motion tracking for AR.
+ */
+class VROARSession {
+public:
+    
+    VROARSession(VROTrackingType trackingType, VROWorldAlignment worldAlignment) :
+        _trackingType(trackingType),
+        _worldAlignment(worldAlignment),
+        _imageTrackingImpl(VROImageTrackingImpl::ARKit) {}
+    virtual ~VROARSession() {}
+    
+    VROTrackingType getTrackingType() const {
+        return _trackingType;
+    }
+
+    VROWorldAlignment getWorldAlignment() const {
+        return _worldAlignment;
+    }
+    
+    VROImageTrackingImpl getImageTrackingImpl() const {
+        return _imageTrackingImpl;
+    }
+    
+    /*
+     The scene associated with this session.
+     */
+    const std::shared_ptr<VROScene> getScene() const {
+        return _scene;
+    }
+    virtual void setScene(std::shared_ptr<VROScene> scene) {
+        _scene = scene;
+    }
+    
+    /*
+     The delegate set by the application to respond to events from the
+     AR session.
+     */
+    std::shared_ptr<VROARSessionDelegate> getDelegate() {
+        return _delegate.lock();
+    }
+    virtual void setDelegate(std::shared_ptr<VROARSessionDelegate> delegate) {
+        _delegate = delegate;
+    }
+    
+    /*
+     Start the session. The session cannot be started until its
+     scene, viewport, and orientation have been set.
+     */
+    virtual void run() = 0;
+    
+    /*
+     Pause the session. No new frames will be created.
+     */
+    virtual void pause() = 0;
+
+    /*
+     Resets the VROARSession depending on the given boolean flags. If no flags
+     are set to true, then nothing will happen.
+     */
+    virtual void resetSession(bool resetTracking, bool removeAnchors) = 0;
+
+    /*
+     Returns true if at least one frame has been generated.
+     */
+    virtual bool isReady() const = 0;
+    
+    /*
+     Set what anchors will be auto-detected by the AR session. Returns true if successful (e.g.
+     if the device supports these forms of anchor detection).
+     */
+    virtual bool setAnchorDetection(std::set<VROAnchorDetection> types) = 0;
+    
+    /*
+     Adds an image target that should be tracked by this session.
+     */
+    virtual void addARImageTarget(std::shared_ptr<VROARImageTarget> target) = 0;
+
+    /*
+     Removes an image target that should no longer be tracked by this session and the
+     corresponding anchor that matched with the target. If the image target has not
+     been found yet, then the given anchor should be nullptr
+     */
+    virtual void removeARImageTarget(std::shared_ptr<VROARImageTarget> target) = 0;
+    
+    /*
+     Add or remove anchors from the session. These methods are used for
+     placing anchors that are *not* auto-detected. The AR session will
+     not keep these anchors up to date; that is the responsibility of the
+     system that added the anchor.
+     */
+    virtual void addAnchor(std::shared_ptr<VROARAnchor> anchor) = 0;
+    virtual void removeAnchor(std::shared_ptr<VROARAnchor> anchor) = 0;
+    
+    /*
+     Invoke to update the anchor's node with the latest transformation
+     data contained in the anchor, alerting delegates in the process.
+     */
+    virtual void updateAnchor(std::shared_ptr<VROARAnchor> anchor) = 0;
+    
+    /*
+     Invoke each rendering frame. Updates the AR session with the latest
+     AR data, and returns this in a VROARFrame. The camera background is
+     updated at this point as well.
+     */
+    virtual std::unique_ptr<VROARFrame> &updateFrame() = 0;
+    
+    /*
+     Get the last frame that was generated via updateFrame().
+     */
+    virtual std::unique_ptr<VROARFrame> &getLastFrame() = 0;
+    
+    /*
+     Get the background texture for this AR session. The contents of this
+     texture are updated after each call to updateFrame().
+     */
+    virtual std::shared_ptr<VROTexture> getCameraBackgroundTexture() = 0;
+    
+    /*
+     Invoke when the viewport changes. The AR engine may adjust its camera
+     background and projection matrices in response to a viewport change.
+     */
+    virtual void setViewport(VROViewport viewport) = 0;
+    
+    /*
+     Invoke when orientation changes, so the AR engine can make the 
+     necessary adjustments.
+     */
+    virtual void setOrientation(VROCameraOrientation orientation) = 0;
+
+    /*
+     Sets AR world origin to the given transform.
+     */
+    virtual void setWorldOrigin(VROMatrix4f relativeTransform) = 0;
+    
+    /*
+     Sets whether or not to enable autofocus.
+     */
+    virtual void setAutofocus(bool enabled) = 0;
+    
+    /*
+     Sets the video quality to use.
+     */
+    virtual void setVideoQuality(VROVideoQuality quality) = 0;
+    
+private:
+    
+    VROTrackingType _trackingType;
+    VROWorldAlignment _worldAlignment;
+    VROImageTrackingImpl _imageTrackingImpl;
+    std::shared_ptr<VROScene> _scene;
+    std::weak_ptr<VROARSessionDelegate> _delegate;
+
+};
+
+class VROARSessionDelegate {
+public:
+    
+    /*
+     Invoked whenever an anchor is detected by the AR session, or when an 
+     anchor is manually added to the session via addAnchor(). The application
+     can choose to add a VROARNode to associate virtual content with this
+     anchor by setting a VROARNode on the anchor.
+     */
+    virtual void anchorWasDetected(std::shared_ptr<VROARAnchor> anchor) = 0;
+    
+    /*
+     Invoked just before and after the anchor's node's properties are updated
+     to match the current state of the anchor.
+     */
+    virtual void anchorWillUpdate(std::shared_ptr<VROARAnchor> anchor) = 0;
+    virtual void anchorDidUpdate(std::shared_ptr<VROARAnchor> anchor) = 0;
+    
+    /*
+     Invoked when an anchor is removed from the AR session, along with its
+     corresponding node (now detached from the scene).
+     */
+    virtual void anchorWasRemoved(std::shared_ptr<VROARAnchor> anchor) = 0;
+    
+};
+
+#endif /* VROARSession_h */