From 0cd2863df452a39b309a298b14c68322b7b73ad7 Mon Sep 17 00:00:00 2001
From: Seth Alves <seth.alves@gmail.com>
Date: Tue, 18 Apr 2017 14:42:32 -0700
Subject: [PATCH 01/14] start on routing HMD position and rotation through
 controller interface

(cherry picked from commit bca5241bae7674ff7e41c037d84bb78e5152046a)
---
 interface/resources/controllers/standard.json |  7 +-
 interface/src/Application.cpp                 |  7 ++
 interface/src/avatar/MyAvatar.cpp             | 68 ++++++++++++++++++-
 interface/src/avatar/MyAvatar.h               | 17 ++++-
 .../controllers/src/controllers/Actions.cpp   |  3 +
 .../controllers/src/controllers/Actions.h     |  3 +
 6 files changed, 101 insertions(+), 4 deletions(-)

diff --git a/interface/resources/controllers/standard.json b/interface/resources/controllers/standard.json
index 53285ea974..62eec9bc3c 100644
--- a/interface/resources/controllers/standard.json
+++ b/interface/resources/controllers/standard.json
@@ -61,6 +61,11 @@
         { "from": "Standard.RightHand", "to": "Actions.RightHand" },
 
         { "from": "Standard.LeftFoot", "to": "Actions.LeftFoot" },
-        { "from": "Standard.RightFoot", "to": "Actions.RightFoot" }
+        { "from": "Standard.RightFoot", "to": "Actions.RightFoot" },
+
+        { "from": "Standard.Hips", "to": "Actions.Hips" },
+        { "from": "Standard.Spine2", "to": "Actions.Spine2" },
+
+        { "from": "Standard.Head", "to": "Actions.Head" }
     ]
 }
diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index c6cd185034..5b014f7009 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -4395,6 +4395,13 @@ void Application::update(float deltaTime) {
     controller::Pose rightFootPose = userInputMapper->getPoseState(controller::Action::RIGHT_FOOT);
     myAvatar->setFootControllerPosesInSensorFrame(leftFootPose.transform(avatarToSensorMatrix), rightFootPose.transform(avatarToSensorMatrix));
 
+    controller::Pose hipsPose = userInputMapper->getPoseState(controller::Action::HIPS);
+    controller::Pose spine2Pose = userInputMapper->getPoseState(controller::Action::SPINE2);
+    myAvatar->setSpineControllerPosesInSensorFrame(hipsPose.transform(avatarToSensorMatrix), spine2Pose.transform(avatarToSensorMatrix));
+
+    controller::Pose headPose = userInputMapper->getPoseState(controller::Action::HEAD);
+    myAvatar->setHeadControllerPoseInSensorFrame(headPose.transform(avatarToSensorMatrix));
+
     updateThreads(deltaTime); // If running non-threaded, then give the threads some time to process...
     updateDialogs(deltaTime); // update various stats dialogs if present
 
diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp
index da09bfba7e..0906dc7f7f 100644
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@@ -642,6 +642,7 @@ void MyAvatar::updateSensorToWorldMatrix() {
     updateJointFromController(controller::Action::RIGHT_HAND, _controllerRightHandMatrixCache);
 }
 
+
 //  Update avatar head rotation with sensor data
 void MyAvatar::updateFromTrackers(float deltaTime) {
     glm::vec3 estimatedPosition, estimatedRotation;
@@ -660,8 +661,9 @@ void MyAvatar::updateFromTrackers(float deltaTime) {
         estimatedPosition.x *= -1.0f;
         _trackedHeadPosition = estimatedPosition;
 
-        const float OCULUS_LEAN_SCALE = 0.05f;
-        estimatedPosition /= OCULUS_LEAN_SCALE;
+        // wut
+        // const float OCULUS_LEAN_SCALE = 0.05f;
+        // estimatedPosition /= OCULUS_LEAN_SCALE;
     } else if (inFacetracker) {
         estimatedPosition = tracker->getHeadTranslation();
         _trackedHeadPosition = estimatedPosition;
@@ -1384,6 +1386,68 @@ controller::Pose MyAvatar::getRightFootControllerPoseInAvatarFrame() const {
     return getRightFootControllerPoseInWorldFrame().transform(invAvatarMatrix);
 }
 
+void MyAvatar::setSpineControllerPosesInSensorFrame(const controller::Pose& hips, const controller::Pose& spine2) {
+    if (controller::InputDevice::getLowVelocityFilter()) {
+        auto oldHipsPose = getHipsControllerPoseInSensorFrame();
+        auto oldSpine2Pose = getSpine2ControllerPoseInSensorFrame();
+        _hipsControllerPoseInSensorFrameCache.set(applyLowVelocityFilter(oldHipsPose, hips));
+        _spine2ControllerPoseInSensorFrameCache.set(applyLowVelocityFilter(oldSpine2Pose, spine2));
+    } else {
+        _hipsControllerPoseInSensorFrameCache.set(hips);
+        _spine2ControllerPoseInSensorFrameCache.set(spine2);
+    }
+}
+
+controller::Pose MyAvatar::getHipsControllerPoseInSensorFrame() const {
+    return _hipsControllerPoseInSensorFrameCache.get();
+}
+
+controller::Pose MyAvatar::getSpine2ControllerPoseInSensorFrame() const {
+    return _spine2ControllerPoseInSensorFrameCache.get();
+}
+
+controller::Pose MyAvatar::getHipsControllerPoseInWorldFrame() const {
+    return _hipsControllerPoseInSensorFrameCache.get().transform(getSensorToWorldMatrix());
+}
+
+controller::Pose MyAvatar::getSpine2ControllerPoseInWorldFrame() const {
+    return _spine2ControllerPoseInSensorFrameCache.get().transform(getSensorToWorldMatrix());
+}
+
+controller::Pose MyAvatar::getHipsControllerPoseInAvatarFrame() const {
+    glm::mat4 invAvatarMatrix = glm::inverse(createMatFromQuatAndPos(getOrientation(), getPosition()));
+    return getHipsControllerPoseInWorldFrame().transform(invAvatarMatrix);
+}
+
+controller::Pose MyAvatar::getSpine2ControllerPoseInAvatarFrame() const {
+    glm::mat4 invAvatarMatrix = glm::inverse(createMatFromQuatAndPos(getOrientation(), getPosition()));
+    return getSpine2ControllerPoseInWorldFrame().transform(invAvatarMatrix);
+}
+
+void MyAvatar::setHeadControllerPoseInSensorFrame(const controller::Pose& headPose) {
+    bool inHmd = qApp->isHMDMode();
+    Head* head = getHead();
+    if (inHmd) {
+        _headControllerPoseInSensorFrameCache.set(headPose);
+        _trackedHeadPosition = headPose.translation;
+        head->setDeltaPitch(headPose.rotation.x);
+        head->setDeltaYaw(headPose.rotation.y);
+        head->setDeltaRoll(headPose.rotation.z);
+    }
+}
+
+controller::Pose MyAvatar::getHeadControllerPoseInSensorFrame() const {
+    return _headControllerPoseInSensorFrameCache.get();
+}
+
+controller::Pose MyAvatar::getHeadControllerPoseInWorldFrame() const {
+    return _headControllerPoseInSensorFrameCache.get().transform(getSensorToWorldMatrix());
+}
+
+controller::Pose MyAvatar::getHeadControllerPoseInAvatarFrame() const {
+    glm::mat4 invAvatarMatrix = glm::inverse(createMatFromQuatAndPos(getOrientation(), getPosition()));
+    return getHeadControllerPoseInWorldFrame().transform(invAvatarMatrix);
+}
 
 void MyAvatar::updateMotors() {
     _characterController.clearMotors();
diff --git a/interface/src/avatar/MyAvatar.h b/interface/src/avatar/MyAvatar.h
index 0146bd11a4..01b4dc824b 100644
--- a/interface/src/avatar/MyAvatar.h
+++ b/interface/src/avatar/MyAvatar.h
@@ -453,6 +453,19 @@ public:
     controller::Pose getLeftFootControllerPoseInAvatarFrame() const;
     controller::Pose getRightFootControllerPoseInAvatarFrame() const;
 
+    void setSpineControllerPosesInSensorFrame(const controller::Pose& hips, const controller::Pose& spine2);
+    controller::Pose getHipsControllerPoseInSensorFrame() const;
+    controller::Pose getSpine2ControllerPoseInSensorFrame() const;
+    controller::Pose getHipsControllerPoseInWorldFrame() const;
+    controller::Pose getSpine2ControllerPoseInWorldFrame() const;
+    controller::Pose getHipsControllerPoseInAvatarFrame() const;
+    controller::Pose getSpine2ControllerPoseInAvatarFrame() const;
+
+    void setHeadControllerPoseInSensorFrame(const controller::Pose& headPose);
+    controller::Pose getHeadControllerPoseInSensorFrame() const;
+    controller::Pose getHeadControllerPoseInWorldFrame() const;
+    controller::Pose getHeadControllerPoseInAvatarFrame() const;
+
     bool hasDriveInput() const;
 
     Q_INVOKABLE void setCharacterControllerEnabled(bool enabled);
@@ -693,9 +706,11 @@ private:
     // These are stored in SENSOR frame
     ThreadSafeValueCache<controller::Pose> _leftHandControllerPoseInSensorFrameCache { controller::Pose() };
     ThreadSafeValueCache<controller::Pose> _rightHandControllerPoseInSensorFrameCache { controller::Pose() };
-
     ThreadSafeValueCache<controller::Pose> _leftFootControllerPoseInSensorFrameCache{ controller::Pose() };
     ThreadSafeValueCache<controller::Pose> _rightFootControllerPoseInSensorFrameCache{ controller::Pose() };
+    ThreadSafeValueCache<controller::Pose> _hipsControllerPoseInSensorFrameCache{ controller::Pose() };
+    ThreadSafeValueCache<controller::Pose> _spine2ControllerPoseInSensorFrameCache{ controller::Pose() };
+    ThreadSafeValueCache<controller::Pose> _headControllerPoseInSensorFrameCache{ controller::Pose() };
 
     bool _hmdLeanRecenterEnabled = true;
 
diff --git a/libraries/controllers/src/controllers/Actions.cpp b/libraries/controllers/src/controllers/Actions.cpp
index 300fa684d9..62a10c851f 100644
--- a/libraries/controllers/src/controllers/Actions.cpp
+++ b/libraries/controllers/src/controllers/Actions.cpp
@@ -53,6 +53,9 @@ namespace controller {
             makePosePair(Action::RIGHT_HAND, "RightHand"),
             makePosePair(Action::LEFT_FOOT, "LeftFoot"),
             makePosePair(Action::RIGHT_FOOT, "RightFoot"),
+            makePosePair(Action::HIPS, "Hips"),
+            makePosePair(Action::SPINE2, "Spine2"),
+            makePosePair(Action::HEAD, "Head"),
 
             makeButtonPair(Action::LEFT_HAND_CLICK, "LeftHandClick"),
             makeButtonPair(Action::RIGHT_HAND_CLICK, "RightHandClick"),
diff --git a/libraries/controllers/src/controllers/Actions.h b/libraries/controllers/src/controllers/Actions.h
index edf3dee07a..534f01d865 100644
--- a/libraries/controllers/src/controllers/Actions.h
+++ b/libraries/controllers/src/controllers/Actions.h
@@ -44,6 +44,9 @@ enum class Action {
     RIGHT_HAND,
     LEFT_FOOT,
     RIGHT_FOOT,
+    HIPS,
+    SPINE2,
+    HEAD,
 
     LEFT_HAND_CLICK,
     RIGHT_HAND_CLICK,

From 23592f4a53294ff2c24b44a97f87abc053a5beb3 Mon Sep 17 00:00:00 2001
From: Seth Alves <seth.alves@gmail.com>
Date: Wed, 19 Apr 2017 07:21:50 -0700
Subject: [PATCH 02/14] get rid of _trackedHeadPosition

(cherry picked from commit e909938b232e11400832ae7dd29de16968967668)
---
 interface/src/avatar/MyAvatar.cpp | 8 --------
 interface/src/avatar/MyAvatar.h   | 1 -
 2 files changed, 9 deletions(-)

diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp
index 0906dc7f7f..659077188f 100644
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@@ -642,7 +642,6 @@ void MyAvatar::updateSensorToWorldMatrix() {
     updateJointFromController(controller::Action::RIGHT_HAND, _controllerRightHandMatrixCache);
 }
 
-
 //  Update avatar head rotation with sensor data
 void MyAvatar::updateFromTrackers(float deltaTime) {
     glm::vec3 estimatedPosition, estimatedRotation;
@@ -659,14 +658,8 @@ void MyAvatar::updateFromTrackers(float deltaTime) {
     if (inHmd) {
         estimatedPosition = extractTranslation(getHMDSensorMatrix());
         estimatedPosition.x *= -1.0f;
-        _trackedHeadPosition = estimatedPosition;
-
-        // wut
-        // const float OCULUS_LEAN_SCALE = 0.05f;
-        // estimatedPosition /= OCULUS_LEAN_SCALE;
     } else if (inFacetracker) {
         estimatedPosition = tracker->getHeadTranslation();
-        _trackedHeadPosition = estimatedPosition;
         estimatedRotation = glm::degrees(safeEulerAngles(tracker->getHeadRotation()));
     }
 
@@ -1429,7 +1422,6 @@ void MyAvatar::setHeadControllerPoseInSensorFrame(const controller::Pose& headPo
     Head* head = getHead();
     if (inHmd) {
         _headControllerPoseInSensorFrameCache.set(headPose);
-        _trackedHeadPosition = headPose.translation;
         head->setDeltaPitch(headPose.rotation.x);
         head->setDeltaYaw(headPose.rotation.y);
         head->setDeltaRoll(headPose.rotation.z);
diff --git a/interface/src/avatar/MyAvatar.h b/interface/src/avatar/MyAvatar.h
index 01b4dc824b..cea5962638 100644
--- a/interface/src/avatar/MyAvatar.h
+++ b/interface/src/avatar/MyAvatar.h
@@ -353,7 +353,6 @@ public:
 
     eyeContactTarget getEyeContactTarget();
 
-    Q_INVOKABLE glm::vec3 getTrackedHeadPosition() const { return _trackedHeadPosition; }
     Q_INVOKABLE glm::vec3 getHeadPosition() const { return getHead()->getPosition(); }
     Q_INVOKABLE float getHeadFinalYaw() const { return getHead()->getFinalYaw(); }
     Q_INVOKABLE float getHeadFinalRoll() const { return getHead()->getFinalRoll(); }

From dc19f3772643eff3516e19435136c043bf9fb27c Mon Sep 17 00:00:00 2001
From: "Anthony J. Thibault" <tony@highfidelity.io>
Date: Tue, 25 Apr 2017 15:04:47 -0700
Subject: [PATCH 03/14] input/controller routing thru skeleton model and rig.

---
 interface/src/avatar/SkeletonModel.cpp | 39 +++++++++++++++++++-------
 libraries/animation/src/Rig.cpp        |  2 +-
 libraries/animation/src/Rig.h          | 12 ++++----
 libraries/shared/src/GLMHelpers.cpp    |  5 ++++
 libraries/shared/src/GLMHelpers.h      |  7 +++++
 5 files changed, 49 insertions(+), 16 deletions(-)

diff --git a/interface/src/avatar/SkeletonModel.cpp b/interface/src/avatar/SkeletonModel.cpp
index 3cf866fb6b..ccee65d3e6 100644
--- a/interface/src/avatar/SkeletonModel.cpp
+++ b/interface/src/avatar/SkeletonModel.cpp
@@ -108,8 +108,6 @@ void SkeletonModel::updateRig(float deltaTime, glm::mat4 parentTransform) {
         Rig::HeadParameters headParams;
 
         if (qApp->isHMDMode()) {
-            headParams.isInHMD = true;
-
             // get HMD position from sensor space into world space, and back into rig space
             glm::mat4 worldHMDMat = myAvatar->getSensorToWorldMatrix() * myAvatar->getHMDSensorMatrix();
             glm::mat4 rigToWorld = createMatFromQuatAndPos(getRotation(), getTranslation());
@@ -119,18 +117,39 @@ void SkeletonModel::updateRig(float deltaTime, glm::mat4 parentTransform) {
             headParams.rigHeadPosition = extractTranslation(rigHMDMat);
             headParams.rigHeadOrientation = extractRotation(rigHMDMat);
             headParams.worldHeadOrientation = extractRotation(worldHMDMat);
+            headParams.headEnabled = true;
+        } else {
+            auto avatarHeadPose = myAvatar->getHeadControllerPoseInAvatarFrame();
+            if (avatarHeadPose.isValid()) {
+                glm::mat4 rigHeadMat = Matrices::Y_180 * createMatFromQuatAndPos(avatarHeadPose.getRotation(), avatarHeadPose.getTranslation());
+                headParams.rigHeadPosition = extractTranslation(rigHeadMat);
+                headParams.rigHeadOrientation = glmExtractRotation(rigHeadMat);
+                headParams.worldHeadOrientation = myAvatar->getHeadControllerPoseInWorldFrame().getTranslation();
+                headParams.headEnabled = true;
+            } else {
+                // even though full head IK is disabled, the rig still needs the head orientation to rotate the head up and down in desktop mode.
+                headParams.rigHeadOrientation = Quaternions::Y_180 * head->getFinalOrientationInLocalFrame();
+                headParams.worldHeadOrientation = head->getFinalOrientationInWorldFrame();
+                headParams.headEnabled = false;
+            }
+        }
 
-            // TODO: if hips target sensor is valid.
-            // Copy it into headParams.hipsMatrix, and set headParams.hipsEnabled to true.
-
-            headParams.hipsEnabled = false;
+        auto avatarHipsPose = myAvatar->getHipsControllerPoseInAvatarFrame();
+        if (avatarHipsPose.isValid()) {
+            glm::mat4 rigHipsMat = Matrices::Y_180 * createMatFromQuatAndPos(avatarHipsPose.getRotation(), avatarHipsPose.getTranslation());
+            headParams.hipsMatrix = rigHipsMat;
+            headParams.hipsEnabled = true;
         } else {
             headParams.hipsEnabled = false;
-            headParams.isInHMD = false;
+        }
 
-            // We don't have a valid localHeadPosition.
-            headParams.rigHeadOrientation = Quaternions::Y_180 * head->getFinalOrientationInLocalFrame();
-            headParams.worldHeadOrientation = head->getFinalOrientationInWorldFrame();
+        auto avatarSpine2Pose = myAvatar->getSpine2ControllerPoseInAvatarFrame();
+        if (avatarSpine2Pose.isValid()) {
+            glm::mat4 rigSpine2Mat = Matrices::Y_180 * createMatFromQuatAndPos(avatarSpine2Pose.getRotation(), avatarSpine2Pose.getTranslation());
+            headParams.spine2Matrix = rigSpine2Mat;
+            headParams.spine2Enabled = true;
+        } else {
+            headParams.spine2Enabled = false;
         }
 
         headParams.neckJointIndex = geometry.neckJointIndex;
diff --git a/libraries/animation/src/Rig.cpp b/libraries/animation/src/Rig.cpp
index 116758b1ba..9ef2a554c6 100644
--- a/libraries/animation/src/Rig.cpp
+++ b/libraries/animation/src/Rig.cpp
@@ -1082,7 +1082,7 @@ void Rig::computeHeadNeckAnimVars(const AnimPose& hmdPose, glm::vec3& headPositi
 void Rig::updateNeckJoint(int index, const HeadParameters& params) {
     if (_animSkeleton && index >= 0 && index < _animSkeleton->getNumJoints()) {
         glm::quat yFlip180 = glm::angleAxis(PI, glm::vec3(0.0f, 1.0f, 0.0f));
-        if (params.isInHMD) {
+        if (params.headEnabled) {
             glm::vec3 headPos, neckPos;
             glm::quat headRot, neckRot;
 
diff --git a/libraries/animation/src/Rig.h b/libraries/animation/src/Rig.h
index 89f0d624f9..b66ca95042 100644
--- a/libraries/animation/src/Rig.h
+++ b/libraries/animation/src/Rig.h
@@ -42,12 +42,14 @@ public:
     };
 
     struct HeadParameters {
-        glm::quat worldHeadOrientation = glm::quat();  // world space (-z forward)
-        glm::quat rigHeadOrientation = glm::quat();  // rig space (-z forward)
-        glm::vec3 rigHeadPosition = glm::vec3();     // rig space
-        glm::mat4 hipsMatrix = glm::mat4();          // rig space
+        glm::mat4 hipsMatrix = glm::mat4();           // rig space
+        glm::mat4 spine2Matrix = glm::mat4();         // rig space
+        glm::quat worldHeadOrientation = glm::quat(); // world space (-z forward)
+        glm::quat rigHeadOrientation = glm::quat();   // rig space (-z forward)
+        glm::vec3 rigHeadPosition = glm::vec3();      // rig space
         bool hipsEnabled = false;
-        bool isInHMD = false;
+        bool headEnabled = false;
+        bool spine2Enabled = false;
         int neckJointIndex = -1;
         bool isTalking = false;
     };
diff --git a/libraries/shared/src/GLMHelpers.cpp b/libraries/shared/src/GLMHelpers.cpp
index ec244553f8..db42fef8bc 100644
--- a/libraries/shared/src/GLMHelpers.cpp
+++ b/libraries/shared/src/GLMHelpers.cpp
@@ -38,6 +38,11 @@ const quat Quaternions::X_180{ 0.0f, 1.0f, 0.0f, 0.0f };
 const quat Quaternions::Y_180{ 0.0f, 0.0f, 1.0f, 0.0f };
 const quat Quaternions::Z_180{ 0.0f, 0.0f, 0.0f, 1.0f };
 
+const mat4 Matrices::IDENTITY { glm::mat4() };
+const mat4 Matrices::X_180 { createMatFromQuatAndPos(Quaternions::X_180, Vectors::ZERO) };
+const mat4 Matrices::Y_180 { createMatFromQuatAndPos(Quaternions::Y_180, Vectors::ZERO) };
+const mat4 Matrices::Z_180 { createMatFromQuatAndPos(Quaternions::Z_180, Vectors::ZERO) };
+
 //  Safe version of glm::mix; based on the code in Nick Bobick's article,
 //  http://www.gamasutra.com/features/19980703/quaternions_01.htm (via Clyde,
 //  https://github.com/threerings/clyde/blob/master/src/main/java/com/threerings/math/Quaternion.java)
diff --git a/libraries/shared/src/GLMHelpers.h b/libraries/shared/src/GLMHelpers.h
index deb87930fc..fd75fa416c 100644
--- a/libraries/shared/src/GLMHelpers.h
+++ b/libraries/shared/src/GLMHelpers.h
@@ -54,6 +54,13 @@ const glm::vec3 IDENTITY_FORWARD = glm::vec3( 0.0f, 0.0f,-1.0f);
 
 glm::quat safeMix(const glm::quat& q1, const glm::quat& q2, float alpha);
 
+class Matrices {
+public:
+    static const mat4 IDENTITY;
+    static const mat4 X_180;
+    static const mat4 Y_180;
+    static const mat4 Z_180;
+};
 
 class Quaternions {
  public:

From 1931a8d1f6982b9264b650e7166905249799f709 Mon Sep 17 00:00:00 2001
From: "Anthony J. Thibault" <tony@highfidelity.io>
Date: Tue, 25 Apr 2017 15:05:52 -0700
Subject: [PATCH 04/14] viveMotionCapture.js: can now disable puck control,
 with a second controller squeeze

---
 scripts/developer/tests/viveMotionCapture.js | 130 +++++++++----------
 1 file changed, 65 insertions(+), 65 deletions(-)

diff --git a/scripts/developer/tests/viveMotionCapture.js b/scripts/developer/tests/viveMotionCapture.js
index 6cb0f92b9b..5496b475be 100644
--- a/scripts/developer/tests/viveMotionCapture.js
+++ b/scripts/developer/tests/viveMotionCapture.js
@@ -8,7 +8,7 @@ var TRACKED_OBJECT_POSES = [
     "TrackedObject12", "TrackedObject13", "TrackedObject14", "TrackedObject15"
 ];
 
-var calibrated = false;
+var triggerPressHandled = false;
 var rightTriggerPressed = false;
 var leftTriggerPressed = false;
 
@@ -43,21 +43,6 @@ var SENSOR_CONFIG_NAMES = [
     "Auto"
 ];
 
-var ANIM_VARS = [
-    "leftFootType",
-    "leftFootPosition",
-    "leftFootRotation",
-    "rightFootType",
-    "rightFootPosition",
-    "rightFootRotation",
-    "hipsType",
-    "hipsPosition",
-    "hipsRotation",
-    "spine2Type",
-    "spine2Position",
-    "spine2Rotation"
-];
-
 var sensorConfig = AUTO;
 
 var Y_180 = {x: 0, y: 1, z: 0, w: 0};
@@ -86,7 +71,7 @@ function computeDefaultToReferenceXform() {
 
         return defaultToReferenceXform;
     } else {
-        return new Xform.ident();
+        return Xform.ident();
     }
 }
 
@@ -200,71 +185,86 @@ function computeIKTargetXform(jointInfo) {
 
 function update(dt) {
     if (rightTriggerPressed && leftTriggerPressed) {
-        if (!calibrated) {
-            calibrate();
-            calibrated = true;
-
+        if (!triggerPressHandled) {
+            triggerPressHandled = true;
             if (handlerId) {
-                MyAvatar.removeAnimationStateHandler(handlerId);
-            }
+                print("AJT: UN-CALIBRATE!");
 
-            handlerId = MyAvatar.addAnimationStateHandler(function (props) {
-
-                var result = {}, xform;
-                if (rightFoot) {
-                    xform = computeIKTargetXform(rightFoot);
-                    result.rightFootType = ikTypes.RotationAndPosition;
-                    result.rightFootPosition = xform.pos;
-                    result.rightFootRotation = xform.rot;
-                } else {
-                    result.rightFootType = props.rightFootType;
-                    result.rightFootPosition = props.rightFootPosition;
-                    result.rightFootRotation = props.rightFootRotation;
+                // go back to normal, vive pucks will be ignored.
+                leftFoot = undefined;
+                rightFoot = undefined;
+                hips = undefined;
+                spine2 = undefined;
+                if (handlerId) {
+                    print("AJT: un-hooking animation state handler");
+                    MyAvatar.removeAnimationStateHandler(handlerId);
+                    handlerId = undefined;
                 }
+            } else {
+                print("AJT: CALIBRATE!");
+                calibrate();
+
+                var animVars = [];
 
                 if (leftFoot) {
-                    xform = computeIKTargetXform(leftFoot);
-                    result.leftFootType = ikTypes.RotationAndPosition;
-                    result.leftFootPosition = xform.pos;
-                    result.leftFootRotation = xform.rot;
-                } else {
-                    result.leftFootType = props.leftFootType;
-                    result.leftFootPosition = props.leftFootPosition;
-                    result.leftFootRotation = props.leftFootRotation;
+                    animVars.push("leftFootType");
+                    animVars.push("leftFootPosition");
+                    animVars.push("leftFootRotation");
+                }
+                if (rightFoot) {
+                    animVars.push("rightFootType");
+                    animVars.push("rightFootPosition");
+                    animVars.push("rightFootRotation");
                 }
-
                 if (hips) {
-                    xform = computeIKTargetXform(hips);
-                    result.hipsType = ikTypes.RotationAndPosition;
-                    result.hipsPosition = xform.pos;
-                    result.hipsRotation = xform.rot;
-                } else {
-                    result.hipsType = props.hipsType;
-                    result.hipsPosition = props.hipsPosition;
-                    result.hipsRotation = props.hipsRotation;
+                    animVars.push("hipsType");
+                    animVars.push("hipsPosition");
+                    animVars.push("hipsRotation");
                 }
-
                 if (spine2) {
-                    xform = computeIKTargetXform(spine2);
-                    result.spine2Type = ikTypes.RotationAndPosition;
-                    result.spine2Position = xform.pos;
-                    result.spine2Rotation = xform.rot;
-                } else {
-                    result.spine2Type = ikTypes.Off;
+                    animVars.push("spine2Type");
+                    animVars.push("spine2Position");
+                    animVars.push("spine2Rotation");
                 }
 
-                return result;
-            }, ANIM_VARS);
-
+                // hook up new anim state handler that maps vive pucks to ik system.
+                handlerId = MyAvatar.addAnimationStateHandler(function (props) {
+                    var result = {}, xform;
+                    if (rightFoot) {
+                        xform = computeIKTargetXform(rightFoot);
+                        result.rightFootType = ikTypes.RotationAndPosition;
+                        result.rightFootPosition = xform.pos;
+                        result.rightFootRotation = xform.rot;
+                    }
+                    if (leftFoot) {
+                        xform = computeIKTargetXform(leftFoot);
+                        result.leftFootType = ikTypes.RotationAndPosition;
+                        result.leftFootPosition = xform.pos;
+                        result.leftFootRotation = xform.rot;
+                    }
+                    if (hips) {
+                        xform = computeIKTargetXform(hips);
+                        result.hipsType = ikTypes.RotationAndPosition;
+                        result.hipsPosition = xform.pos;
+                        result.hipsRotation = xform.rot;
+                    }
+                    if (spine2) {
+                        xform = computeIKTargetXform(spine2);
+                        result.spine2Type = ikTypes.RotationAndPosition;
+                        result.spine2Position = xform.pos;
+                        result.spine2Rotation = xform.rot;
+                    }
+                    return result;
+                }, animVars);
+            }
         }
     } else {
-        calibrated = false;
+        triggerPressHandled = false;
     }
 
     var drawMarkers = false;
     if (drawMarkers) {
         var RED = {x: 1, y: 0, z: 0, w: 1};
-        var GREEN = {x: 0, y: 1, z: 0, w: 1};
         var BLUE = {x: 0, y: 0, z: 1, w: 1};
 
         if (leftFoot) {
@@ -304,4 +304,4 @@ Script.scriptEnding.connect(function () {
     Controller.disableMapping(MAPPING_NAME);
     Script.update.disconnect(update);
 });
-var TRIGGER_OFF_VALUE = 0.1;
+

From 1fc9f4c93dc7b8654653667128ea8ac383875793 Mon Sep 17 00:00:00 2001
From: "Anthony J. Thibault" <tony@highfidelity.io>
Date: Tue, 25 Apr 2017 17:22:47 -0700
Subject: [PATCH 05/14] Hips and Spine are routed thru input system properly

---
 libraries/animation/src/Rig.cpp               | 22 +++++++++++++++----
 .../src/controllers/StandardController.cpp    |  3 +++
 2 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/libraries/animation/src/Rig.cpp b/libraries/animation/src/Rig.cpp
index 9ef2a554c6..53f76d82ff 100644
--- a/libraries/animation/src/Rig.cpp
+++ b/libraries/animation/src/Rig.cpp
@@ -1028,13 +1028,18 @@ void Rig::updateFromHeadParameters(const HeadParameters& params, float dt) {
     if (params.hipsEnabled) {
         _animVars.set("hipsType", (int)IKTarget::Type::RotationAndPosition);
         _animVars.set("hipsPosition", extractTranslation(params.hipsMatrix));
-        _animVars.set("hipsRotation", glmExtractRotation(params.hipsMatrix) * Quaternions::Y_180);
+        _animVars.set("hipsRotation", glmExtractRotation(params.hipsMatrix));
     } else {
         _animVars.set("hipsType", (int)IKTarget::Type::Unknown);
     }
 
-    // by default this IK target is disabled.
-    _animVars.set("spine2Type", (int)IKTarget::Type::Unknown);
+    if (params.spine2Enabled) {
+        _animVars.set("spine2Type", (int)IKTarget::Type::RotationAndPosition);
+        _animVars.set("spine2Position", extractTranslation(params.spine2Matrix));
+        _animVars.set("spine2Rotation", glmExtractRotation(params.spine2Matrix));
+    } else {
+        _animVars.set("spine2Type", (int)IKTarget::Type::Unknown);
+    }
 }
 
 void Rig::updateFromEyeParameters(const EyeParameters& params) {
@@ -1105,7 +1110,16 @@ void Rig::updateNeckJoint(int index, const HeadParameters& params) {
 
             _animVars.set("headPosition", headPos);
             _animVars.set("headRotation", headRot);
-            _animVars.set("headType", (int)IKTarget::Type::HmdHead);
+
+            if (params.hipsEnabled) {
+                // Since there is an explicit hips ik target, switch the head to use the more generic RotationAndPosition IK chain type.
+                // this will allow the spine to bend more, ensuring that it can reach the head target position.
+                _animVars.set("headType", (int)IKTarget::Type::RotationAndPosition);
+            } else {
+                // When there is no hips IK target, use the HmdHead IK chain type.  This will make the spine very stiff,
+                // but because the IK _hipsOffset is enabled, the hips will naturally follow underneath the head.
+                _animVars.set("headType", (int)IKTarget::Type::HmdHead);
+            }
             _animVars.set("neckPosition", neckPos);
             _animVars.set("neckRotation", neckRot);
             _animVars.set("neckType", (int)IKTarget::Type::Unknown); // 'Unknown' disables the target
diff --git a/libraries/controllers/src/controllers/StandardController.cpp b/libraries/controllers/src/controllers/StandardController.cpp
index cc90ee7b49..d8c98eb63b 100644
--- a/libraries/controllers/src/controllers/StandardController.cpp
+++ b/libraries/controllers/src/controllers/StandardController.cpp
@@ -104,6 +104,9 @@ Input::NamedVector StandardController::getAvailableInputs() const {
         makePair(RIGHT_HAND, "RightHand"),
         makePair(LEFT_FOOT, "LeftFoot"),
         makePair(RIGHT_FOOT, "RightFoot"),
+        makePair(HIPS, "Hips"),
+        makePair(SPINE2, "Spine2"),
+        makePair(HEAD, "Head"),
 
         // Aliases, PlayStation style names
         makePair(LB, "L1"),

From 1b9e60944762b74981a621b5abb8573771a21aaa Mon Sep 17 00:00:00 2001
From: "Anthony J. Thibault" <tony@highfidelity.io>
Date: Tue, 25 Apr 2017 17:23:15 -0700
Subject: [PATCH 06/14] viveMotionCapture.js: updated to route pucks through
 input system

Removed use of animationStateHandler() to set IK targets.
---
 scripts/developer/tests/viveMotionCapture.js | 119 +++++++++----------
 1 file changed, 58 insertions(+), 61 deletions(-)

diff --git a/scripts/developer/tests/viveMotionCapture.js b/scripts/developer/tests/viveMotionCapture.js
index 5496b475be..4aa5cbf86f 100644
--- a/scripts/developer/tests/viveMotionCapture.js
+++ b/scripts/developer/tests/viveMotionCapture.js
@@ -11,18 +11,20 @@ var TRACKED_OBJECT_POSES = [
 var triggerPressHandled = false;
 var rightTriggerPressed = false;
 var leftTriggerPressed = false;
+var calibrationCount = 0;
 
-var MAPPING_NAME = "com.highfidelity.viveMotionCapture";
-
-var mapping = Controller.newMapping(MAPPING_NAME);
-mapping.from([Controller.Standard.RTClick]).peek().to(function (value) {
+var TRIGGER_MAPPING_NAME = "com.highfidelity.viveMotionCapture.triggers";
+var triggerMapping = Controller.newMapping(TRIGGER_MAPPING_NAME);
+triggerMapping.from([Controller.Standard.RTClick]).peek().to(function (value) {
     rightTriggerPressed = (value !== 0) ? true : false;
 });
-mapping.from([Controller.Standard.LTClick]).peek().to(function (value) {
+triggerMapping.from([Controller.Standard.LTClick]).peek().to(function (value) {
     leftTriggerPressed = (value !== 0) ? true : false;
 });
+Controller.enableMapping(TRIGGER_MAPPING_NAME);
 
-Controller.enableMapping(MAPPING_NAME);
+var CONTROLLER_MAPPING_NAME = "com.highfidelity.viveMotionCapture.controller";
+var controllerMapping;
 
 var leftFoot;
 var rightFoot;
@@ -92,7 +94,8 @@ function calibrate() {
             if (pose.valid) {
                 poses.push({
                     channel: channel,
-                    pose: pose
+                    pose: pose,
+                    lastestPose: pose
                 });
             }
         });
@@ -177,85 +180,76 @@ var ikTypes = {
 
 var handlerId;
 
-function computeIKTargetXform(jointInfo) {
-    var pose = Controller.getPoseValue(jointInfo.channel);
+function convertJointInfoToPose(jointInfo) {
+    var latestPose = jointInfo.latestPose;
     var offsetXform = jointInfo.offsetXform;
-    return Xform.mul(Y_180_XFORM, Xform.mul(new Xform(pose.rotation, pose.translation), offsetXform));
+    var xform = Xform.mul(new Xform(latestPose.rotation, latestPose.translation), offsetXform);
+    return {
+        valid: true,
+        translation: xform.pos,
+        rotation: xform.rot,
+        velocity: Vec3.sum(latestPose.velocity, Vec3.cross(latestPose.angularVelocity, Vec3.subtract(xform.pos, latestPose.translation))),
+        angularVelocity: latestPose.angularVelocity
+    };
 }
 
 function update(dt) {
     if (rightTriggerPressed && leftTriggerPressed) {
         if (!triggerPressHandled) {
             triggerPressHandled = true;
-            if (handlerId) {
-                print("AJT: UN-CALIBRATE!");
+            if (controllerMapping) {
 
                 // go back to normal, vive pucks will be ignored.
+                print("AJT: UN-CALIBRATE!");
+
                 leftFoot = undefined;
                 rightFoot = undefined;
                 hips = undefined;
                 spine2 = undefined;
-                if (handlerId) {
-                    print("AJT: un-hooking animation state handler");
-                    MyAvatar.removeAnimationStateHandler(handlerId);
-                    handlerId = undefined;
-                }
+
+                Controller.disableMapping(CONTROLLER_MAPPING_NAME + calibrationCount);
+                controllerMapping = undefined;
+
             } else {
                 print("AJT: CALIBRATE!");
                 calibrate();
+                calibrationCount++;
 
-                var animVars = [];
+                controllerMapping = Controller.newMapping(CONTROLLER_MAPPING_NAME + calibrationCount);
 
                 if (leftFoot) {
-                    animVars.push("leftFootType");
-                    animVars.push("leftFootPosition");
-                    animVars.push("leftFootRotation");
+                    controllerMapping.from(leftFoot.channel).to(function (pose) {
+                        leftFoot.latestPose = pose;
+                    });
+                    controllerMapping.from(function () {
+                        return convertJointInfoToPose(leftFoot);
+                    }).to(Controller.Standard.LeftFoot);
                 }
                 if (rightFoot) {
-                    animVars.push("rightFootType");
-                    animVars.push("rightFootPosition");
-                    animVars.push("rightFootRotation");
+                    controllerMapping.from(rightFoot.channel).to(function (pose) {
+                        rightFoot.latestPose = pose;
+                    });
+                    controllerMapping.from(function () {
+                        return convertJointInfoToPose(rightFoot);
+                    }).to(Controller.Standard.RightFoot);
                 }
                 if (hips) {
-                    animVars.push("hipsType");
-                    animVars.push("hipsPosition");
-                    animVars.push("hipsRotation");
+                    controllerMapping.from(hips.channel).to(function (pose) {
+                        hips.latestPose = pose;
+                    });
+                    controllerMapping.from(function () {
+                        return convertJointInfoToPose(hips);
+                    }).to(Controller.Standard.Hips);
                 }
                 if (spine2) {
-                    animVars.push("spine2Type");
-                    animVars.push("spine2Position");
-                    animVars.push("spine2Rotation");
+                    controllerMapping.from(spine2.channel).to(function (pose) {
+                        spine2.latestPose = pose;
+                    });
+                    controllerMapping.from(function () {
+                        return convertJointInfoToPose(spine2);
+                    }).to(Controller.Standard.Spine2);
                 }
-
-                // hook up new anim state handler that maps vive pucks to ik system.
-                handlerId = MyAvatar.addAnimationStateHandler(function (props) {
-                    var result = {}, xform;
-                    if (rightFoot) {
-                        xform = computeIKTargetXform(rightFoot);
-                        result.rightFootType = ikTypes.RotationAndPosition;
-                        result.rightFootPosition = xform.pos;
-                        result.rightFootRotation = xform.rot;
-                    }
-                    if (leftFoot) {
-                        xform = computeIKTargetXform(leftFoot);
-                        result.leftFootType = ikTypes.RotationAndPosition;
-                        result.leftFootPosition = xform.pos;
-                        result.leftFootRotation = xform.rot;
-                    }
-                    if (hips) {
-                        xform = computeIKTargetXform(hips);
-                        result.hipsType = ikTypes.RotationAndPosition;
-                        result.hipsPosition = xform.pos;
-                        result.hipsRotation = xform.rot;
-                    }
-                    if (spine2) {
-                        xform = computeIKTargetXform(spine2);
-                        result.spine2Type = ikTypes.RotationAndPosition;
-                        result.spine2Position = xform.pos;
-                        result.spine2Rotation = xform.rot;
-                    }
-                    return result;
-                }, animVars);
+                Controller.enableMapping(CONTROLLER_MAPPING_NAME + calibrationCount);
             }
         }
     } else {
@@ -301,7 +295,10 @@ function update(dt) {
 Script.update.connect(update);
 
 Script.scriptEnding.connect(function () {
-    Controller.disableMapping(MAPPING_NAME);
+    Controller.disableMapping(TRIGGER_MAPPING_NAME);
+    if (controllerMapping) {
+        Controller.disableMapping(CONTROLLER_MAPPING_NAME + calibrationCount);
+    }
     Script.update.disconnect(update);
 });
 

From ef43ff4b99565a9fb4d485b5ece1d47536a3331f Mon Sep 17 00:00:00 2001
From: "Anthony J. Thibault" <tony@highfidelity.io>
Date: Wed, 26 Apr 2017 11:55:24 -0700
Subject: [PATCH 07/14] Add default pose matrices to InputCalibrationData
 structure

---
 interface/src/Application.cpp                 |   8 +-
 interface/src/avatar/MyAvatar.cpp             | 100 ++++++++++++++++--
 interface/src/avatar/MyAvatar.h               |   8 ++
 libraries/controllers/src/controllers/Input.h |  12 ++-
 4 files changed, 116 insertions(+), 12 deletions(-)

diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index 5b014f7009..a9f882f73f 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -4347,7 +4347,13 @@ void Application::update(float deltaTime) {
     controller::InputCalibrationData calibrationData = {
         myAvatar->getSensorToWorldMatrix(),
         createMatFromQuatAndPos(myAvatar->getOrientation(), myAvatar->getPosition()),
-        myAvatar->getHMDSensorMatrix()
+        myAvatar->getHMDSensorMatrix(),
+        myAvatar->getCenterEyeCalibrationMat(),
+        myAvatar->getHeadCalibrationMat(),
+        myAvatar->getSpine2CalibrationMat(),
+        myAvatar->getHipsCalibrationMat(),
+        myAvatar->getLeftFootCalibrationMat(),
+        myAvatar->getRightFootCalibrationMat()
     };
 
     InputPluginPointer keyboardMousePlugin;
diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp
index 659077188f..9acbf14242 100644
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@@ -83,6 +83,22 @@ const float MyAvatar::ZOOM_MIN = 0.5f;
 const float MyAvatar::ZOOM_MAX = 25.0f;
 const float MyAvatar::ZOOM_DEFAULT = 1.5f;
 
+// 2 meter tall dude (in avatar coordinates)
+static const glm::vec3 DEFAULT_AVATAR_MIDDLE_EYE_POS { 0.0f, 0.9f, 0.0f };
+static const glm::quat DEFAULT_AVATAR_MIDDLE_EYE_ROT { Quaternions::Y_180 };
+static const glm::vec3 DEFAULT_AVATAR_HEAD_POS { 0.0f, 0.8f, 0.0f };
+static const glm::quat DEFAULT_AVATAR_HEAD_ROT { Quaternions::Y_180 };
+static const glm::vec3 DEFAULT_AVATAR_NECK_POS { 0.0f, 0.7f, 0.0f };
+static const glm::quat DEFAULT_AVATAR_NECK_ROT { Quaternions::Y_180 };
+static const glm::vec3 DEFAULT_AVATAR_SPINE2_POS { 0.0f, 0.5f, 0.0f };
+static const glm::quat DEFAULT_AVATAR_SPINE2_ROT { Quaternions::Y_180};
+static const glm::vec3 DEFAULT_AVATAR_HIPS_POS { 0.0f, 0.05f, 0.0f };
+static const glm::quat DEFAULT_AVATAR_HIPS_ROT { Quaternions::Y_180 };
+static const glm::vec3 DEFAULT_AVATAR_LEFTFOOT_POS { -0.1f, -0.9f, 0.0f };  // AJT: TODO: WRONG FIX ME
+static const glm::quat DEFAULT_AVATAR_LEFTFOOT_ROT { Quaternions::IDENTITY }; // AJT: TODO: WRONG FIX ME
+static const glm::vec3 DEFAULT_AVATAR_RIGHTFOOT_POS { 0.1f, -0.9f, 0.0f }; // AJT: TODO: WRONG FIX ME
+static const glm::quat DEFAULT_AVATAR_RIGHTFOOT_ROT { Quaternions::IDENTITY }; // AJT: TODO: WRONG FIX ME
+
 MyAvatar::MyAvatar(RigPointer rig) :
     Avatar(rig),
     _wasPushing(false),
@@ -2283,22 +2299,17 @@ glm::mat4 MyAvatar::deriveBodyFromHMDSensor() const {
     const glm::quat hmdOrientation = getHMDSensorOrientation();
     const glm::quat hmdOrientationYawOnly = cancelOutRollAndPitch(hmdOrientation);
 
-    // 2 meter tall dude (in rig coordinates)
-    const glm::vec3 DEFAULT_RIG_MIDDLE_EYE_POS(0.0f, 0.9f, 0.0f);
-    const glm::vec3 DEFAULT_RIG_NECK_POS(0.0f, 0.70f, 0.0f);
-    const glm::vec3 DEFAULT_RIG_HIPS_POS(0.0f, 0.05f, 0.0f);
-
     int rightEyeIndex = _rig->indexOfJoint("RightEye");
     int leftEyeIndex = _rig->indexOfJoint("LeftEye");
     int neckIndex = _rig->indexOfJoint("Neck");
     int hipsIndex = _rig->indexOfJoint("Hips");
 
-    glm::vec3 rigMiddleEyePos = DEFAULT_RIG_MIDDLE_EYE_POS;
+    glm::vec3 rigMiddleEyePos = DEFAULT_AVATAR_MIDDLE_EYE_POS;
     if (leftEyeIndex >= 0 && rightEyeIndex >= 0) {
         rigMiddleEyePos = (_rig->getAbsoluteDefaultPose(leftEyeIndex).trans() + _rig->getAbsoluteDefaultPose(rightEyeIndex).trans()) / 2.0f;
     }
-    glm::vec3 rigNeckPos = neckIndex != -1 ? _rig->getAbsoluteDefaultPose(neckIndex).trans() : DEFAULT_RIG_NECK_POS;
-    glm::vec3 rigHipsPos = hipsIndex != -1 ? _rig->getAbsoluteDefaultPose(hipsIndex).trans() : DEFAULT_RIG_HIPS_POS;
+    glm::vec3 rigNeckPos = neckIndex != -1 ? _rig->getAbsoluteDefaultPose(neckIndex).trans() : DEFAULT_AVATAR_NECK_POS;
+    glm::vec3 rigHipsPos = hipsIndex != -1 ? _rig->getAbsoluteDefaultPose(hipsIndex).trans() : DEFAULT_AVATAR_HIPS_POS;
 
     glm::vec3 localEyes = (rigMiddleEyePos - rigHipsPos);
     glm::vec3 localNeck = (rigNeckPos - rigHipsPos);
@@ -2662,6 +2673,79 @@ glm::vec3 MyAvatar::getAbsoluteJointTranslationInObjectFrame(int index) const {
     }
 }
 
+glm::mat4 MyAvatar::getCenterEyeCalibrationMat() const {
+    // TODO: as an optimization cache this computation, then invalidate the cache when the avatar model is changed.
+    int rightEyeIndex = _rig->indexOfJoint("RightEye");
+    int leftEyeIndex = _rig->indexOfJoint("LeftEye");
+    if (rightEyeIndex >= 0 && leftEyeIndex >= 0) {
+        auto centerEyePos = (getAbsoluteDefaultJointTranslationInObjectFrame(rightEyeIndex) + getAbsoluteDefaultJointTranslationInObjectFrame(leftEyeIndex)) * 0.5f;
+        auto centerEyeRot = Quaternions::Y_180;
+        return createMatFromQuatAndPos(centerEyeRot, centerEyePos);
+    } else {
+        return createMatFromQuatAndPos(DEFAULT_AVATAR_MIDDLE_EYE_POS, DEFAULT_AVATAR_MIDDLE_EYE_POS);
+    }
+}
+
+glm::mat4 MyAvatar::getHeadCalibrationMat() const {
+    // TODO: as an optimization cache this computation, then invalidate the cache when the avatar model is changed.
+    int headIndex = _rig->indexOfJoint("Head");
+    if (headIndex >= 0) {
+        auto headPos = getAbsoluteDefaultJointTranslationInObjectFrame(headIndex);
+        auto headRot = getAbsoluteDefaultJointRotationInObjectFrame(headIndex);
+        return createMatFromQuatAndPos(headRot, headPos);
+    } else {
+        return createMatFromQuatAndPos(DEFAULT_AVATAR_HEAD_POS, DEFAULT_AVATAR_HEAD_POS);
+    }
+}
+
+glm::mat4 MyAvatar::getSpine2CalibrationMat() const {
+    // TODO: as an optimization cache this computation, then invalidate the cache when the avatar model is changed.
+    int spine2Index = _rig->indexOfJoint("Spine2");
+    if (spine2Index >= 0) {
+        auto spine2Pos = getAbsoluteDefaultJointTranslationInObjectFrame(spine2Index);
+        auto spine2Rot = getAbsoluteDefaultJointRotationInObjectFrame(spine2Index);
+        return createMatFromQuatAndPos(spine2Rot, spine2Pos);
+    } else {
+        return createMatFromQuatAndPos(DEFAULT_AVATAR_SPINE2_POS, DEFAULT_AVATAR_SPINE2_POS);
+    }
+}
+
+glm::mat4 MyAvatar::getHipsCalibrationMat() const {
+    // TODO: as an optimization cache this computation, then invalidate the cache when the avatar model is changed.
+    int hipsIndex = _rig->indexOfJoint("Hips");
+    if (hipsIndex >= 0) {
+        auto hipsPos = getAbsoluteDefaultJointTranslationInObjectFrame(hipsIndex);
+        auto hipsRot = getAbsoluteDefaultJointRotationInObjectFrame(hipsIndex);
+        return createMatFromQuatAndPos(hipsRot, hipsPos);
+    } else {
+        return createMatFromQuatAndPos(DEFAULT_AVATAR_HIPS_POS, DEFAULT_AVATAR_HIPS_POS);
+    }
+}
+
+glm::mat4 MyAvatar::getLeftFootCalibrationMat() const {
+    // TODO: as an optimization cache this computation, then invalidate the cache when the avatar model is changed.
+    int leftFootIndex = _rig->indexOfJoint("LeftFoot");
+    if (leftFootIndex >= 0) {
+        auto leftFootPos = getAbsoluteDefaultJointTranslationInObjectFrame(leftFootIndex);
+        auto leftFootRot = getAbsoluteDefaultJointRotationInObjectFrame(leftFootIndex);
+        return createMatFromQuatAndPos(leftFootRot, leftFootPos);
+    } else {
+        return createMatFromQuatAndPos(DEFAULT_AVATAR_LEFTFOOT_POS, DEFAULT_AVATAR_LEFTFOOT_POS);
+    }
+}
+
+glm::mat4 MyAvatar::getRightFootCalibrationMat() const {
+    // TODO: as an optimization cache this computation, then invalidate the cache when the avatar model is changed.
+    int rightFootIndex = _rig->indexOfJoint("RightFoot");
+    if (rightFootIndex >= 0) {
+        auto rightFootPos = getAbsoluteDefaultJointTranslationInObjectFrame(rightFootIndex);
+        auto rightFootRot = getAbsoluteDefaultJointRotationInObjectFrame(rightFootIndex);
+        return createMatFromQuatAndPos(rightFootRot, rightFootPos);
+    } else {
+        return createMatFromQuatAndPos(DEFAULT_AVATAR_RIGHTFOOT_POS, DEFAULT_AVATAR_RIGHTFOOT_POS);
+    }
+}
+
 bool MyAvatar::pinJoint(int index, const glm::vec3& position, const glm::quat& orientation) {
     auto hipsIndex = getJointIndex("Hips");
     if (index != hipsIndex) {
diff --git a/interface/src/avatar/MyAvatar.h b/interface/src/avatar/MyAvatar.h
index cea5962638..01b6496e12 100644
--- a/interface/src/avatar/MyAvatar.h
+++ b/interface/src/avatar/MyAvatar.h
@@ -473,6 +473,14 @@ public:
     virtual glm::quat getAbsoluteJointRotationInObjectFrame(int index) const override;
     virtual glm::vec3 getAbsoluteJointTranslationInObjectFrame(int index) const override;
 
+    // all calibration matrices are in absolute avatar space.
+    glm::mat4 getCenterEyeCalibrationMat() const;
+    glm::mat4 getHeadCalibrationMat() const;
+    glm::mat4 getSpine2CalibrationMat() const;
+    glm::mat4 getHipsCalibrationMat() const;
+    glm::mat4 getLeftFootCalibrationMat() const;
+    glm::mat4 getRightFootCalibrationMat() const;
+
     void addHoldAction(AvatarActionHold* holdAction);  // thread-safe
     void removeHoldAction(AvatarActionHold* holdAction);  // thread-safe
     void updateHoldActions(const AnimPose& prePhysicsPose, const AnimPose& postUpdatePose);
diff --git a/libraries/controllers/src/controllers/Input.h b/libraries/controllers/src/controllers/Input.h
index 9c7f09d526..65c78cd6ea 100644
--- a/libraries/controllers/src/controllers/Input.h
+++ b/libraries/controllers/src/controllers/Input.h
@@ -16,9 +16,15 @@
 namespace controller {
 
 struct InputCalibrationData {
-    glm::mat4 sensorToWorldMat;
-    glm::mat4 avatarMat;
-    glm::mat4 hmdSensorMat;
+    glm::mat4 sensorToWorldMat;    // sensor to world
+    glm::mat4 avatarMat;           // avatar to world
+    glm::mat4 hmdSensorMat;        // hmd pos and orientation in sensor space
+    glm::mat4 defaultCenterEyeMat; // default pose for the center of the eyes in avatar space.
+    glm::mat4 defaultHeadMat;      // default pose for head joint in avatar space
+    glm::mat4 defaultSpine2;       // default pose for spine2 joint in avatar space
+    glm::mat4 defaultHips;         // default pose for hips joint in avatar space
+    glm::mat4 defaultLeftFoot;     // default pose for leftFoot joint in avatar space
+    glm::mat4 defaultRightFoot;    // default pose for leftFoot joint in avatar space
 };
 
 enum class ChannelType {

From 764f6c69eaa4dbed7a06f0104b93864bb28c9367 Mon Sep 17 00:00:00 2001
From: "Anthony J. Thibault" <tony@highfidelity.io>
Date: Thu, 27 Apr 2017 17:39:25 -0700
Subject: [PATCH 08/14] Head input action will override the HMD for IK.

---
 interface/src/avatar/MyAvatar.cpp            | 34 +++++-----
 interface/src/avatar/MyAvatar.h              |  2 +-
 interface/src/avatar/SkeletonModel.cpp       | 37 +++++-----
 libraries/animation/src/Rig.cpp              | 71 ++++----------------
 libraries/animation/src/Rig.h                | 13 ++--
 scripts/developer/tests/viveMotionCapture.js | 44 ++++++++++++
 6 files changed, 97 insertions(+), 104 deletions(-)

diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp
index 9acbf14242..70d650e7a5 100644
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@@ -83,21 +83,21 @@ const float MyAvatar::ZOOM_MIN = 0.5f;
 const float MyAvatar::ZOOM_MAX = 25.0f;
 const float MyAvatar::ZOOM_DEFAULT = 1.5f;
 
-// 2 meter tall dude (in avatar coordinates)
-static const glm::vec3 DEFAULT_AVATAR_MIDDLE_EYE_POS { 0.0f, 0.9f, 0.0f };
+// default values, used when avatar is missing joints... (avatar space)
 static const glm::quat DEFAULT_AVATAR_MIDDLE_EYE_ROT { Quaternions::Y_180 };
-static const glm::vec3 DEFAULT_AVATAR_HEAD_POS { 0.0f, 0.8f, 0.0f };
+static const glm::vec3 DEFAULT_AVATAR_MIDDLE_EYE_POS { 0.0f, 0.6f, 0.0f };
 static const glm::quat DEFAULT_AVATAR_HEAD_ROT { Quaternions::Y_180 };
-static const glm::vec3 DEFAULT_AVATAR_NECK_POS { 0.0f, 0.7f, 0.0f };
+static const glm::vec3 DEFAULT_AVATAR_HEAD_POS { 0.0f, 0.53f, 0.0f };
+static const glm::vec3 DEFAULT_AVATAR_NECK_POS { 0.0f, 0.445f, 0.025f };
 static const glm::quat DEFAULT_AVATAR_NECK_ROT { Quaternions::Y_180 };
-static const glm::vec3 DEFAULT_AVATAR_SPINE2_POS { 0.0f, 0.5f, 0.0f };
+static const glm::vec3 DEFAULT_AVATAR_SPINE2_POS { 0.0f, 0.32f, 0.02f };
 static const glm::quat DEFAULT_AVATAR_SPINE2_ROT { Quaternions::Y_180};
-static const glm::vec3 DEFAULT_AVATAR_HIPS_POS { 0.0f, 0.05f, 0.0f };
+static const glm::vec3 DEFAULT_AVATAR_HIPS_POS { 0.0f, 0.0f, 0.0f };
 static const glm::quat DEFAULT_AVATAR_HIPS_ROT { Quaternions::Y_180 };
-static const glm::vec3 DEFAULT_AVATAR_LEFTFOOT_POS { -0.1f, -0.9f, 0.0f };  // AJT: TODO: WRONG FIX ME
-static const glm::quat DEFAULT_AVATAR_LEFTFOOT_ROT { Quaternions::IDENTITY }; // AJT: TODO: WRONG FIX ME
-static const glm::vec3 DEFAULT_AVATAR_RIGHTFOOT_POS { 0.1f, -0.9f, 0.0f }; // AJT: TODO: WRONG FIX ME
-static const glm::quat DEFAULT_AVATAR_RIGHTFOOT_ROT { Quaternions::IDENTITY }; // AJT: TODO: WRONG FIX ME
+static const glm::vec3 DEFAULT_AVATAR_LEFTFOOT_POS { -0.08f, -0.96f, 0.029f};
+static const glm::quat DEFAULT_AVATAR_LEFTFOOT_ROT { -0.40167322754859924f, 0.9154590368270874f, -0.005437685176730156f, -0.023744143545627594f };
+static const glm::vec3 DEFAULT_AVATAR_RIGHTFOOT_POS { 0.08f, -0.96f, 0.029f };
+static const glm::quat DEFAULT_AVATAR_RIGHTFOOT_ROT { -0.4016716778278351f, 0.9154615998268127f, 0.0053307069465518f, 0.023696165531873703f };
 
 MyAvatar::MyAvatar(RigPointer rig) :
     Avatar(rig),
@@ -1433,14 +1433,12 @@ controller::Pose MyAvatar::getSpine2ControllerPoseInAvatarFrame() const {
     return getSpine2ControllerPoseInWorldFrame().transform(invAvatarMatrix);
 }
 
-void MyAvatar::setHeadControllerPoseInSensorFrame(const controller::Pose& headPose) {
-    bool inHmd = qApp->isHMDMode();
-    Head* head = getHead();
-    if (inHmd) {
-        _headControllerPoseInSensorFrameCache.set(headPose);
-        head->setDeltaPitch(headPose.rotation.x);
-        head->setDeltaYaw(headPose.rotation.y);
-        head->setDeltaRoll(headPose.rotation.z);
+void MyAvatar::setHeadControllerPoseInSensorFrame(const controller::Pose& head) {
+    if (controller::InputDevice::getLowVelocityFilter()) {
+        auto oldHeadPose = getHeadControllerPoseInSensorFrame();
+        _headControllerPoseInSensorFrameCache.set(applyLowVelocityFilter(oldHeadPose, head));
+    } else {
+        _headControllerPoseInSensorFrameCache.set(head);
     }
 }
 
diff --git a/interface/src/avatar/MyAvatar.h b/interface/src/avatar/MyAvatar.h
index 01b6496e12..dc249e0411 100644
--- a/interface/src/avatar/MyAvatar.h
+++ b/interface/src/avatar/MyAvatar.h
@@ -460,7 +460,7 @@ public:
     controller::Pose getHipsControllerPoseInAvatarFrame() const;
     controller::Pose getSpine2ControllerPoseInAvatarFrame() const;
 
-    void setHeadControllerPoseInSensorFrame(const controller::Pose& headPose);
+    void setHeadControllerPoseInSensorFrame(const controller::Pose& head);
     controller::Pose getHeadControllerPoseInSensorFrame() const;
     controller::Pose getHeadControllerPoseInWorldFrame() const;
     controller::Pose getHeadControllerPoseInAvatarFrame() const;
diff --git a/interface/src/avatar/SkeletonModel.cpp b/interface/src/avatar/SkeletonModel.cpp
index ccee65d3e6..9fad9e09fb 100644
--- a/interface/src/avatar/SkeletonModel.cpp
+++ b/interface/src/avatar/SkeletonModel.cpp
@@ -107,29 +107,27 @@ void SkeletonModel::updateRig(float deltaTime, glm::mat4 parentTransform) {
 
         Rig::HeadParameters headParams;
 
-        if (qApp->isHMDMode()) {
-            // get HMD position from sensor space into world space, and back into rig space
-            glm::mat4 worldHMDMat = myAvatar->getSensorToWorldMatrix() * myAvatar->getHMDSensorMatrix();
-            glm::mat4 rigToWorld = createMatFromQuatAndPos(getRotation(), getTranslation());
-            glm::mat4 worldToRig = glm::inverse(rigToWorld);
-            glm::mat4 rigHMDMat = worldToRig * worldHMDMat;
-
-            headParams.rigHeadPosition = extractTranslation(rigHMDMat);
-            headParams.rigHeadOrientation = extractRotation(rigHMDMat);
-            headParams.worldHeadOrientation = extractRotation(worldHMDMat);
+        // input action is the highest priority source for head orientation.
+        auto avatarHeadPose = myAvatar->getHeadControllerPoseInAvatarFrame();
+        if (avatarHeadPose.isValid()) {
+            glm::mat4 rigHeadMat = Matrices::Y_180 * createMatFromQuatAndPos(avatarHeadPose.getRotation(), avatarHeadPose.getTranslation());
+            headParams.rigHeadPosition = extractTranslation(rigHeadMat);
+            headParams.rigHeadOrientation = glmExtractRotation(rigHeadMat);
             headParams.headEnabled = true;
         } else {
-            auto avatarHeadPose = myAvatar->getHeadControllerPoseInAvatarFrame();
-            if (avatarHeadPose.isValid()) {
-                glm::mat4 rigHeadMat = Matrices::Y_180 * createMatFromQuatAndPos(avatarHeadPose.getRotation(), avatarHeadPose.getTranslation());
-                headParams.rigHeadPosition = extractTranslation(rigHeadMat);
-                headParams.rigHeadOrientation = glmExtractRotation(rigHeadMat);
-                headParams.worldHeadOrientation = myAvatar->getHeadControllerPoseInWorldFrame().getTranslation();
+            if (qApp->isHMDMode()) {
+                // get HMD position from sensor space into world space, and back into rig space
+                glm::mat4 worldHMDMat = myAvatar->getSensorToWorldMatrix() * myAvatar->getHMDSensorMatrix();
+                glm::mat4 rigToWorld = createMatFromQuatAndPos(getRotation(), getTranslation());
+                glm::mat4 worldToRig = glm::inverse(rigToWorld);
+                glm::mat4 rigHMDMat = worldToRig * worldHMDMat;
+                _rig->computeHeadFromHMD(AnimPose(rigHMDMat), headParams.rigHeadPosition, headParams.rigHeadOrientation);
                 headParams.headEnabled = true;
             } else {
                 // even though full head IK is disabled, the rig still needs the head orientation to rotate the head up and down in desktop mode.
-                headParams.rigHeadOrientation = Quaternions::Y_180 * head->getFinalOrientationInLocalFrame();
-                headParams.worldHeadOrientation = head->getFinalOrientationInWorldFrame();
+                // preMult 180 is necessary to convert from avatar to rig coordinates.
+                // postMult 180 is necessary to convert head from -z forward to z forward.
+                headParams.rigHeadOrientation = Quaternions::Y_180 * head->getFinalOrientationInLocalFrame() * Quaternions::Y_180;
                 headParams.headEnabled = false;
             }
         }
@@ -152,7 +150,6 @@ void SkeletonModel::updateRig(float deltaTime, glm::mat4 parentTransform) {
             headParams.spine2Enabled = false;
         }
 
-        headParams.neckJointIndex = geometry.neckJointIndex;
         headParams.isTalking = head->getTimeWithoutTalking() <= 1.5f;
 
         _rig->updateFromHeadParameters(headParams, deltaTime);
@@ -212,7 +209,6 @@ void SkeletonModel::updateRig(float deltaTime, glm::mat4 parentTransform) {
         Model::updateRig(deltaTime, parentTransform);
 
         Rig::EyeParameters eyeParams;
-        eyeParams.worldHeadOrientation = headParams.worldHeadOrientation;
         eyeParams.eyeLookAt = lookAt;
         eyeParams.eyeSaccade = head->getSaccade();
         eyeParams.modelRotation = getRotation();
@@ -244,7 +240,6 @@ void SkeletonModel::updateRig(float deltaTime, glm::mat4 parentTransform) {
         head->setBaseRoll(glm::degrees(-eulers.z));
 
         Rig::EyeParameters eyeParams;
-        eyeParams.worldHeadOrientation = head->getFinalOrientationInWorldFrame();
         eyeParams.eyeLookAt = lookAt;
         eyeParams.eyeSaccade = glm::vec3(0.0f);
         eyeParams.modelRotation = getRotation();
diff --git a/libraries/animation/src/Rig.cpp b/libraries/animation/src/Rig.cpp
index 53f76d82ff..700761b248 100644
--- a/libraries/animation/src/Rig.cpp
+++ b/libraries/animation/src/Rig.cpp
@@ -46,7 +46,6 @@ static bool isEqual(const glm::quat& p, const glm::quat& q) {
 const glm::vec3 DEFAULT_RIGHT_EYE_POS(-0.3f, 0.9f, 0.0f);
 const glm::vec3 DEFAULT_LEFT_EYE_POS(0.3f, 0.9f, 0.0f);
 const glm::vec3 DEFAULT_HEAD_POS(0.0f, 0.75f, 0.0f);
-const glm::vec3 DEFAULT_NECK_POS(0.0f, 0.70f, 0.0f);
 
 void Rig::overrideAnimation(const QString& url, float fps, bool loop, float firstFrame, float lastFrame) {
 
@@ -1020,7 +1019,7 @@ glm::quat Rig::getJointDefaultRotationInParentFrame(int jointIndex) {
 }
 
 void Rig::updateFromHeadParameters(const HeadParameters& params, float dt) {
-    updateNeckJoint(params.neckJointIndex, params);
+    updateHeadAnimVars(params);
 
     _animVars.set("isTalking", params.isTalking);
     _animVars.set("notIsTalking", !params.isTalking);
@@ -1043,74 +1042,40 @@ void Rig::updateFromHeadParameters(const HeadParameters& params, float dt) {
 }
 
 void Rig::updateFromEyeParameters(const EyeParameters& params) {
-    updateEyeJoint(params.leftEyeJointIndex, params.modelTranslation, params.modelRotation,
-                   params.worldHeadOrientation, params.eyeLookAt, params.eyeSaccade);
-    updateEyeJoint(params.rightEyeJointIndex, params.modelTranslation, params.modelRotation,
-                   params.worldHeadOrientation, params.eyeLookAt, params.eyeSaccade);
+    updateEyeJoint(params.leftEyeJointIndex, params.modelTranslation, params.modelRotation, params.eyeLookAt, params.eyeSaccade);
+    updateEyeJoint(params.rightEyeJointIndex, params.modelTranslation, params.modelRotation, params.eyeLookAt, params.eyeSaccade);
 }
 
-void Rig::computeHeadNeckAnimVars(const AnimPose& hmdPose, glm::vec3& headPositionOut, glm::quat& headOrientationOut,
-                                  glm::vec3& neckPositionOut, glm::quat& neckOrientationOut) const {
+void Rig::computeHeadFromHMD(const AnimPose& hmdPose, glm::vec3& headPositionOut, glm::quat& headOrientationOut) const {
 
     // the input hmd values are in avatar/rig space
     const glm::vec3& hmdPosition = hmdPose.trans();
-    const glm::quat& hmdOrientation = hmdPose.rot();
+
+    // the HMD looks down the negative z axis, but the head bone looks down the z axis, so apply a 180 degree rotation.
+    const glm::quat& hmdOrientation = hmdPose.rot() * Quaternions::Y_180;
 
     // TODO: cache jointIndices
     int rightEyeIndex = indexOfJoint("RightEye");
     int leftEyeIndex = indexOfJoint("LeftEye");
     int headIndex = indexOfJoint("Head");
-    int neckIndex = indexOfJoint("Neck");
 
     glm::vec3 absRightEyePos = rightEyeIndex != -1 ? getAbsoluteDefaultPose(rightEyeIndex).trans() : DEFAULT_RIGHT_EYE_POS;
     glm::vec3 absLeftEyePos = leftEyeIndex != -1 ? getAbsoluteDefaultPose(leftEyeIndex).trans() : DEFAULT_LEFT_EYE_POS;
     glm::vec3 absHeadPos = headIndex != -1 ? getAbsoluteDefaultPose(headIndex).trans() : DEFAULT_HEAD_POS;
-    glm::vec3 absNeckPos = neckIndex != -1 ? getAbsoluteDefaultPose(neckIndex).trans() : DEFAULT_NECK_POS;
 
     glm::vec3 absCenterEyePos = (absRightEyePos + absLeftEyePos) / 2.0f;
     glm::vec3 eyeOffset = absCenterEyePos - absHeadPos;
-    glm::vec3 headOffset = absHeadPos - absNeckPos;
 
-    // apply simplistic head/neck model
-
-    // head
     headPositionOut = hmdPosition - hmdOrientation * eyeOffset;
+
     headOrientationOut = hmdOrientation;
-
-    // neck
-    neckPositionOut = hmdPosition - hmdOrientation * (headOffset + eyeOffset);
-
-    // slerp between default orientation and hmdOrientation
-    neckOrientationOut = safeMix(hmdOrientation, _animSkeleton->getRelativeDefaultPose(neckIndex).rot(), 0.5f);
 }
 
-void Rig::updateNeckJoint(int index, const HeadParameters& params) {
-    if (_animSkeleton && index >= 0 && index < _animSkeleton->getNumJoints()) {
-        glm::quat yFlip180 = glm::angleAxis(PI, glm::vec3(0.0f, 1.0f, 0.0f));
+void Rig::updateHeadAnimVars(const HeadParameters& params) {
+    if (_animSkeleton) {
         if (params.headEnabled) {
-            glm::vec3 headPos, neckPos;
-            glm::quat headRot, neckRot;
-
-            AnimPose hmdPose(glm::vec3(1.0f), params.rigHeadOrientation * yFlip180, params.rigHeadPosition);
-            computeHeadNeckAnimVars(hmdPose, headPos, headRot, neckPos, neckRot);
-
-            // debug rendering
-#ifdef DEBUG_RENDERING
-            const glm::vec4 red(1.0f, 0.0f, 0.0f, 1.0f);
-            const glm::vec4 green(0.0f, 1.0f, 0.0f, 1.0f);
-
-            // transform from bone into avatar space
-            AnimPose headPose(glm::vec3(1), headRot, headPos);
-            DebugDraw::getInstance().addMyAvatarMarker("headTarget", headPose.rot, headPose.trans, red);
-
-            // transform from bone into avatar space
-            AnimPose neckPose(glm::vec3(1), neckRot, neckPos);
-            DebugDraw::getInstance().addMyAvatarMarker("neckTarget", neckPose.rot, neckPose.trans, green);
-#endif
-
-            _animVars.set("headPosition", headPos);
-            _animVars.set("headRotation", headRot);
-
+            _animVars.set("headPosition", params.rigHeadPosition);
+            _animVars.set("headRotation", params.rigHeadOrientation);
             if (params.hipsEnabled) {
                 // Since there is an explicit hips ik target, switch the head to use the more generic RotationAndPosition IK chain type.
                 // this will allow the spine to bend more, ensuring that it can reach the head target position.
@@ -1120,23 +1085,15 @@ void Rig::updateNeckJoint(int index, const HeadParameters& params) {
                 // but because the IK _hipsOffset is enabled, the hips will naturally follow underneath the head.
                 _animVars.set("headType", (int)IKTarget::Type::HmdHead);
             }
-            _animVars.set("neckPosition", neckPos);
-            _animVars.set("neckRotation", neckRot);
-            _animVars.set("neckType", (int)IKTarget::Type::Unknown); // 'Unknown' disables the target
-
         } else {
             _animVars.unset("headPosition");
-            _animVars.set("headRotation", params.rigHeadOrientation * yFlip180);
-            _animVars.set("headAndNeckType", (int)IKTarget::Type::RotationOnly);
+            _animVars.set("headRotation", params.rigHeadOrientation);
             _animVars.set("headType", (int)IKTarget::Type::RotationOnly);
-            _animVars.unset("neckPosition");
-            _animVars.unset("neckRotation");
-            _animVars.set("neckType", (int)IKTarget::Type::RotationOnly);
         }
     }
 }
 
-void Rig::updateEyeJoint(int index, const glm::vec3& modelTranslation, const glm::quat& modelRotation, const glm::quat& worldHeadOrientation, const glm::vec3& lookAtSpot, const glm::vec3& saccade) {
+void Rig::updateEyeJoint(int index, const glm::vec3& modelTranslation, const glm::quat& modelRotation, const glm::vec3& lookAtSpot, const glm::vec3& saccade) {
 
     // TODO: does not properly handle avatar scale.
 
diff --git a/libraries/animation/src/Rig.h b/libraries/animation/src/Rig.h
index b66ca95042..2d024628f5 100644
--- a/libraries/animation/src/Rig.h
+++ b/libraries/animation/src/Rig.h
@@ -44,18 +44,15 @@ public:
     struct HeadParameters {
         glm::mat4 hipsMatrix = glm::mat4();           // rig space
         glm::mat4 spine2Matrix = glm::mat4();         // rig space
-        glm::quat worldHeadOrientation = glm::quat(); // world space (-z forward)
         glm::quat rigHeadOrientation = glm::quat();   // rig space (-z forward)
         glm::vec3 rigHeadPosition = glm::vec3();      // rig space
         bool hipsEnabled = false;
         bool headEnabled = false;
         bool spine2Enabled = false;
-        int neckJointIndex = -1;
         bool isTalking = false;
     };
 
     struct EyeParameters {
-        glm::quat worldHeadOrientation = glm::quat();
         glm::vec3 eyeLookAt = glm::vec3();  // world space
         glm::vec3 eyeSaccade = glm::vec3(); // world space
         glm::vec3 modelTranslation = glm::vec3();
@@ -232,6 +229,9 @@ public:
 
     void setEnableDebugDrawIKTargets(bool enableDebugDrawIKTargets) { _enableDebugDrawIKTargets = enableDebugDrawIKTargets; }
 
+    // input assumed to be in rig space
+    void computeHeadFromHMD(const AnimPose& hmdPose, glm::vec3& headPositionOut, glm::quat& headOrientationOut) const;
+
 signals:
     void onLoadComplete();
 
@@ -241,10 +241,9 @@ protected:
     void applyOverridePoses();
     void buildAbsoluteRigPoses(const AnimPoseVec& relativePoses, AnimPoseVec& absolutePosesOut);
 
-    void updateNeckJoint(int index, const HeadParameters& params);
-    void computeHeadNeckAnimVars(const AnimPose& hmdPose, glm::vec3& headPositionOut, glm::quat& headOrientationOut,
-                                 glm::vec3& neckPositionOut, glm::quat& neckOrientationOut) const;
-    void updateEyeJoint(int index, const glm::vec3& modelTranslation, const glm::quat& modelRotation, const glm::quat& worldHeadOrientation, const glm::vec3& lookAt, const glm::vec3& saccade);
+    void updateHeadAnimVars(const HeadParameters& params);
+
+    void updateEyeJoint(int index, const glm::vec3& modelTranslation, const glm::quat& modelRotation, const glm::vec3& lookAt, const glm::vec3& saccade);
     void calcAnimAlpha(float speed, const std::vector<float>& referenceSpeeds, float* alphaOut) const;
 
     AnimPose _modelOffset;  // model to rig space
diff --git a/scripts/developer/tests/viveMotionCapture.js b/scripts/developer/tests/viveMotionCapture.js
index 4aa5cbf86f..e7fb8566dc 100644
--- a/scripts/developer/tests/viveMotionCapture.js
+++ b/scripts/developer/tests/viveMotionCapture.js
@@ -26,6 +26,7 @@ Controller.enableMapping(TRIGGER_MAPPING_NAME);
 var CONTROLLER_MAPPING_NAME = "com.highfidelity.viveMotionCapture.controller";
 var controllerMapping;
 
+var head;
 var leftFoot;
 var rightFoot;
 var hips;
@@ -77,8 +78,29 @@ function computeDefaultToReferenceXform() {
     }
 }
 
+function computeHeadOffsetXform() {
+    var leftEyeIndex = MyAvatar.getJointIndex("LeftEye");
+    var rightEyeIndex = MyAvatar.getJointIndex("RightEye");
+    var headIndex = MyAvatar.getJointIndex("Head");
+    if (leftEyeIndex > 0 && rightEyeIndex > 0 && headIndex > 0) {
+        var defaultHeadXform = new Xform(MyAvatar.getAbsoluteDefaultJointRotationInObjectFrame(headIndex),
+                                         MyAvatar.getAbsoluteDefaultJointTranslationInObjectFrame(headIndex));
+        var defaultLeftEyeXform = new Xform(MyAvatar.getAbsoluteDefaultJointRotationInObjectFrame(leftEyeIndex),
+                                            MyAvatar.getAbsoluteDefaultJointTranslationInObjectFrame(leftEyeIndex));
+        var defaultRightEyeXform = new Xform(MyAvatar.getAbsoluteDefaultJointRotationInObjectFrame(rightEyeIndex),
+                                             MyAvatar.getAbsoluteDefaultJointTranslationInObjectFrame(rightEyeIndex));
+        var defaultCenterEyePos = Vec3.multiply(0.5, Vec3.sum(defaultLeftEyeXform.pos, defaultRightEyeXform.pos));
+        var defaultCenterEyeXform = new Xform(defaultLeftEyeXform.rot, defaultCenterEyePos);
+
+        return Xform.mul(defaultCenterEyeXform.inv(), defaultHeadXform);
+    } else {
+        return undefined;
+    }
+}
+
 function calibrate() {
 
+    head = undefined;
     leftFoot = undefined;
     rightFoot = undefined;
     hips = undefined;
@@ -86,6 +108,13 @@ function calibrate() {
 
     var defaultToReferenceXform = computeDefaultToReferenceXform();
 
+    var headOffsetXform = computeHeadOffsetXform();
+    print("AJT: computed headOffsetXform " + (headOffsetXform ? JSON.stringify(headOffsetXform) : "undefined"));
+
+    if (headOffsetXform) {
+        head = { offsetXform: headOffsetXform };
+    }
+
     var poses = [];
     if (Controller.Hardware.Vive) {
         TRACKED_OBJECT_POSES.forEach(function (key) {
@@ -202,6 +231,7 @@ function update(dt) {
                 // go back to normal, vive pucks will be ignored.
                 print("AJT: UN-CALIBRATE!");
 
+                head = undefined;
                 leftFoot = undefined;
                 rightFoot = undefined;
                 hips = undefined;
@@ -217,6 +247,20 @@ function update(dt) {
 
                 controllerMapping = Controller.newMapping(CONTROLLER_MAPPING_NAME + calibrationCount);
 
+                if (head) {
+                    controllerMapping.from(function () {
+                        var worldToAvatarXform = (new Xform(MyAvatar.orientation, MyAvatar.position)).inv();
+                        head.latestPose = {
+                            valid: true,
+                            translation: worldToAvatarXform.xformPoint(HMD.position),
+                            rotation: Quat.multiply(worldToAvatarXform.rot, Quat.multiply(HMD.orientation, Y_180)), // postMult 180 rot flips head direction
+                            velocity: {x: 0, y: 0, z: 0},  // TODO: currently this is unused anyway...
+                            angularVelocity: {x: 0, y: 0, z: 0}
+                        };
+                        return convertJointInfoToPose(head);
+                    }).to(Controller.Standard.Head);
+                }
+
                 if (leftFoot) {
                     controllerMapping.from(leftFoot.channel).to(function (pose) {
                         leftFoot.latestPose = pose;

From f3cc1c2d86d7bcb5e568ac3dca7bedd6544ab906 Mon Sep 17 00:00:00 2001
From: "Anthony J. Thibault" <tony@highfidelity.io>
Date: Fri, 28 Apr 2017 11:30:06 -0700
Subject: [PATCH 09/14] Added hipsContorllerTest.js for QA Testing

---
 scripts/developer/tests/hipsControllerTest.js | 105 ++++++++++++++++++
 1 file changed, 105 insertions(+)
 create mode 100644 scripts/developer/tests/hipsControllerTest.js

diff --git a/scripts/developer/tests/hipsControllerTest.js b/scripts/developer/tests/hipsControllerTest.js
new file mode 100644
index 0000000000..5c6a4811e5
--- /dev/null
+++ b/scripts/developer/tests/hipsControllerTest.js
@@ -0,0 +1,105 @@
+//
+//  hipsControllerTest.js
+//
+//  Created by Anthony Thibault on 4/24/17
+//  Copyright 2017 High Fidelity, Inc.
+//
+//  Test procedural manipulation of the Avatar hips via the controller system.
+//  Pull the left and right triggers on your hand controllers, you hips should begin to gyrate in an amusing mannor.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+
+/* global Xform */
+Script.include("/~/system/libraries/Xform.js");
+
+var triggerPressHandled = false;
+var rightTriggerPressed = false;
+var leftTriggerPressed = false;
+
+var MAPPING_NAME = "com.highfidelity.hipsIkTest";
+
+var mapping = Controller.newMapping(MAPPING_NAME);
+mapping.from([Controller.Standard.RTClick]).peek().to(function (value) {
+    rightTriggerPressed = (value !== 0) ? true : false;
+});
+mapping.from([Controller.Standard.LTClick]).peek().to(function (value) {
+    leftTriggerPressed = (value !== 0) ? true : false;
+});
+
+Controller.enableMapping(MAPPING_NAME);
+
+var CONTROLLER_MAPPING_NAME = "com.highfidelity.hipsIkTest.controller";
+var controllerMapping;
+
+var ZERO = {x: 0, y: 0, z: 0};
+var X_AXIS = {x: 1, y: 0, z: 0};
+var Y_AXIS = {x: 0, y: 1, z: 0};
+var Y_180 = {x: 0, y: 1, z: 0, w: 0};
+var Y_180_XFORM = new Xform(Y_180, {x: 0, y: 0, z: 0});
+
+var hips = undefined;
+
+function computeCurrentXform(jointIndex) {
+    var currentXform = new Xform(MyAvatar.getAbsoluteJointRotationInObjectFrame(jointIndex),
+                                 MyAvatar.getAbsoluteJointTranslationInObjectFrame(jointIndex));
+    return currentXform;
+}
+
+function calibrate() {
+    hips = computeCurrentXform(MyAvatar.getJointIndex("Hips"));
+}
+
+function circleOffset(radius, theta, normal) {
+    var pos = {x: radius * Math.cos(theta), y: radius * Math.sin(theta), z: 0};
+    var lookAtRot = Quat.lookAt(normal, ZERO, X_AXIS);
+    return Vec3.multiplyQbyV(lookAtRot, pos);
+}
+
+var calibrationCount = 0;
+
+function update(dt) {
+    if (rightTriggerPressed && leftTriggerPressed) {
+        if (!triggerPressHandled) {
+            triggerPressHandled = true;
+            if (controllerMapping) {
+                hips = undefined;
+                Controller.disableMapping(CONTROLLER_MAPPING_NAME + calibrationCount);
+                controllerMapping = undefined;
+            } else {
+                calibrate();
+                calibrationCount++;
+                controllerMapping = Controller.newMapping(CONTROLLER_MAPPING_NAME + calibrationCount);
+
+                var n = Y_AXIS;
+                var t = 0;
+                if (hips) {
+                    controllerMapping.from(function () {
+                        t += (1 / 60) * 4;
+                        return {
+                            valid: true,
+                            translation: Vec3.sum(hips.pos, circleOffset(0.1, t, n)),
+                            rotation: hips.rot,
+                            velocity: ZERO,
+                            angularVelocity: ZERO
+                        };
+                    }).to(Controller.Standard.Hips);
+                }
+                Controller.enableMapping(CONTROLLER_MAPPING_NAME + calibrationCount);
+            }
+        }
+    } else {
+        triggerPressHandled = false;
+    }
+}
+
+Script.update.connect(update);
+
+Script.scriptEnding.connect(function () {
+    Controller.disableMapping(MAPPING_NAME);
+    if (controllerMapping) {
+        Controller.disableMapping(CONTROLLER_MAPPING_NAME + calibrationCount);
+    }
+    Script.update.disconnect(update);
+});
+

From 58de67ba119268b45280b4a0fad83b91183e2d9b Mon Sep 17 00:00:00 2001
From: "Anthony J. Thibault" <tony@highfidelity.io>
Date: Fri, 28 Apr 2017 14:12:00 -0700
Subject: [PATCH 10/14] Fix tests/controllers/src/main.cpp clang/gcc warnings

---
 tests/controllers/src/main.cpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/tests/controllers/src/main.cpp b/tests/controllers/src/main.cpp
index 2c8f361fac..e697bd501f 100644
--- a/tests/controllers/src/main.cpp
+++ b/tests/controllers/src/main.cpp
@@ -114,6 +114,12 @@ int main(int argc, char** argv) {
         last = now;
 
         InputCalibrationData calibrationData = {
+            glm::mat4(),
+            glm::mat4(),
+            glm::mat4(),
+            glm::mat4(),
+            glm::mat4(),
+            glm::mat4(),
             glm::mat4(),
             glm::mat4(),
             glm::mat4()
@@ -130,6 +136,12 @@ int main(int argc, char** argv) {
 
     {
         InputCalibrationData calibrationData = {
+            glm::mat4(),
+            glm::mat4(),
+            glm::mat4(),
+            glm::mat4(),
+            glm::mat4(),
+            glm::mat4(),
             glm::mat4(),
             glm::mat4(),
             glm::mat4()

From 5e1bc0d908d63f81e852891c2efc27b1d6596fd7 Mon Sep 17 00:00:00 2001
From: Brad Davis <bdavis@saintandreas.org>
Date: Fri, 28 Apr 2017 14:28:03 -0700
Subject: [PATCH 11/14] Remove faceshift

---
 cmake/externals/faceshift/CMakeLists.txt      |  47 ---
 cmake/macros/TargetFaceshift.cmake            |  14 -
 cmake/modules/FindFaceshift.cmake             |  26 --
 interface/CMakeLists.txt                      |   5 -
 .../resources/icons/tablet-icons/goto-msg.svg |  36 +-
 interface/src/Application.cpp                 |  25 +-
 interface/src/Menu.cpp                        |  12 +-
 interface/src/Menu.h                          |   1 -
 interface/src/avatar/Head.cpp                 |  17 +-
 interface/src/avatar/MyAvatar.cpp             |   4 +-
 interface/src/devices/DeviceTracker.cpp       |   3 -
 interface/src/devices/DeviceTracker.h         |   3 -
 interface/src/devices/EyeTracker.cpp          |   9 +-
 interface/src/devices/EyeTracker.h            |   3 -
 interface/src/devices/FaceTracker.cpp         |  40 ++-
 interface/src/devices/FaceTracker.h           |  38 ++-
 interface/src/devices/Faceshift.cpp           | 310 ------------------
 interface/src/devices/Faceshift.h             | 155 ---------
 interface/src/devices/Logging.cpp             |  11 +
 interface/src/devices/Logging.h               |  16 +
 interface/src/devices/MotionTracker.cpp       |   5 -
 interface/src/devices/MotionTracker.h         |  18 +-
 interface/src/ui/PreferencesDialog.cpp        |   8 -
 libraries/avatars/src/AvatarData.cpp          |   6 +-
 libraries/avatars/src/AvatarData.h            |   4 +-
 libraries/ui/src/ui/Menu.cpp                  |  12 +
 libraries/ui/src/ui/Menu.h                    |  10 +
 27 files changed, 150 insertions(+), 688 deletions(-)
 delete mode 100644 cmake/externals/faceshift/CMakeLists.txt
 delete mode 100644 cmake/macros/TargetFaceshift.cmake
 delete mode 100644 cmake/modules/FindFaceshift.cmake
 delete mode 100644 interface/src/devices/Faceshift.cpp
 delete mode 100644 interface/src/devices/Faceshift.h
 create mode 100644 interface/src/devices/Logging.cpp
 create mode 100644 interface/src/devices/Logging.h

diff --git a/cmake/externals/faceshift/CMakeLists.txt b/cmake/externals/faceshift/CMakeLists.txt
deleted file mode 100644
index c4f2055435..0000000000
--- a/cmake/externals/faceshift/CMakeLists.txt
+++ /dev/null
@@ -1,47 +0,0 @@
-set(EXTERNAL_NAME faceshift)
-
-include(ExternalProject)
-ExternalProject_Add(
-  ${EXTERNAL_NAME}
-  URL https://hifi-public.s3.amazonaws.com/dependencies/faceshift.zip
-  CMAKE_ARGS ${ANDROID_CMAKE_ARGS} -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
-  BINARY_DIR ${EXTERNAL_PROJECT_PREFIX}/build
-  LOG_DOWNLOAD 1
-  LOG_CONFIGURE 1
-  LOG_BUILD 1
-)
-
-#  URL_MD5 1bdcb8a0b8d5b1ede434cc41efade41d
-
-# Hide this external target (for ide users)
-set_target_properties(${EXTERNAL_NAME} PROPERTIES FOLDER "hidden/externals")
-
-ExternalProject_Get_Property(${EXTERNAL_NAME} INSTALL_DIR)
-
-string(TOUPPER ${EXTERNAL_NAME} EXTERNAL_NAME_UPPER)
-set(${EXTERNAL_NAME_UPPER}_INCLUDE_DIRS ${INSTALL_DIR}/include CACHE FILEPATH "Path to Faceshift include directory")
-
-set(LIBRARY_DEBUG_PATH "lib/Debug")
-set(LIBRARY_RELEASE_PATH "lib/Release")
-
-if (WIN32)
-  set(LIBRARY_PREFIX "")
-  set(LIBRARY_EXT "lib")
-  # use selected configuration in release path when building on Windows
-  set(LIBRARY_RELEASE_PATH "$<$<CONFIG:RelWithDebInfo>:build/RelWithDebInfo>")
-  set(LIBRARY_RELEASE_PATH "${LIBRARY_RELEASE_PATH}$<$<CONFIG:MinSizeRel>:build/MinSizeRel>")
-  set(LIBRARY_RELEASE_PATH "${LIBRARY_RELEASE_PATH}$<$<OR:$<CONFIG:Release>,$<CONFIG:Debug>>:lib/Release>")
-elseif (APPLE)
-  set(LIBRARY_EXT "a")
-  set(LIBRARY_PREFIX "lib")
-
-  if (CMAKE_GENERATOR STREQUAL "Unix Makefiles")
-    set(LIBRARY_DEBUG_PATH "build")
-    set(LIBRARY_RELEASE_PATH "build")
-  endif ()
-endif()
-
-set(${EXTERNAL_NAME_UPPER}_LIBRARY_DEBUG
-  ${INSTALL_DIR}/${LIBRARY_DEBUG_PATH}/${LIBRARY_PREFIX}faceshift.${LIBRARY_EXT} CACHE FILEPATH "Faceshift libraries")
-set(${EXTERNAL_NAME_UPPER}_LIBRARY_RELEASE
-${INSTALL_DIR}/${LIBRARY_RELEASE_PATH}/${LIBRARY_PREFIX}faceshift.${LIBRARY_EXT} CACHE FILEPATH "Faceshift libraries")
diff --git a/cmake/macros/TargetFaceshift.cmake b/cmake/macros/TargetFaceshift.cmake
deleted file mode 100644
index 99f65d942a..0000000000
--- a/cmake/macros/TargetFaceshift.cmake
+++ /dev/null
@@ -1,14 +0,0 @@
-# 
-#  Copyright 2015 High Fidelity, Inc.
-#  Created by Bradley Austin Davis on 2015/10/10
-#
-#  Distributed under the Apache License, Version 2.0.
-#  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
-# 
-macro(TARGET_FACESHIFT)
-    add_dependency_external_projects(faceshift)
-    find_package(Faceshift REQUIRED)
-    target_include_directories(${TARGET_NAME} PRIVATE ${FACESHIFT_INCLUDE_DIRS})
-    target_link_libraries(${TARGET_NAME} ${FACESHIFT_LIBRARIES})
-    add_definitions(-DHAVE_FACESHIFT)
-endmacro()
\ No newline at end of file
diff --git a/cmake/modules/FindFaceshift.cmake b/cmake/modules/FindFaceshift.cmake
deleted file mode 100644
index bd77951273..0000000000
--- a/cmake/modules/FindFaceshift.cmake
+++ /dev/null
@@ -1,26 +0,0 @@
-# 
-#  FindFaceshift.cmake
-# 
-#  Try to find the Faceshift networking library
-#
-#  You must provide a FACESHIFT_ROOT_DIR which contains lib and include directories
-#
-#  Once done this will define
-#
-#  FACESHIFT_FOUND - system found Faceshift
-#  FACESHIFT_INCLUDE_DIRS - the Faceshift include directory
-#  FACESHIFT_LIBRARIES - Link this to use Faceshift
-#
-#  Created on 8/30/2013 by Andrzej Kapolka
-#  Copyright 2013 High Fidelity, Inc.
-#
-#  Distributed under the Apache License, Version 2.0.
-#  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
-# 
-
-include(SelectLibraryConfigurations)
-select_library_configurations(FACESHIFT)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Faceshift DEFAULT_MSG FACESHIFT_INCLUDE_DIRS FACESHIFT_LIBRARIES)
-mark_as_advanced(FACESHIFT_INCLUDE_DIRS FACESHIFT_LIBRARIES FACESHIFT_SEARCH_DIRS)
\ No newline at end of file
diff --git a/interface/CMakeLists.txt b/interface/CMakeLists.txt
index 4d58d70075..e3d01826b3 100644
--- a/interface/CMakeLists.txt
+++ b/interface/CMakeLists.txt
@@ -202,7 +202,6 @@ link_hifi_libraries(
 # include the binary directory of render-utils for shader includes
 target_include_directories(${TARGET_NAME} PRIVATE "${CMAKE_BINARY_DIR}/libraries/render-utils")
 
-#fixme find a way to express faceshift as a plugin
 target_bullet()
 target_opengl()
 
@@ -210,10 +209,6 @@ if (NOT ANDROID)
   target_glew()
 endif ()
 
-if (WIN32 OR APPLE)
-  target_faceshift()
-endif()
-
 # perform standard include and linking for found externals
 foreach(EXTERNAL ${OPTIONAL_EXTERNALS})
 
diff --git a/interface/resources/icons/tablet-icons/goto-msg.svg b/interface/resources/icons/tablet-icons/goto-msg.svg
index 9b576ab1bf..ef905b6066 100644
--- a/interface/resources/icons/tablet-icons/goto-msg.svg
+++ b/interface/resources/icons/tablet-icons/goto-msg.svg
@@ -1,18 +1,18 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 19.2.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 50 50" style="enable-background:new 0 0 50 50;" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#FFFFFF;}
-	.st1{fill:#EF3B4E;}
-</style>
-<g id="Layer_2">
-</g>
-<g id="Layer_1_1_">
-	<path class="st0" d="M47.2,41.3l-9.1-9.1c-0.8-0.8-1.9-1.1-3-1l-2.4-2.4c1.8-2.6,2.8-5.7,2.8-9c0-8.9-7.2-16.1-16.1-16.1
-		S3.3,11,3.3,19.8c0,8.9,7.2,16.1,16.1,16.1c4.1,0,7.8-1.5,10.6-4l2.2,2.2c-0.2,1.1,0.1,2.2,1,3l9.1,9.1c1.4,1.4,3.6,1.4,4.9,0
-		C48.5,44.9,48.5,42.7,47.2,41.3z M19.4,32.2c-6.8,0-12.3-5.5-12.3-12.3S12.6,7.6,19.4,7.6s12.3,5.5,12.3,12.3
-		C31.8,26.6,26.2,32.2,19.4,32.2z"/>
-</g>
-<circle class="st1" cx="43.5" cy="6.5" r="5.9"/>
-</svg>
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 19.2.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 50 50" style="enable-background:new 0 0 50 50;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#FFFFFF;}
+	.st1{fill:#EF3B4E;}
+</style>
+<g id="Layer_2">
+</g>
+<g id="Layer_1_1_">
+	<path class="st0" d="M47.2,41.3l-9.1-9.1c-0.8-0.8-1.9-1.1-3-1l-2.4-2.4c1.8-2.6,2.8-5.7,2.8-9c0-8.9-7.2-16.1-16.1-16.1
+		S3.3,11,3.3,19.8c0,8.9,7.2,16.1,16.1,16.1c4.1,0,7.8-1.5,10.6-4l2.2,2.2c-0.2,1.1,0.1,2.2,1,3l9.1,9.1c1.4,1.4,3.6,1.4,4.9,0
+		C48.5,44.9,48.5,42.7,47.2,41.3z M19.4,32.2c-6.8,0-12.3-5.5-12.3-12.3S12.6,7.6,19.4,7.6s12.3,5.5,12.3,12.3
+		C31.8,26.6,26.2,32.2,19.4,32.2z"/>
+</g>
+<circle class="st1" cx="43.5" cy="6.5" r="5.9"/>
+</svg>
diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index 39a4b8ee7c..306fa99852 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -137,7 +137,6 @@
 #include "CrashHandler.h"
 #include "devices/DdeFaceTracker.h"
 #include "devices/EyeTracker.h"
-#include "devices/Faceshift.h"
 #include "devices/Leapmotion.h"
 #include "DiscoverabilityManager.h"
 #include "GLCanvas.h"
@@ -480,7 +479,6 @@ bool setupEssentials(int& argc, char** argv) {
     DependencyManager::set<ModelCache>();
     DependencyManager::set<ScriptCache>();
     DependencyManager::set<SoundCache>();
-    DependencyManager::set<Faceshift>();
     DependencyManager::set<DdeFaceTracker>();
     DependencyManager::set<EyeTracker>();
     DependencyManager::set<AudioClient>();
@@ -1209,10 +1207,6 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
 
     this->installEventFilter(this);
 
-    // initialize our face trackers after loading the menu settings
-    auto faceshiftTracker = DependencyManager::get<Faceshift>();
-    faceshiftTracker->init();
-    connect(faceshiftTracker.data(), &FaceTracker::muteToggled, this, &Application::faceTrackerMuteToggled);
 #ifdef HAVE_DDE
     auto ddeTracker = DependencyManager::get<DdeFaceTracker>();
     ddeTracker->init();
@@ -3624,20 +3618,13 @@ ivec2 Application::getMouse() const {
 }
 
 FaceTracker* Application::getActiveFaceTracker() {
-    auto faceshift = DependencyManager::get<Faceshift>();
     auto dde = DependencyManager::get<DdeFaceTracker>();
 
-    return (dde->isActive() ? static_cast<FaceTracker*>(dde.data()) :
-            (faceshift->isActive() ? static_cast<FaceTracker*>(faceshift.data()) : nullptr));
+    return dde->isActive() ? static_cast<FaceTracker*>(dde.data()) : nullptr;
 }
 
 FaceTracker* Application::getSelectedFaceTracker() {
     FaceTracker* faceTracker = nullptr;
-#ifdef HAVE_FACESHIFT
-    if (Menu::getInstance()->isOptionChecked(MenuOption::Faceshift)) {
-        faceTracker = DependencyManager::get<Faceshift>().data();
-    }
-#endif
 #ifdef HAVE_DDE
     if (Menu::getInstance()->isOptionChecked(MenuOption::UseCamera)) {
         faceTracker = DependencyManager::get<DdeFaceTracker>().data();
@@ -3647,15 +3634,8 @@ FaceTracker* Application::getSelectedFaceTracker() {
 }
 
 void Application::setActiveFaceTracker() const {
-#if defined(HAVE_FACESHIFT) || defined(HAVE_DDE)
-    bool isMuted = Menu::getInstance()->isOptionChecked(MenuOption::MuteFaceTracking);
-#endif
-#ifdef HAVE_FACESHIFT
-    auto faceshiftTracker = DependencyManager::get<Faceshift>();
-    faceshiftTracker->setIsMuted(isMuted);
-    faceshiftTracker->setEnabled(Menu::getInstance()->isOptionChecked(MenuOption::Faceshift) && !isMuted);
-#endif
 #ifdef HAVE_DDE
+    bool isMuted = Menu::getInstance()->isOptionChecked(MenuOption::MuteFaceTracking);
     bool isUsingDDE = Menu::getInstance()->isOptionChecked(MenuOption::UseCamera);
     Menu::getInstance()->getActionForOption(MenuOption::BinaryEyelidControl)->setVisible(isUsingDDE);
     Menu::getInstance()->getActionForOption(MenuOption::CoupleEyelids)->setVisible(isUsingDDE);
@@ -5131,7 +5111,6 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
 }
 
 void Application::resetSensors(bool andReload) {
-    DependencyManager::get<Faceshift>()->reset();
     DependencyManager::get<DdeFaceTracker>()->reset();
     DependencyManager::get<EyeTracker>()->reset();
     getActiveDisplayPlugin()->resetSensors();
diff --git a/interface/src/Menu.cpp b/interface/src/Menu.cpp
index 8754951317..fcd539ca7d 100644
--- a/interface/src/Menu.cpp
+++ b/interface/src/Menu.cpp
@@ -34,7 +34,6 @@
 #include "avatar/AvatarManager.h"
 #include "AvatarBookmarks.h"
 #include "devices/DdeFaceTracker.h"
-#include "devices/Faceshift.h"
 #include "MainWindow.h"
 #include "render/DrawStatus.h"
 #include "scripting/MenuScriptingInterface.h"
@@ -451,12 +450,6 @@ Menu::Menu() {
             qApp, SLOT(setActiveFaceTracker()));
         faceTrackerGroup->addAction(noFaceTracker);
 
-#ifdef HAVE_FACESHIFT
-        QAction* faceshiftFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::Faceshift,
-            0, false,
-            qApp, SLOT(setActiveFaceTracker()));
-        faceTrackerGroup->addAction(faceshiftFaceTracker);
-#endif
 #ifdef HAVE_DDE
         QAction* ddeFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::UseCamera,
             0, true,
@@ -477,11 +470,10 @@ Menu::Menu() {
     QAction* ddeCalibrate = addActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::CalibrateCamera, 0,
         DependencyManager::get<DdeFaceTracker>().data(), SLOT(calibrate()));
     ddeCalibrate->setVisible(true);  // DDE face tracking is on by default
-#endif
-#if defined(HAVE_FACESHIFT) || defined(HAVE_DDE)
     faceTrackingMenu->addSeparator();
     addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::MuteFaceTracking,
-        Qt::CTRL | Qt::SHIFT | Qt::Key_F, true);  // DDE face tracking is on by default
+        [](bool mute) { FaceTracker::setIsMuted(mute); },
+        Qt::CTRL | Qt::SHIFT | Qt::Key_F, FaceTracker::isMuted());
     addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::AutoMuteAudio, 0, false);
 #endif
 
diff --git a/interface/src/Menu.h b/interface/src/Menu.h
index eeffcac7ca..479a78e7c2 100644
--- a/interface/src/Menu.h
+++ b/interface/src/Menu.h
@@ -105,7 +105,6 @@ namespace MenuOption {
     const QString ExpandPaintGLTiming = "Expand /paintGL";
     const QString ExpandPhysicsSimulationTiming = "Expand /physics";
     const QString ExpandUpdateTiming = "Expand /update";
-    const QString Faceshift = "Faceshift";
     const QString FirstPerson = "First Person";
     const QString FivePointCalibration = "5 Point Calibration";
     const QString FixGaze = "Fix Gaze (no saccade)";
diff --git a/interface/src/avatar/Head.cpp b/interface/src/avatar/Head.cpp
index 282acf6bf5..f2eeba9d60 100644
--- a/interface/src/avatar/Head.cpp
+++ b/interface/src/avatar/Head.cpp
@@ -23,7 +23,6 @@
 #include "Util.h"
 #include "devices/DdeFaceTracker.h"
 #include "devices/EyeTracker.h"
-#include "devices/Faceshift.h"
 #include <Rig.h>
 
 using namespace std;
@@ -209,14 +208,14 @@ void Head::simulate(float deltaTime, bool isMine) {
 
         // use data to update fake Faceshift blendshape coefficients
         calculateMouthShapes(deltaTime);
-        DependencyManager::get<Faceshift>()->updateFakeCoefficients(_leftEyeBlink,
-                                                                    _rightEyeBlink,
-                                                                    _browAudioLift,
-                                                                    _audioJawOpen,
-                                                                    _mouth2,
-                                                                    _mouth3,
-                                                                    _mouth4,
-                                                                    _blendshapeCoefficients);
+        FaceTracker::updateFakeCoefficients(_leftEyeBlink,
+                                            _rightEyeBlink,
+                                            _browAudioLift,
+                                            _audioJawOpen,
+                                            _mouth2,
+                                            _mouth3,
+                                            _mouth4,
+                                            _blendshapeCoefficients);
 
         applyEyelidOffset(getOrientation());
 
diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp
index 7bc961c654..b8c7656839 100644
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@@ -41,9 +41,9 @@
 #include <recording/Clip.h>
 #include <recording/Frame.h>
 #include <RecordingScriptingInterface.h>
+#include <devices/FaceTracker.h>
 
 #include "Application.h"
-#include "devices/Faceshift.h"
 #include "AvatarManager.h"
 #include "AvatarActionHold.h"
 #include "Menu.h"
@@ -650,7 +650,7 @@ void MyAvatar::updateFromTrackers(float deltaTime) {
     }
 
     FaceTracker* tracker = qApp->getActiveFaceTracker();
-    bool inFacetracker = tracker && !tracker->isMuted();
+    bool inFacetracker = tracker && !FaceTracker::isMuted();
 
     if (inHmd) {
         estimatedPosition = extractTranslation(getHMDSensorMatrix());
diff --git a/interface/src/devices/DeviceTracker.cpp b/interface/src/devices/DeviceTracker.cpp
index 2cd4950064..93aeb607bc 100644
--- a/interface/src/devices/DeviceTracker.cpp
+++ b/interface/src/devices/DeviceTracker.cpp
@@ -1,7 +1,4 @@
 //
-//  DeviceTracker.cpp
-//  interface/src/devices
-//
 //  Created by Sam Cake on 6/20/14.
 //  Copyright 2014 High Fidelity, Inc.
 //
diff --git a/interface/src/devices/DeviceTracker.h b/interface/src/devices/DeviceTracker.h
index 543e9bab1a..8a7f509cb3 100644
--- a/interface/src/devices/DeviceTracker.h
+++ b/interface/src/devices/DeviceTracker.h
@@ -1,7 +1,4 @@
 //
-//  DeviceTracker.h
-//  interface/src/devices
-//
 //  Created by Sam Cake on 6/20/14.
 //  Copyright 2014 High Fidelity, Inc.
 //
diff --git a/interface/src/devices/EyeTracker.cpp b/interface/src/devices/EyeTracker.cpp
index 367aa52aae..8733461dbb 100644
--- a/interface/src/devices/EyeTracker.cpp
+++ b/interface/src/devices/EyeTracker.cpp
@@ -1,7 +1,4 @@
 //
-//  EyeTracker.cpp
-//  interface/src/devices
-//
 //  Created by David Rowe on 27 Jul 2015.
 //  Copyright 2015 High Fidelity, Inc.
 //
@@ -17,8 +14,8 @@
 
 #include <SharedUtil.h>
 
-#include "InterfaceLogging.h"
-#include "OctreeConstants.h"
+#include "Logging.h"
+#include <OctreeConstants.h>
 
 #ifdef HAVE_IVIEWHMD
 char* HIGH_FIDELITY_EYE_TRACKER_CALIBRATION = "HighFidelityEyeTrackerCalibration";
@@ -115,7 +112,7 @@ void EyeTracker::processData(smi_CallbackDataStruct* data) {
 
 void EyeTracker::init() {
     if (_isInitialized) {
-        qCWarning(interfaceapp) << "Eye Tracker: Already initialized";
+        qCWarning(trackers) << "Eye Tracker: Already initialized";
         return;
     }
 }
diff --git a/interface/src/devices/EyeTracker.h b/interface/src/devices/EyeTracker.h
index 0e760d9454..9cf35d0f2a 100644
--- a/interface/src/devices/EyeTracker.h
+++ b/interface/src/devices/EyeTracker.h
@@ -1,7 +1,4 @@
 //
-//  EyeTracker.h
-//  interface/src/devices
-//
 //  Created by David Rowe on 27 Jul 2015.
 //  Copyright 2015 High Fidelity, Inc.
 //
diff --git a/interface/src/devices/FaceTracker.cpp b/interface/src/devices/FaceTracker.cpp
index 76a4534952..034787f19a 100644
--- a/interface/src/devices/FaceTracker.cpp
+++ b/interface/src/devices/FaceTracker.cpp
@@ -1,7 +1,4 @@
 //
-//  FaceTracker.cpp
-//  interface/src/devices
-//
 //  Created by Andrzej Kapolka on 4/9/14.
 //  Copyright 2014 High Fidelity, Inc.
 //
@@ -9,22 +6,21 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
-#include <QTimer>
-
-#include <GLMHelpers.h>
-
 #include "FaceTracker.h"
-#include "InterfaceLogging.h"
-#include "Menu.h"
+
+#include <QTimer>
+#include <GLMHelpers.h>
+#include "Logging.h"
+//#include "Menu.h"
 
 const int FPS_TIMER_DELAY = 2000;  // ms
 const int FPS_TIMER_DURATION = 2000;  // ms
 
 const float DEFAULT_EYE_DEFLECTION = 0.25f;
 Setting::Handle<float> FaceTracker::_eyeDeflection("faceshiftEyeDeflection", DEFAULT_EYE_DEFLECTION);
+bool FaceTracker::_isMuted { true };
 
 void FaceTracker::init() {
-    _isMuted = Menu::getInstance()->isOptionChecked(MenuOption::MuteFaceTracking);
     _isInitialized = true;  // FaceTracker can be used now
 }
 
@@ -101,7 +97,7 @@ void FaceTracker::countFrame() {
 }
 
 void FaceTracker::finishFPSTimer() {
-    qCDebug(interfaceapp) << "Face tracker FPS =" << (float)_frameCount / ((float)FPS_TIMER_DURATION / 1000.0f);
+    qCDebug(trackers) << "Face tracker FPS =" << (float)_frameCount / ((float)FPS_TIMER_DURATION / 1000.0f);
     _isCalculatingFPS = false;
 }
 
@@ -113,3 +109,25 @@ void FaceTracker::toggleMute() {
 void FaceTracker::setEyeDeflection(float eyeDeflection) {
     _eyeDeflection.set(eyeDeflection);
 }
+
+void FaceTracker::updateFakeCoefficients(float leftBlink, float rightBlink, float browUp,
+    float jawOpen, float mouth2, float mouth3, float mouth4, QVector<float>& coefficients) {
+    const int MMMM_BLENDSHAPE = 34;
+    const int FUNNEL_BLENDSHAPE = 40;
+    const int SMILE_LEFT_BLENDSHAPE = 28;
+    const int SMILE_RIGHT_BLENDSHAPE = 29;
+    const int MAX_FAKE_BLENDSHAPE = 40;  //  Largest modified blendshape from above and below
+
+    coefficients.resize(std::max((int)coefficients.size(), MAX_FAKE_BLENDSHAPE + 1));
+    qFill(coefficients.begin(), coefficients.end(), 0.0f);
+    coefficients[_leftBlinkIndex] = leftBlink;
+    coefficients[_rightBlinkIndex] = rightBlink;
+    coefficients[_browUpCenterIndex] = browUp;
+    coefficients[_browUpLeftIndex] = browUp;
+    coefficients[_browUpRightIndex] = browUp;
+    coefficients[_jawOpenIndex] = jawOpen;
+    coefficients[SMILE_LEFT_BLENDSHAPE] = coefficients[SMILE_RIGHT_BLENDSHAPE] = mouth4;
+    coefficients[MMMM_BLENDSHAPE] = mouth2;
+    coefficients[FUNNEL_BLENDSHAPE] = mouth3;
+}
+
diff --git a/interface/src/devices/FaceTracker.h b/interface/src/devices/FaceTracker.h
index 7126d19ca8..58d5c5e574 100644
--- a/interface/src/devices/FaceTracker.h
+++ b/interface/src/devices/FaceTracker.h
@@ -1,7 +1,4 @@
 //
-//  FaceTracker.h
-//  interface/src/devices
-//
 //  Created by Andrzej Kapolka on 4/9/14.
 //  Copyright 2014 High Fidelity, Inc.
 //
@@ -20,7 +17,7 @@
 
 #include <SettingHandle.h>
 
-/// Base class for face trackers (Faceshift, DDE).
+/// Base class for face trackers (DDE, BinaryVR).
 class FaceTracker : public QObject {
     Q_OBJECT
     
@@ -45,12 +42,21 @@ public:
     const QVector<float>& getBlendshapeCoefficients() const;
     float getBlendshapeCoefficient(int index) const;
 
-    bool isMuted() const { return _isMuted; }
-    void setIsMuted(bool isMuted) { _isMuted = isMuted; }
+    static bool isMuted() { return _isMuted; }
+    static void setIsMuted(bool isMuted) { _isMuted = isMuted; }
 
     static float getEyeDeflection() { return _eyeDeflection.get(); }
     static void setEyeDeflection(float eyeDeflection);
 
+    static void updateFakeCoefficients(float leftBlink,
+                                float rightBlink,
+                                float browUp,
+                                float jawOpen,
+                                float mouth2,
+                                float mouth3,
+                                float mouth4,
+                                QVector<float>& coefficients);
+
 signals:
     void muteToggled();
 
@@ -63,7 +69,7 @@ protected:
     virtual ~FaceTracker() {};
 
     bool _isInitialized = false;
-    bool _isMuted = true;
+    static bool _isMuted;
 
     glm::vec3 _headTranslation = glm::vec3(0.0f);
     glm::quat _headRotation = glm::quat();
@@ -84,6 +90,24 @@ private:
     bool _isCalculatingFPS = false;
     int _frameCount = 0;
 
+    // see http://support.faceshift.com/support/articles/35129-export-of-blendshapes
+    static const int _leftBlinkIndex = 0;
+    static const int _rightBlinkIndex = 1;
+    static const int _leftEyeOpenIndex = 8;
+    static const int _rightEyeOpenIndex = 9;
+
+    // Brows
+    static const int _browDownLeftIndex = 14;
+    static const int _browDownRightIndex = 15;
+    static const int _browUpCenterIndex = 16;
+    static const int _browUpLeftIndex = 17;
+    static const int _browUpRightIndex = 18;
+
+    static const int _mouthSmileLeftIndex = 28;
+    static const int _mouthSmileRightIndex = 29;
+
+    static const int _jawOpenIndex = 21;
+
     static Setting::Handle<float> _eyeDeflection;
 };
 
diff --git a/interface/src/devices/Faceshift.cpp b/interface/src/devices/Faceshift.cpp
deleted file mode 100644
index 81c099c740..0000000000
--- a/interface/src/devices/Faceshift.cpp
+++ /dev/null
@@ -1,310 +0,0 @@
-//
-//  Faceshift.cpp
-//  interface/src/devices
-//
-//  Created by Andrzej Kapolka on 9/3/13.
-//  Copyright 2013 High Fidelity, Inc.
-//
-//  Distributed under the Apache License, Version 2.0.
-//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
-//
-
-#include <QTimer>
-
-#include <GLMHelpers.h>
-#include <NumericalConstants.h>
-#include <PerfStat.h>
-
-#include "Faceshift.h"
-#include "Menu.h"
-#include "Util.h"
-#include "InterfaceLogging.h"
-
-#ifdef HAVE_FACESHIFT
-using namespace fs;
-#endif
-
-using namespace std;
-
-const QString DEFAULT_FACESHIFT_HOSTNAME = "localhost";
-const quint16 FACESHIFT_PORT = 33433;
-
-Faceshift::Faceshift() :
-    _hostname("faceshiftHostname", DEFAULT_FACESHIFT_HOSTNAME)
-{
-#ifdef HAVE_FACESHIFT
-    connect(&_tcpSocket, SIGNAL(connected()), SLOT(noteConnected()));
-    connect(&_tcpSocket, SIGNAL(error(QAbstractSocket::SocketError)), SLOT(noteError(QAbstractSocket::SocketError)));
-    connect(&_tcpSocket, SIGNAL(readyRead()), SLOT(readFromSocket()));
-    connect(&_tcpSocket, SIGNAL(stateChanged(QAbstractSocket::SocketState)), SIGNAL(connectionStateChanged()));
-    connect(&_tcpSocket, SIGNAL(disconnected()), SLOT(noteDisconnected()));
-
-    connect(&_udpSocket, SIGNAL(readyRead()), SLOT(readPendingDatagrams()));
-
-    _udpSocket.bind(FACESHIFT_PORT);
-#endif
-}
-
-#ifdef HAVE_FACESHIFT
-void Faceshift::init() {
-    FaceTracker::init();
-    setEnabled(Menu::getInstance()->isOptionChecked(MenuOption::Faceshift) && !_isMuted);
-}
-
-void Faceshift::update(float deltaTime) {
-    if (!isActive()) {
-        return;
-    }
-    FaceTracker::update(deltaTime);
-    
-    // get the euler angles relative to the window
-    glm::vec3 eulers = glm::degrees(safeEulerAngles(_headRotation * glm::quat(glm::radians(glm::vec3(
-        (_eyeGazeLeftPitch + _eyeGazeRightPitch) / 2.0f, (_eyeGazeLeftYaw + _eyeGazeRightYaw) / 2.0f, 0.0f)))));
-
-    // compute and subtract the long term average
-    const float LONG_TERM_AVERAGE_SMOOTHING = 0.999f;
-    if (!_longTermAverageInitialized) {
-        _longTermAverageEyePitch = eulers.x;
-        _longTermAverageEyeYaw = eulers.y;
-        _longTermAverageInitialized = true;
-
-    } else {
-        _longTermAverageEyePitch = glm::mix(eulers.x, _longTermAverageEyePitch, LONG_TERM_AVERAGE_SMOOTHING);
-        _longTermAverageEyeYaw = glm::mix(eulers.y, _longTermAverageEyeYaw, LONG_TERM_AVERAGE_SMOOTHING);
-    }
-    _estimatedEyePitch = eulers.x - _longTermAverageEyePitch;
-    _estimatedEyeYaw = eulers.y - _longTermAverageEyeYaw;
-}
-
-void Faceshift::reset() {
-    if (_tcpSocket.state() == QAbstractSocket::ConnectedState) {
-        qCDebug(interfaceapp, "Faceshift: Reset");
-
-        FaceTracker::reset();
-
-        string message;
-        fsBinaryStream::encode_message(message, fsMsgCalibrateNeutral());
-        send(message);
-    }
-    _longTermAverageInitialized = false;
-}
-
-bool Faceshift::isActive() const {
-    const quint64 ACTIVE_TIMEOUT_USECS = 1000000;
-    return (usecTimestampNow() - _lastReceiveTimestamp) < ACTIVE_TIMEOUT_USECS;
-}
-
-bool Faceshift::isTracking() const {
-    return isActive() && _tracking;
-}
-#endif
-
-
-bool Faceshift::isConnectedOrConnecting() const {
-    return _tcpSocket.state() == QAbstractSocket::ConnectedState ||
-    (_tcpRetryCount == 0 && _tcpSocket.state() != QAbstractSocket::UnconnectedState);
-}
-
-void Faceshift::updateFakeCoefficients(float leftBlink, float rightBlink, float browUp,
-        float jawOpen, float mouth2, float mouth3, float mouth4, QVector<float>& coefficients) const {
-    const int MMMM_BLENDSHAPE = 34;
-    const int FUNNEL_BLENDSHAPE = 40;
-    const int SMILE_LEFT_BLENDSHAPE = 28;
-    const int SMILE_RIGHT_BLENDSHAPE = 29;
-    const int MAX_FAKE_BLENDSHAPE = 40;  //  Largest modified blendshape from above and below
-
-    coefficients.resize(max((int)coefficients.size(), MAX_FAKE_BLENDSHAPE + 1));
-    qFill(coefficients.begin(), coefficients.end(), 0.0f);
-    coefficients[_leftBlinkIndex] = leftBlink;
-    coefficients[_rightBlinkIndex] = rightBlink;
-    coefficients[_browUpCenterIndex] = browUp;
-    coefficients[_browUpLeftIndex] = browUp;
-    coefficients[_browUpRightIndex] = browUp;
-    coefficients[_jawOpenIndex] = jawOpen;
-    coefficients[SMILE_LEFT_BLENDSHAPE] = coefficients[SMILE_RIGHT_BLENDSHAPE] = mouth4;
-    coefficients[MMMM_BLENDSHAPE] = mouth2;
-    coefficients[FUNNEL_BLENDSHAPE] = mouth3;
-}
-
-void Faceshift::setEnabled(bool enabled) {
-    // Don't enable until have explicitly initialized
-    if (!_isInitialized) {
-        return;
-    }
-#ifdef HAVE_FACESHIFT
-    if ((_tcpEnabled = enabled)) {
-        connectSocket();
-    } else {
-        qCDebug(interfaceapp, "Faceshift: Disconnecting...");
-        _tcpSocket.disconnectFromHost();
-    }
-#endif
-}
-
-void Faceshift::connectSocket() {
-    if (_tcpEnabled) {
-        if (!_tcpRetryCount) {
-            qCDebug(interfaceapp, "Faceshift: Connecting...");
-        }
-
-        _tcpSocket.connectToHost(_hostname.get(), FACESHIFT_PORT);
-        _tracking = false;
-    }
-}
-
-void Faceshift::noteConnected() {
-#ifdef HAVE_FACESHIFT
-    qCDebug(interfaceapp, "Faceshift: Connected");
-    // request the list of blendshape names
-    string message;
-    fsBinaryStream::encode_message(message, fsMsgSendBlendshapeNames());
-    send(message);
-#endif
-}
-
-void Faceshift::noteDisconnected() {
-#ifdef HAVE_FACESHIFT
-    qCDebug(interfaceapp, "Faceshift: Disconnected");
-#endif
-}
-
-void Faceshift::noteError(QAbstractSocket::SocketError error) {
-    if (!_tcpRetryCount) {
-       // Only spam log with fail to connect the first time, so that we can keep waiting for server
-       qCWarning(interfaceapp) << "Faceshift: " << _tcpSocket.errorString();
-    }
-    // retry connection after a 2 second delay
-    if (_tcpEnabled) {
-        _tcpRetryCount++;
-        QTimer::singleShot(2000, this, SLOT(connectSocket()));
-    }
-}
-
-void Faceshift::readPendingDatagrams() {
-    QByteArray buffer;
-    while (_udpSocket.hasPendingDatagrams()) {
-        buffer.resize(_udpSocket.pendingDatagramSize());
-        _udpSocket.readDatagram(buffer.data(), buffer.size());
-        receive(buffer);
-    }
-}
-
-void Faceshift::readFromSocket() {
-    receive(_tcpSocket.readAll());
-}
-
-void Faceshift::send(const std::string& message) {
-    _tcpSocket.write(message.data(), message.size());
-}
-
-void Faceshift::receive(const QByteArray& buffer) {
-#ifdef HAVE_FACESHIFT
-    _lastReceiveTimestamp = usecTimestampNow();
-
-    _stream.received(buffer.size(), buffer.constData());
-    fsMsgPtr msg;
-    for (fsMsgPtr msg; (msg = _stream.get_message()); ) {
-        switch (msg->id()) {
-            case fsMsg::MSG_OUT_TRACKING_STATE: {
-                const fsTrackingData& data = static_pointer_cast<fsMsgTrackingState>(msg)->tracking_data();
-                if ((_tracking = data.m_trackingSuccessful)) {
-                    glm::quat newRotation = glm::quat(data.m_headRotation.w, -data.m_headRotation.x,
-                                                      data.m_headRotation.y, -data.m_headRotation.z);
-                    // Compute angular velocity of the head
-                    glm::quat r = glm::normalize(newRotation * glm::inverse(_headRotation));
-                    float theta = 2 * acos(r.w);
-                    if (theta > EPSILON) {
-                        float rMag = glm::length(glm::vec3(r.x, r.y, r.z));
-                        _headAngularVelocity = theta / _averageFrameTime * glm::vec3(r.x, r.y, r.z) / rMag;
-                    } else {
-                        _headAngularVelocity = glm::vec3(0,0,0);
-                    }
-                    const float ANGULAR_VELOCITY_FILTER_STRENGTH = 0.3f;
-                    _headRotation = safeMix(_headRotation, newRotation, glm::clamp(glm::length(_headAngularVelocity) *
-                                                                                   ANGULAR_VELOCITY_FILTER_STRENGTH, 0.0f, 1.0f));
-
-                    const float TRANSLATION_SCALE = 0.02f;
-                    glm::vec3 newHeadTranslation = glm::vec3(data.m_headTranslation.x, data.m_headTranslation.y,
-                                                            -data.m_headTranslation.z) * TRANSLATION_SCALE;
-                    
-                    _headLinearVelocity = (newHeadTranslation - _lastHeadTranslation) / _averageFrameTime;
-                    
-                    const float LINEAR_VELOCITY_FILTER_STRENGTH = 0.3f;
-                    float velocityFilter = glm::clamp(1.0f - glm::length(_headLinearVelocity) *
-                                                      LINEAR_VELOCITY_FILTER_STRENGTH, 0.0f, 1.0f);
-                    _filteredHeadTranslation = velocityFilter * _filteredHeadTranslation + (1.0f - velocityFilter) * newHeadTranslation;
-                    
-                    _lastHeadTranslation = newHeadTranslation;
-                    _headTranslation = _filteredHeadTranslation;
-                    
-                    _eyeGazeLeftPitch = -data.m_eyeGazeLeftPitch;
-                    _eyeGazeLeftYaw = data.m_eyeGazeLeftYaw;
-                    _eyeGazeRightPitch = -data.m_eyeGazeRightPitch;
-                    _eyeGazeRightYaw = data.m_eyeGazeRightYaw;
-                    _blendshapeCoefficients = QVector<float>::fromStdVector(data.m_coeffs);
-
-                    const float FRAME_AVERAGING_FACTOR = 0.99f;
-                    quint64 usecsNow = usecTimestampNow();
-                    if (_lastMessageReceived != 0) {
-                        _averageFrameTime = FRAME_AVERAGING_FACTOR * _averageFrameTime +
-                            (1.0f - FRAME_AVERAGING_FACTOR) * (float)(usecsNow - _lastMessageReceived) / 1000000.0f;
-                    }
-                    _lastMessageReceived = usecsNow;
-                }
-                break;
-            }
-            case fsMsg::MSG_OUT_BLENDSHAPE_NAMES: {
-                const vector<string>& names = static_pointer_cast<fsMsgBlendshapeNames>(msg)->blendshape_names();
-                for (int i = 0; i < (int)names.size(); i++) {
-                    if (names[i] == "EyeBlink_L") {
-                        _leftBlinkIndex = i;
-
-                    } else if (names[i] == "EyeBlink_R") {
-                        _rightBlinkIndex = i;
-
-                    } else if (names[i] == "EyeOpen_L") {
-                        _leftEyeOpenIndex = i;
-
-                    } else if (names[i] == "EyeOpen_R") {
-                        _rightEyeOpenIndex = i;
-
-                    } else if (names[i] == "BrowsD_L") {
-                        _browDownLeftIndex = i;
-
-                    } else if (names[i] == "BrowsD_R") {
-                        _browDownRightIndex = i;
-
-                    } else if (names[i] == "BrowsU_C") {
-                        _browUpCenterIndex = i;
-
-                    } else if (names[i] == "BrowsU_L") {
-                        _browUpLeftIndex = i;
-
-                    } else if (names[i] == "BrowsU_R") {
-                        _browUpRightIndex = i;
-
-                    } else if (names[i] == "JawOpen") {
-                        _jawOpenIndex = i;
-
-                    } else if (names[i] == "MouthSmile_L") {
-                        _mouthSmileLeftIndex = i;
-
-                    } else if (names[i] == "MouthSmile_R") {
-                        _mouthSmileRightIndex = i;
-                    }
-                }
-                break;
-            }
-            default:
-                break;
-        }
-    }
-#endif
-
-    FaceTracker::countFrame();
-}
-
-void Faceshift::setHostname(const QString& hostname) {
-    _hostname.set(hostname);
-}
-
diff --git a/interface/src/devices/Faceshift.h b/interface/src/devices/Faceshift.h
deleted file mode 100644
index 2c5889857c..0000000000
--- a/interface/src/devices/Faceshift.h
+++ /dev/null
@@ -1,155 +0,0 @@
-//
-//  Faceshift.h
-//  interface/src/devices
-//
-//  Created by Andrzej Kapolka on 9/3/13.
-//  Copyright 2013 High Fidelity, Inc.
-//
-//  Distributed under the Apache License, Version 2.0.
-//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
-//
-
-#ifndef hifi_Faceshift_h
-#define hifi_Faceshift_h
-
-#include <QTcpSocket>
-#include <QUdpSocket>
-
-#ifdef HAVE_FACESHIFT
-#include <fsbinarystream.h>
-#endif
-
-#include <DependencyManager.h>
-#include <SettingHandle.h>
-
-#include "FaceTracker.h"
-
-const float STARTING_FACESHIFT_FRAME_TIME = 0.033f;
-
-/// Handles interaction with the Faceshift software, which provides head position/orientation and facial features.
-class Faceshift : public FaceTracker, public Dependency {
-    Q_OBJECT
-    SINGLETON_DEPENDENCY
-
-public:
-#ifdef HAVE_FACESHIFT
-    // If we don't have faceshift, use the base class' methods
-    virtual void init() override;
-    virtual void update(float deltaTime) override;
-    virtual void reset() override;
-
-    virtual bool isActive() const override;
-    virtual bool isTracking() const override;
-#endif
-
-    bool isConnectedOrConnecting() const;
-
-    const glm::vec3& getHeadAngularVelocity() const { return _headAngularVelocity; }
-
-    // these pitch/yaw angles are in degrees
-    float getEyeGazeLeftPitch() const { return _eyeGazeLeftPitch; }
-    float getEyeGazeLeftYaw() const { return _eyeGazeLeftYaw; }
-
-    float getEyeGazeRightPitch() const { return _eyeGazeRightPitch; }
-    float getEyeGazeRightYaw() const { return _eyeGazeRightYaw; }
-
-    float getLeftBlink() const { return getBlendshapeCoefficient(_leftBlinkIndex); }
-    float getRightBlink() const { return getBlendshapeCoefficient(_rightBlinkIndex); }
-    float getLeftEyeOpen() const { return getBlendshapeCoefficient(_leftEyeOpenIndex); }
-    float getRightEyeOpen() const { return getBlendshapeCoefficient(_rightEyeOpenIndex); }
-
-    float getBrowDownLeft() const { return getBlendshapeCoefficient(_browDownLeftIndex); }
-    float getBrowDownRight() const { return getBlendshapeCoefficient(_browDownRightIndex); }
-    float getBrowUpCenter() const { return getBlendshapeCoefficient(_browUpCenterIndex); }
-    float getBrowUpLeft() const { return getBlendshapeCoefficient(_browUpLeftIndex); }
-    float getBrowUpRight() const { return getBlendshapeCoefficient(_browUpRightIndex); }
-
-    float getMouthSize() const { return getBlendshapeCoefficient(_jawOpenIndex); }
-    float getMouthSmileLeft() const { return getBlendshapeCoefficient(_mouthSmileLeftIndex); }
-    float getMouthSmileRight() const { return getBlendshapeCoefficient(_mouthSmileRightIndex); }
-
-    QString getHostname() { return _hostname.get(); }
-    void setHostname(const QString& hostname);
-
-    void updateFakeCoefficients(float leftBlink,
-                                float rightBlink,
-                                float browUp,
-                                float jawOpen,
-                                float mouth2,
-                                float mouth3,
-                                float mouth4,
-                                QVector<float>& coefficients) const;
-
-signals:
-    void connectionStateChanged();
-
-public slots:
-    void setEnabled(bool enabled) override;
-
-private slots:
-    void connectSocket();
-    void noteConnected();
-    void noteError(QAbstractSocket::SocketError error);
-    void readPendingDatagrams();
-    void readFromSocket();
-    void noteDisconnected();
-
-private:
-    Faceshift();
-    virtual ~Faceshift() {}
-
-    void send(const std::string& message);
-    void receive(const QByteArray& buffer);
-
-    QTcpSocket _tcpSocket;
-    QUdpSocket _udpSocket;
-
-#ifdef HAVE_FACESHIFT
-    fs::fsBinaryStream _stream;
-#endif
-
-    bool _tcpEnabled = true;
-    int _tcpRetryCount = 0;
-    bool _tracking = false;
-    quint64 _lastReceiveTimestamp = 0;
-    quint64 _lastMessageReceived = 0;
-    float _averageFrameTime = STARTING_FACESHIFT_FRAME_TIME;
-
-    glm::vec3 _headAngularVelocity = glm::vec3(0.0f);
-    glm::vec3 _headLinearVelocity = glm::vec3(0.0f);
-    glm::vec3 _lastHeadTranslation = glm::vec3(0.0f);
-    glm::vec3 _filteredHeadTranslation = glm::vec3(0.0f);
-
-    // degrees
-    float _eyeGazeLeftPitch = 0.0f;
-    float _eyeGazeLeftYaw = 0.0f;
-    float _eyeGazeRightPitch = 0.0f;
-    float _eyeGazeRightYaw = 0.0f;
-
-    // degrees
-    float _longTermAverageEyePitch = 0.0f;
-    float _longTermAverageEyeYaw = 0.0f;
-    bool _longTermAverageInitialized = false;
-
-    Setting::Handle<QString> _hostname;
-
-    // see http://support.faceshift.com/support/articles/35129-export-of-blendshapes
-    int _leftBlinkIndex = 0;
-    int _rightBlinkIndex = 1;
-    int _leftEyeOpenIndex = 8;
-    int _rightEyeOpenIndex = 9;
-
-    // Brows
-    int _browDownLeftIndex = 14;
-    int _browDownRightIndex = 15;
-    int _browUpCenterIndex = 16;
-    int _browUpLeftIndex = 17;
-    int _browUpRightIndex = 18;
-
-    int _mouthSmileLeftIndex = 28;
-    int _mouthSmileRightIndex = 29;
-
-    int _jawOpenIndex = 21;
-};
-
-#endif // hifi_Faceshift_h
diff --git a/interface/src/devices/Logging.cpp b/interface/src/devices/Logging.cpp
new file mode 100644
index 0000000000..a4dcf1b711
--- /dev/null
+++ b/interface/src/devices/Logging.cpp
@@ -0,0 +1,11 @@
+//
+//  Created by Bradley Austin Davis on 2017/04/25
+//  Copyright 2013-2017 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include "Logging.h"
+
+Q_LOGGING_CATEGORY(trackers, "hifi.trackers")
diff --git a/interface/src/devices/Logging.h b/interface/src/devices/Logging.h
new file mode 100644
index 0000000000..554429b61d
--- /dev/null
+++ b/interface/src/devices/Logging.h
@@ -0,0 +1,16 @@
+//
+//  Created by Bradley Austin Davis on 2017/04/25
+//  Copyright 2013-2017 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef hifi_TrackersLogging_h
+#define hifi_TrackersLogging_h
+
+#include <QtCore/QLoggingCategory>
+
+Q_DECLARE_LOGGING_CATEGORY(trackers)
+
+#endif // hifi_TrackersLogging_h
diff --git a/interface/src/devices/MotionTracker.cpp b/interface/src/devices/MotionTracker.cpp
index 234a8d0c0c..c6012c0422 100644
--- a/interface/src/devices/MotionTracker.cpp
+++ b/interface/src/devices/MotionTracker.cpp
@@ -1,7 +1,4 @@
 //
-//  MotionTracker.cpp
-//  interface/src/devices
-//
 //  Created by Sam Cake on 6/20/14.
 //  Copyright 2014 High Fidelity, Inc.
 //
@@ -10,8 +7,6 @@
 //
 
 #include "MotionTracker.h"
-#include "GLMHelpers.h"
-
 
 // glm::mult(mat43, mat43) just the composition of the 2 matrices assuming they are in fact mat44 with the last raw = { 0, 0, 0, 1 }
 namespace glm {
diff --git a/interface/src/devices/MotionTracker.h b/interface/src/devices/MotionTracker.h
index a4b5e6735e..26c8dcea2c 100644
--- a/interface/src/devices/MotionTracker.h
+++ b/interface/src/devices/MotionTracker.h
@@ -1,7 +1,4 @@
 //
-//  MotionTracker.h
-//  interface/src/devices
-//
 //  Created by Sam Cake on 6/20/14.
 //  Copyright 2014 High Fidelity, Inc.
 //
@@ -14,20 +11,7 @@
 
 #include "DeviceTracker.h"
 
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wsign-compare"
-#endif
-
-#include <glm/glm.hpp>
-
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-
-
-#include <glm/gtc/quaternion.hpp>
-#include <glm/gtc/matrix_transform.hpp>
+#include <GLMHelpers.h>
 
 /// Base class for device trackers.
 class MotionTracker : public DeviceTracker {
diff --git a/interface/src/ui/PreferencesDialog.cpp b/interface/src/ui/PreferencesDialog.cpp
index a12d9020ae..89fffbab22 100644
--- a/interface/src/ui/PreferencesDialog.cpp
+++ b/interface/src/ui/PreferencesDialog.cpp
@@ -11,7 +11,6 @@
 #include <AudioClient.h>
 #include <avatar/AvatarManager.h>
 #include <devices/DdeFaceTracker.h>
-#include <devices/Faceshift.h>
 #include <NetworkingConstants.h>
 #include <ScriptEngines.h>
 #include <OffscreenUi.h>
@@ -207,13 +206,6 @@ void setupPreferences() {
         auto setter = [](float value) { FaceTracker::setEyeDeflection(value); };
         preferences->addPreference(new SliderPreference(AVATAR_TUNING, "Face tracker eye deflection", getter, setter));
     }
-    {
-        auto getter = []()->QString { return DependencyManager::get<Faceshift>()->getHostname(); };
-        auto setter = [](const QString& value) { DependencyManager::get<Faceshift>()->setHostname(value); };
-        auto preference = new EditPreference(AVATAR_TUNING, "Faceshift hostname", getter, setter);
-        preference->setPlaceholderText("localhost");
-        preferences->addPreference(preference);
-    }
     {
         auto getter = [=]()->QString { return myAvatar->getAnimGraphOverrideUrl().toString(); };
         auto setter = [=](const QString& value) { myAvatar->setAnimGraphOverrideUrl(QUrl(value)); };
diff --git a/libraries/avatars/src/AvatarData.cpp b/libraries/avatars/src/AvatarData.cpp
index 1427ce6359..6c265ef1b6 100644
--- a/libraries/avatars/src/AvatarData.cpp
+++ b/libraries/avatars/src/AvatarData.cpp
@@ -393,9 +393,9 @@ QByteArray AvatarData::toByteArray(AvatarDataDetail dataDetail, quint64 lastSent
         if (isFingerPointing) {
             setAtBit(flags, HAND_STATE_FINGER_POINTING_BIT);
         }
-        // faceshift state
+        // face tracker state
         if (_headData->_isFaceTrackerConnected) {
-            setAtBit(flags, IS_FACESHIFT_CONNECTED);
+            setAtBit(flags, IS_FACE_TRACKER_CONNECTED);
         }
         // eye tracker state
         if (_headData->_isEyeTrackerConnected) {
@@ -883,7 +883,7 @@ int AvatarData::parseDataFromBuffer(const QByteArray& buffer) {
         auto newHandState = getSemiNibbleAt(bitItems, HAND_STATE_START_BIT)
             + (oneAtBit(bitItems, HAND_STATE_FINGER_POINTING_BIT) ? IS_FINGER_POINTING_FLAG : 0);
 
-        auto newFaceTrackerConnected = oneAtBit(bitItems, IS_FACESHIFT_CONNECTED);
+        auto newFaceTrackerConnected = oneAtBit(bitItems, IS_FACE_TRACKER_CONNECTED);
         auto newEyeTrackerConnected = oneAtBit(bitItems, IS_EYE_TRACKER_CONNECTED);
 
         bool keyStateChanged = (_keyState != newKeyState);
diff --git a/libraries/avatars/src/AvatarData.h b/libraries/avatars/src/AvatarData.h
index 545a5f1f8c..b2cc912007 100644
--- a/libraries/avatars/src/AvatarData.h
+++ b/libraries/avatars/src/AvatarData.h
@@ -99,7 +99,7 @@ const quint32 AVATAR_MOTION_SCRIPTABLE_BITS =
 // Referential Data - R is found in the 7th bit
 const int KEY_STATE_START_BIT = 0; // 1st and 2nd bits
 const int HAND_STATE_START_BIT = 2; // 3rd and 4th bits
-const int IS_FACESHIFT_CONNECTED = 4; // 5th bit
+const int IS_FACE_TRACKER_CONNECTED = 4; // 5th bit
 const int IS_EYE_TRACKER_CONNECTED = 5; // 6th bit (was CHAT_CIRCLING)
 const int HAS_REFERENTIAL = 6; // 7th bit
 const int HAND_STATE_FINGER_POINTING_BIT = 7; // 8th bit
@@ -218,7 +218,7 @@ namespace AvatarDataPacket {
     } PACKED_END;
     const size_t AVATAR_LOCAL_POSITION_SIZE = 12;
 
-    // only present if IS_FACESHIFT_CONNECTED flag is set in AvatarInfo.flags
+    // only present if IS_FACE_TRACKER_CONNECTED flag is set in AvatarInfo.flags
     PACKED_BEGIN struct FaceTrackerInfo {
         float leftEyeBlink;
         float rightEyeBlink;
diff --git a/libraries/ui/src/ui/Menu.cpp b/libraries/ui/src/ui/Menu.cpp
index 50833e90fc..7511448c38 100644
--- a/libraries/ui/src/ui/Menu.cpp
+++ b/libraries/ui/src/ui/Menu.cpp
@@ -223,6 +223,18 @@ QAction* Menu::addCheckableActionToQMenuAndActionHash(MenuWrapper* destinationMe
     return action;
 }
 
+QAction* Menu::addCheckableActionToQMenuAndActionHash(MenuWrapper* destinationMenu,
+                                                    const QString& actionName,
+                                                    const std::function<void(bool)>& handler,
+                                                    const QKeySequence& shortcut,
+                                                    const bool checked,
+                                                    int menuItemLocation,
+                                                    const QString& grouping) { 
+    auto action = addCheckableActionToQMenuAndActionHash(destinationMenu, actionName, shortcut, checked, nullptr, nullptr, menuItemLocation, grouping);
+    connect(action, &QAction::triggered, handler);
+    return action;
+}
+
 void Menu::removeAction(MenuWrapper* menu, const QString& actionName) {
     auto action = _actionHash.value(actionName);
     menu->removeAction(action);
diff --git a/libraries/ui/src/ui/Menu.h b/libraries/ui/src/ui/Menu.h
index 9839bd1eb6..25f8f74063 100644
--- a/libraries/ui/src/ui/Menu.h
+++ b/libraries/ui/src/ui/Menu.h
@@ -9,6 +9,8 @@
 #ifndef hifi_ui_Menu_h
 #define hifi_ui_Menu_h
 
+#include <functional>
+
 #include <QtCore/QDir>
 #include <QtCore/QPointer>
 #include <QtCore/QStandardPaths>
@@ -90,6 +92,14 @@ public:
                                                     int menuItemLocation = UNSPECIFIED_POSITION,
                                                     const QString& grouping = QString());
 
+    QAction* addCheckableActionToQMenuAndActionHash(MenuWrapper* destinationMenu,
+                                                    const QString& actionName,
+                                                    const std::function<void(bool)>& handler,
+                                                    const QKeySequence& shortcut = 0,
+                                                    const bool checked = false,
+                                                    int menuItemLocation = UNSPECIFIED_POSITION,
+                                                    const QString& grouping = QString());
+
     void removeAction(MenuWrapper* menu, const QString& actionName);
 
 public slots:

From 2b43a1989f629662bb09f83b1644b7b88c543eab Mon Sep 17 00:00:00 2001
From: Brad Davis <bdavis@saintandreas.org>
Date: Fri, 28 Apr 2017 16:40:48 -0700
Subject: [PATCH 12/14] Moving face and eye trackers out of interface

---
 interface/CMakeLists.txt                      |  2 +-
 .../resources/icons/tablet-icons/goto-msg.svg | 36 +++++++++----------
 interface/src/Application.cpp                 |  2 +-
 interface/src/avatar/Head.cpp                 |  2 +-
 interface/src/avatar/MyAvatar.cpp             |  2 +-
 interface/src/devices/DdeFaceTracker.h        |  2 +-
 interface/src/devices/Leapmotion.h            |  2 +-
 .../ControllerScriptingInterface.cpp          |  2 +-
 interface/src/ui/AvatarInputs.cpp             |  2 +-
 libraries/trackers/CMakeLists.txt             |  6 ++++
 .../trackers/src/trackers}/DeviceTracker.cpp  |  0
 .../trackers/src/trackers}/DeviceTracker.h    |  0
 .../trackers/src/trackers}/EyeTracker.cpp     |  0
 .../trackers/src/trackers}/EyeTracker.h       |  0
 .../trackers/src/trackers}/FaceTracker.cpp    |  0
 .../trackers/src/trackers}/FaceTracker.h      |  0
 .../trackers/src/trackers}/Logging.cpp        |  0
 .../trackers/src/trackers}/Logging.h          |  0
 .../trackers/src/trackers}/MotionTracker.cpp  |  0
 .../trackers/src/trackers}/MotionTracker.h    |  0
 20 files changed, 32 insertions(+), 26 deletions(-)
 create mode 100644 libraries/trackers/CMakeLists.txt
 rename {interface/src/devices => libraries/trackers/src/trackers}/DeviceTracker.cpp (100%)
 rename {interface/src/devices => libraries/trackers/src/trackers}/DeviceTracker.h (100%)
 rename {interface/src/devices => libraries/trackers/src/trackers}/EyeTracker.cpp (100%)
 rename {interface/src/devices => libraries/trackers/src/trackers}/EyeTracker.h (100%)
 rename {interface/src/devices => libraries/trackers/src/trackers}/FaceTracker.cpp (100%)
 rename {interface/src/devices => libraries/trackers/src/trackers}/FaceTracker.h (100%)
 rename {interface/src/devices => libraries/trackers/src/trackers}/Logging.cpp (100%)
 rename {interface/src/devices => libraries/trackers/src/trackers}/Logging.h (100%)
 rename {interface/src/devices => libraries/trackers/src/trackers}/MotionTracker.cpp (100%)
 rename {interface/src/devices => libraries/trackers/src/trackers}/MotionTracker.h (100%)

diff --git a/interface/CMakeLists.txt b/interface/CMakeLists.txt
index e3d01826b3..d7e4b1ae7c 100644
--- a/interface/CMakeLists.txt
+++ b/interface/CMakeLists.txt
@@ -194,7 +194,7 @@ link_hifi_libraries(
   recording fbx networking model-networking entities avatars
   audio audio-client animation script-engine physics
   render-utils entities-renderer avatars-renderer ui auto-updater
-  controllers plugins image
+  controllers plugins image trackers
   ui-plugins display-plugins input-plugins
   ${NON_ANDROID_LIBRARIES}
 )
diff --git a/interface/resources/icons/tablet-icons/goto-msg.svg b/interface/resources/icons/tablet-icons/goto-msg.svg
index ef905b6066..9b576ab1bf 100644
--- a/interface/resources/icons/tablet-icons/goto-msg.svg
+++ b/interface/resources/icons/tablet-icons/goto-msg.svg
@@ -1,18 +1,18 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 19.2.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 50 50" style="enable-background:new 0 0 50 50;" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#FFFFFF;}
-	.st1{fill:#EF3B4E;}
-</style>
-<g id="Layer_2">
-</g>
-<g id="Layer_1_1_">
-	<path class="st0" d="M47.2,41.3l-9.1-9.1c-0.8-0.8-1.9-1.1-3-1l-2.4-2.4c1.8-2.6,2.8-5.7,2.8-9c0-8.9-7.2-16.1-16.1-16.1
-		S3.3,11,3.3,19.8c0,8.9,7.2,16.1,16.1,16.1c4.1,0,7.8-1.5,10.6-4l2.2,2.2c-0.2,1.1,0.1,2.2,1,3l9.1,9.1c1.4,1.4,3.6,1.4,4.9,0
-		C48.5,44.9,48.5,42.7,47.2,41.3z M19.4,32.2c-6.8,0-12.3-5.5-12.3-12.3S12.6,7.6,19.4,7.6s12.3,5.5,12.3,12.3
-		C31.8,26.6,26.2,32.2,19.4,32.2z"/>
-</g>
-<circle class="st1" cx="43.5" cy="6.5" r="5.9"/>
-</svg>
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 19.2.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 50 50" style="enable-background:new 0 0 50 50;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#FFFFFF;}
+	.st1{fill:#EF3B4E;}
+</style>
+<g id="Layer_2">
+</g>
+<g id="Layer_1_1_">
+	<path class="st0" d="M47.2,41.3l-9.1-9.1c-0.8-0.8-1.9-1.1-3-1l-2.4-2.4c1.8-2.6,2.8-5.7,2.8-9c0-8.9-7.2-16.1-16.1-16.1
+		S3.3,11,3.3,19.8c0,8.9,7.2,16.1,16.1,16.1c4.1,0,7.8-1.5,10.6-4l2.2,2.2c-0.2,1.1,0.1,2.2,1,3l9.1,9.1c1.4,1.4,3.6,1.4,4.9,0
+		C48.5,44.9,48.5,42.7,47.2,41.3z M19.4,32.2c-6.8,0-12.3-5.5-12.3-12.3S12.6,7.6,19.4,7.6s12.3,5.5,12.3,12.3
+		C31.8,26.6,26.2,32.2,19.4,32.2z"/>
+</g>
+<circle class="st1" cx="43.5" cy="6.5" r="5.9"/>
+</svg>
diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index 306fa99852..1d90c523b5 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -128,6 +128,7 @@
 #include <QmlWebWindowClass.h>
 #include <Preferences.h>
 #include <display-plugins/CompositorHelper.h>
+#include <trackers/EyeTracker.h>
 
 
 #include "AudioClient.h"
@@ -136,7 +137,6 @@
 #include "avatar/ScriptAvatar.h"
 #include "CrashHandler.h"
 #include "devices/DdeFaceTracker.h"
-#include "devices/EyeTracker.h"
 #include "devices/Leapmotion.h"
 #include "DiscoverabilityManager.h"
 #include "GLCanvas.h"
diff --git a/interface/src/avatar/Head.cpp b/interface/src/avatar/Head.cpp
index f2eeba9d60..16e5776d87 100644
--- a/interface/src/avatar/Head.cpp
+++ b/interface/src/avatar/Head.cpp
@@ -13,6 +13,7 @@
 
 #include <NodeList.h>
 #include <recording/Deck.h>
+#include <trackers/EyeTracker.h>
 
 #include "Application.h"
 #include "Avatar.h"
@@ -22,7 +23,6 @@
 #include "Menu.h"
 #include "Util.h"
 #include "devices/DdeFaceTracker.h"
-#include "devices/EyeTracker.h"
 #include <Rig.h>
 
 using namespace std;
diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp
index b8c7656839..f2726930b5 100644
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@@ -41,7 +41,7 @@
 #include <recording/Clip.h>
 #include <recording/Frame.h>
 #include <RecordingScriptingInterface.h>
-#include <devices/FaceTracker.h>
+#include <trackers/FaceTracker.h>
 
 #include "Application.h"
 #include "AvatarManager.h"
diff --git a/interface/src/devices/DdeFaceTracker.h b/interface/src/devices/DdeFaceTracker.h
index 973c3b224e..f125dfc3cf 100644
--- a/interface/src/devices/DdeFaceTracker.h
+++ b/interface/src/devices/DdeFaceTracker.h
@@ -22,7 +22,7 @@
 #include <DependencyManager.h>
 #include <ui/overlays/TextOverlay.h>
 
-#include "FaceTracker.h"
+#include <trackers/FaceTracker.h>
 
 class DdeFaceTracker : public FaceTracker, public Dependency {
     Q_OBJECT
diff --git a/interface/src/devices/Leapmotion.h b/interface/src/devices/Leapmotion.h
index d7981a65e8..6ecec8ccf9 100644
--- a/interface/src/devices/Leapmotion.h
+++ b/interface/src/devices/Leapmotion.h
@@ -14,7 +14,7 @@
 
 #include <QDateTime>
 
-#include "MotionTracker.h"
+#include <trackers/MotionTracker.h>
 
 #ifdef HAVE_LEAPMOTION
 #include <Leap.h>
diff --git a/interface/src/scripting/ControllerScriptingInterface.cpp b/interface/src/scripting/ControllerScriptingInterface.cpp
index 0d0c2ef668..f3ec3cd79d 100644
--- a/interface/src/scripting/ControllerScriptingInterface.cpp
+++ b/interface/src/scripting/ControllerScriptingInterface.cpp
@@ -17,7 +17,7 @@
 #include <plugins/PluginManager.h>
 
 #include "Application.h"
-#include "devices/MotionTracker.h"
+#include <trackers/MotionTracker.h>
 
 void ControllerScriptingInterface::handleMetaEvent(HFMetaEvent* event) {
     if (event->type() == HFActionEvent::startType()) {
diff --git a/interface/src/ui/AvatarInputs.cpp b/interface/src/ui/AvatarInputs.cpp
index 341915e57f..2b715eac9d 100644
--- a/interface/src/ui/AvatarInputs.cpp
+++ b/interface/src/ui/AvatarInputs.cpp
@@ -11,9 +11,9 @@
 
 #include <AudioClient.h>
 #include <SettingHandle.h>
+#include <trackers/FaceTracker.h>
 
 #include "Application.h"
-#include "devices/FaceTracker.h"
 #include "Menu.h"
 
 HIFI_QML_DEF(AvatarInputs)
diff --git a/libraries/trackers/CMakeLists.txt b/libraries/trackers/CMakeLists.txt
new file mode 100644
index 0000000000..0999a45b59
--- /dev/null
+++ b/libraries/trackers/CMakeLists.txt
@@ -0,0 +1,6 @@
+set(TARGET_NAME trackers)
+setup_hifi_library()
+GroupSources("src")
+link_hifi_libraries(shared)
+
+target_bullet()
diff --git a/interface/src/devices/DeviceTracker.cpp b/libraries/trackers/src/trackers/DeviceTracker.cpp
similarity index 100%
rename from interface/src/devices/DeviceTracker.cpp
rename to libraries/trackers/src/trackers/DeviceTracker.cpp
diff --git a/interface/src/devices/DeviceTracker.h b/libraries/trackers/src/trackers/DeviceTracker.h
similarity index 100%
rename from interface/src/devices/DeviceTracker.h
rename to libraries/trackers/src/trackers/DeviceTracker.h
diff --git a/interface/src/devices/EyeTracker.cpp b/libraries/trackers/src/trackers/EyeTracker.cpp
similarity index 100%
rename from interface/src/devices/EyeTracker.cpp
rename to libraries/trackers/src/trackers/EyeTracker.cpp
diff --git a/interface/src/devices/EyeTracker.h b/libraries/trackers/src/trackers/EyeTracker.h
similarity index 100%
rename from interface/src/devices/EyeTracker.h
rename to libraries/trackers/src/trackers/EyeTracker.h
diff --git a/interface/src/devices/FaceTracker.cpp b/libraries/trackers/src/trackers/FaceTracker.cpp
similarity index 100%
rename from interface/src/devices/FaceTracker.cpp
rename to libraries/trackers/src/trackers/FaceTracker.cpp
diff --git a/interface/src/devices/FaceTracker.h b/libraries/trackers/src/trackers/FaceTracker.h
similarity index 100%
rename from interface/src/devices/FaceTracker.h
rename to libraries/trackers/src/trackers/FaceTracker.h
diff --git a/interface/src/devices/Logging.cpp b/libraries/trackers/src/trackers/Logging.cpp
similarity index 100%
rename from interface/src/devices/Logging.cpp
rename to libraries/trackers/src/trackers/Logging.cpp
diff --git a/interface/src/devices/Logging.h b/libraries/trackers/src/trackers/Logging.h
similarity index 100%
rename from interface/src/devices/Logging.h
rename to libraries/trackers/src/trackers/Logging.h
diff --git a/interface/src/devices/MotionTracker.cpp b/libraries/trackers/src/trackers/MotionTracker.cpp
similarity index 100%
rename from interface/src/devices/MotionTracker.cpp
rename to libraries/trackers/src/trackers/MotionTracker.cpp
diff --git a/interface/src/devices/MotionTracker.h b/libraries/trackers/src/trackers/MotionTracker.h
similarity index 100%
rename from interface/src/devices/MotionTracker.h
rename to libraries/trackers/src/trackers/MotionTracker.h

From 819f02a988a025c7ae33cf18d8f265c4352c0f11 Mon Sep 17 00:00:00 2001
From: David Rowe <david@ctrlaltstudio.com>
Date: Sun, 30 Apr 2017 11:40:28 +1200
Subject: [PATCH 13/14] Fix keyboard not raising for Facebook username field

---
 interface/resources/html/raiseAndLowerKeyboard.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interface/resources/html/raiseAndLowerKeyboard.js b/interface/resources/html/raiseAndLowerKeyboard.js
index 63e016c5d4..27ead23124 100644
--- a/interface/resources/html/raiseAndLowerKeyboard.js
+++ b/interface/resources/html/raiseAndLowerKeyboard.js
@@ -19,7 +19,7 @@
     function shouldRaiseKeyboard() {
         var nodeName = document.activeElement.nodeName;
         var nodeType = document.activeElement.type;
-        if (nodeName === "INPUT" && (nodeType === "text" || nodeType === "number" || nodeType === "password")
+        if (nodeName === "INPUT" && ["email", "number", "password", "tel", "text", "url"].indexOf(nodeType) !== -1
             || document.activeElement.nodeName === "TEXTAREA") {
             return true;
         } else {

From 0c09823f6731e15e50c5bf361144ea120fb94d20 Mon Sep 17 00:00:00 2001
From: "Anthony J. Thibault" <tony@highfidelity.io>
Date: Mon, 1 May 2017 09:10:31 -0700
Subject: [PATCH 14/14] clang warning fixes, unused variables...

---
 interface/src/avatar/MyAvatar.cpp | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp
index 05e5277746..2966f8a95d 100644
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@@ -83,16 +83,12 @@ const float MyAvatar::ZOOM_MAX = 25.0f;
 const float MyAvatar::ZOOM_DEFAULT = 1.5f;
 
 // default values, used when avatar is missing joints... (avatar space)
-static const glm::quat DEFAULT_AVATAR_MIDDLE_EYE_ROT { Quaternions::Y_180 };
+// static const glm::quat DEFAULT_AVATAR_MIDDLE_EYE_ROT { Quaternions::Y_180 };
 static const glm::vec3 DEFAULT_AVATAR_MIDDLE_EYE_POS { 0.0f, 0.6f, 0.0f };
-static const glm::quat DEFAULT_AVATAR_HEAD_ROT { Quaternions::Y_180 };
 static const glm::vec3 DEFAULT_AVATAR_HEAD_POS { 0.0f, 0.53f, 0.0f };
 static const glm::vec3 DEFAULT_AVATAR_NECK_POS { 0.0f, 0.445f, 0.025f };
-static const glm::quat DEFAULT_AVATAR_NECK_ROT { Quaternions::Y_180 };
 static const glm::vec3 DEFAULT_AVATAR_SPINE2_POS { 0.0f, 0.32f, 0.02f };
-static const glm::quat DEFAULT_AVATAR_SPINE2_ROT { Quaternions::Y_180};
 static const glm::vec3 DEFAULT_AVATAR_HIPS_POS { 0.0f, 0.0f, 0.0f };
-static const glm::quat DEFAULT_AVATAR_HIPS_ROT { Quaternions::Y_180 };
 static const glm::vec3 DEFAULT_AVATAR_LEFTFOOT_POS { -0.08f, -0.96f, 0.029f};
 static const glm::quat DEFAULT_AVATAR_LEFTFOOT_ROT { -0.40167322754859924f, 0.9154590368270874f, -0.005437685176730156f, -0.023744143545627594f };
 static const glm::vec3 DEFAULT_AVATAR_RIGHTFOOT_POS { 0.08f, -0.96f, 0.029f };