Adding ViroKit. Needs AWSCore :(

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

@@ -0,0 +1,296 @@
+//
+//  VROInputControllerBase.h
+//  ViroRenderer
+//
+//  Copyright © 2017 Viro Media. All rights reserved.
+//
+
+#ifndef VROInputControllerBase_h
+#define VROInputControllerBase_h
+
+#include <stdio.h>
+#include <vector>
+#include <string>
+#include <memory>
+#include <set>
+#include <float.h>
+#include "VROInputPresenter.h"
+#include "VROScene.h"
+#include "VRORenderContext.h"
+#include "VROEventDelegate.h"
+#include "VROHitTestResult.h"
+#include "VRONode.h"
+#include "VROGeometry.h"
+
+static const float ON_DRAG_DISTANCE_THRESHOLD = 0.01;
+static const float ON_PINCH_SCALE_THRESHOLD = 0.02;
+static const float ON_ROTATE_THRESHOLD = 0.01; // in radians (~.5729 degrees)
+static float kSceneBackgroundDistance = 8;
+
+/*
+ Responsible for mapping generalized input data from a controller, to a unified
+ set of VROEventDelegate.EventTypes. It then notifies corresponding VROEventDelegates
+ in the current scene about the event type that has been triggered.
+ 
+ For example, VROInputControllerDaydream maps the onTouchPadClick event onto
+ a Viro onPrimaryClick event type within VROInputControllerBase, of which then notifies all
+ VROEventDelegates about such an event.
+ */
+class VROInputControllerBase {
+public:
+    VROInputControllerBase();
+    virtual ~VROInputControllerBase(){}
+    
+    /*
+     For testing background reticle distance.
+     */
+    void debugMoveReticle();
+
+    /*
+     onProcess is to be implemented by derived classes to drive the processing
+     of platform-specific input events and map them to viro-specific input events.
+     */
+    virtual void onProcess(const VROCamera &camera) {
+        //No-op
+    }
+
+    /*
+     Called when the renderer is about to be backgrounded within Android's lifecycle.
+     */
+    virtual void onPause() {
+        // No-op
+    }
+
+    /*
+     Called when the renderer is about to be foregrounded within Android's lifecycle.
+     */
+    virtual void onResume() {
+        // No-op
+    }
+
+    void attachScene(std::shared_ptr<VROScene> scene) {
+        _scene = scene;
+    }
+    void detachScene() {
+        _scene = nullptr;
+    }
+    
+    /*
+     Set the current view and projection matrices.
+     */
+    void setView(VROMatrix4f view);
+    void setProjection(VROMatrix4f projection);
+
+    /*
+     Get the presenter, creating it if it does not yet exist. Must be invoked on the
+     rendering thread.
+     */
+    std::shared_ptr<VROInputPresenter> getPresenter() {
+        if (!_controllerPresenter) {
+            _controllerPresenter = createPresenter();
+            registerEventDelegate(_controllerPresenter);
+        }
+        return _controllerPresenter;
+    }
+
+    virtual std::string getHeadset() = 0;
+    virtual std::string getController() = 0;
+
+   /*
+    For notifying components outside the scene tree, we specifically register
+    them here to be tracked by the VROEventManager. Calling registerEventDelegate
+    twice with the same delegate will only have callbacks be triggered once.
+    */
+    void registerEventDelegate(std::shared_ptr<VROEventDelegate> delegate){
+        _delegates.insert(delegate);
+    }
+    void removeEventDelegate(std::shared_ptr<VROEventDelegate> delegate){
+        _delegates.erase(delegate);
+    }
+
+    /*
+     Below are Viro-specific input events to be trigged by derived Input Controller
+     classes; these are the Viro-sepcific events that platform-specific events
+     are mapped to.
+     */
+    void onControllerStatus(int source, VROEventDelegate::ControllerStatus status);
+    void onButtonEvent(int source, VROEventDelegate::ClickState clickAction);
+    void onTouchpadEvent(int source, VROEventDelegate::TouchState touchAction, float lastKnownX, float lastKnownY);
+    
+    /*
+     The following position, rotation and forward are all in world coordinates.
+     */
+    void onMove(int source, VROVector3f position, VROQuaternion rotation, VROVector3f forward);
+    void onSwipe(int source, VROEventDelegate::SwipeState swipeState);
+    void onScroll(int source, float x, float y);
+    
+    /*
+     Pinch event that passes scale factor indicting the change in the pinch ratio
+     since the pinch started. Scale factor begins at 1 when pinch starts with
+     PinchState::PinchStart.
+     */
+    void onPinch(int source, float scaleFactor, VROEventDelegate::PinchState pinchState);
+    
+    void onRotate(int source, float rotationRadians, VROEventDelegate::RotateState rotateState);
+
+protected:
+    
+    virtual std::shared_ptr<VROInputPresenter> createPresenter(){
+        perror("Error: Derived class should create a presenter for BaseInputController to consume!");
+        return nullptr;
+    }
+    
+    /*
+     This function returns the forward offset used in drag
+     */
+    virtual VROVector3f getDragForwardOffset() = 0;
+    
+    /*
+     Status of the current controller, for example if it's Connected / Disconnected.
+     */
+    VROEventDelegate::ControllerStatus _currentControllerStatus;
+
+    /*
+     Update the hit node, performing an intersection from the camera's position
+     toward the given direction.
+     */
+    void updateHitNode(const VROCamera &camera, VROVector3f origin, VROVector3f ray);
+
+    /*
+     VRODraggedObject encapsulates all the information that needs to be tracked
+     and processed for onDrag events for a given dragged node.
+     */
+    struct VRODraggedObject{
+        std::shared_ptr<VRONode> _draggedNode;
+        VROVector3f _originalHitLocation;
+        VROVector3f _originalDraggedNodePosition;
+        VROVector3f _forwardOffset;
+        float _draggedDistanceFromController;
+    };
+    
+    /*
+     Last hit result that we are performing a drag event on.
+     */
+    std::shared_ptr<VRODraggedObject> _lastDraggedNode;
+
+    /*
+     This function is meant to be called to run the dragging logic after onMove
+     deals with other events, etc. This allows for the dragging logic to be overridden.
+     */
+    virtual void processDragging(int source);
+    
+    /*
+     Last result that was returned from the hit test.
+     */
+    std::shared_ptr<VROHitTestResult> _hitResult;
+    
+    /*
+     Last known posiiton of the controller.
+     */
+    VROVector3f _lastKnownPosition;
+    
+    /*
+     Last known position of the node that was dragged previously by this controller.
+     */
+    VROVector3f _lastDraggedNodePosition;
+    
+    /*
+     The pointer's normalized forward vector indicating where the controller
+     is pointing.
+     */
+    VROVector3f _lastKnownForward;
+
+    /*
+     Last known pinch scale value.
+     */
+    float _lastPinchScale;
+    
+    /*
+     Last known rotation value in radians.
+     */
+    float _lastRotation;
+    
+    /*
+     The view and projection matrices, updated each render cycle.
+     */
+    VROMatrix4f _view, _projection;
+
+    /*
+     Delegates registered within the manager to be notified of events
+     to an element that is outside the scene tree.
+     */
+    std::set<std::shared_ptr<VROEventDelegate>> _delegates;
+    
+    std::shared_ptr<VROScene> _scene;
+
+    /*
+     Returns the hit test result for the closest node that was hit.
+     */
+    VROHitTestResult hitTest(const VROCamera &camera, VROVector3f origin, VROVector3f ray, bool boundsOnly);
+
+    virtual void processGazeEvent(int source);
+
+private:
+    
+    /*
+     UI presenter for this input controller.
+     */
+    std::shared_ptr<VROInputPresenter> _controllerPresenter;
+    
+    /*
+     Last known position that a TouchEvent occured on.
+     */
+    VROVector3f _lastTouchedPosition;
+    
+    /*
+     The controller's quaternion that represents the rotation from (0, 0, -1) required to
+     achieve the controller's current orientation.
+     */
+    VROQuaternion _lastKnownRotation;
+
+    /*
+     Last node that we have clicked down on.
+     */
+    std::shared_ptr<VRONode> _lastClickedNode;
+
+    /*
+     Last known that was successfully hovered upon.
+     */
+    std::shared_ptr<VRONode> _lastHoveredNode;
+
+    /*
+     Returns the first node that is able to handle the event action by bubbling it up.
+     If nothing is able to handle the event, nullptr is returned.
+     */
+    std::shared_ptr<VRONode> getNodeToHandleEvent(VROEventDelegate::EventAction action,
+                                                  std::shared_ptr<VRONode> startingNode);
+
+    /*
+     Current node that we are fusing on.
+     */
+    std::shared_ptr<VRONode> _currentFusedNode;
+    
+    /*
+     Current node that we are pinching on.
+     */
+    std::shared_ptr<VRONode> _currentPinchedNode;
+    
+    /*
+     Current node that we are rotating on.
+     */
+    std::shared_ptr<VRONode>  _currentRotateNode;
+
+    /*
+     Time at which the onFuse event is triggered, in milliseconds.
+     */
+    double _fuseTriggerAtMillis = -1;
+
+    /*
+     True if we have already notified delegates about the onFuse event.
+     */
+    bool _haveNotifiedOnFuseTriggered;
+    void processOnFuseEvent(int source, std::shared_ptr<VRONode> node);
+    void notifyOnFuseEvent(int source, float timeToFuseRatio);
+};
+
+#endif