Moved direction vectors to AvatarData, made them align with OpenGL view space

(to avoid the 180 degree rotations).

interface/src/Application.cpp

@@ -288,22 +288,22 @@ void Application::paintGL() {
     if (_myCamera.getMode() == CAMERA_MODE_MIRROR) {
         _myCamera.setTightness     (100.0f); 
         _myCamera.setTargetPosition(_myAvatar.getSpringyHeadPosition());
-        _myCamera.setTargetRotation(_myAvatar.getHead().getWorldAlignedOrientation());
+        _myCamera.setTargetRotation(_myAvatar.getHead().getWorldAlignedOrientation() * glm::quat(glm::vec3(0.0f, PI, 0.0f)));
         
     } else if (OculusManager::isConnected()) {
         _myCamera.setUpShift       (0.0f);
         _myCamera.setDistance      (0.0f);
         _myCamera.setTightness     (100.0f);
         _myCamera.setTargetPosition(_myAvatar.getHeadPosition());
-        _myCamera.setTargetRotation(_myAvatar.getHead().getOrientation() * glm::quat(glm::vec3(0.0f, PI, 0.0f)));
+        _myCamera.setTargetRotation(_myAvatar.getHead().getOrientation());
     
     } else if (_myCamera.getMode() == CAMERA_MODE_FIRST_PERSON) {
         _myCamera.setTargetPosition(_myAvatar.getSpringyHeadPosition());
-        _myCamera.setTargetRotation(_myAvatar.getHead().getWorldAlignedOrientation() * glm::quat(glm::vec3(0.0f, PI, 0.0f)));
+        _myCamera.setTargetRotation(_myAvatar.getHead().getWorldAlignedOrientation());
         
     } else if (_myCamera.getMode() == CAMERA_MODE_THIRD_PERSON) {
         _myCamera.setTargetPosition(_myAvatar.getHeadPosition());
-        _myCamera.setTargetRotation(_myAvatar.getHead().getWorldAlignedOrientation() * glm::quat(glm::vec3(0.0f, PI, 0.0f)));
+        _myCamera.setTargetRotation(_myAvatar.getHead().getWorldAlignedOrientation());
     }
     
     // important...
@@ -1111,7 +1111,7 @@ void Application::initMenu() {
     _window->setMenuBar(menuBar);
     
     QMenu* fileMenu = menuBar->addMenu("File");
-    fileMenu->addAction("Quit", this, SLOT(quit()), (Qt::Key_Q || Qt::Key_Control));
+    fileMenu->addAction("Quit", this, SLOT(quit()), Qt::CTRL | Qt::Key_Q);
 
     QMenu* pairMenu = menuBar->addMenu("Pair");
     pairMenu->addAction("Pair", this, SLOT(pair()));

interface/src/Avatar.cpp

@@ -259,9 +259,9 @@ void Avatar::simulate(float deltaTime, Transmitter* transmitter) {
     }
     
     glm::quat orientation = getOrientation();
-    glm::vec3 front = orientation * IDENTITY_FRONT;
+    glm::vec3 front = orientation * AVATAR_FRONT;
-    glm::vec3 right = orientation * IDENTITY_RIGHT;
+    glm::vec3 right = orientation * AVATAR_RIGHT;
-    glm::vec3 up = orientation * IDENTITY_UP;
+    glm::vec3 up = orientation * AVATAR_UP;
     
     // driving the avatar around should only apply if this is my avatar (as opposed to an avatar being driven remotely)
     if (!_owningAgent) {
@@ -331,8 +331,8 @@ void Avatar::simulate(float deltaTime, Transmitter* transmitter) {
     const float BODY_ROLL_WHILE_TURNING       = 0.2;
     float forwardComponentOfVelocity = glm::dot(getBodyFrontDirection(), _velocity);
     orientation = orientation * glm::quat(glm::radians(glm::vec3(
-        BODY_PITCH_WHILE_WALKING * deltaTime * forwardComponentOfVelocity, 0.0f,
+        -BODY_PITCH_WHILE_WALKING * deltaTime * forwardComponentOfVelocity, 0.0f,
-        -BODY_ROLL_WHILE_TURNING  * deltaTime * _speed * _bodyYawDelta)));
+        BODY_ROLL_WHILE_TURNING  * deltaTime * _speed * _bodyYawDelta)));
     
     // these forces keep the body upright...     
     float tiltDecay = BODY_UPRIGHT_FORCE * deltaTime;
@@ -476,14 +476,14 @@ void Avatar::updateHandMovementAndTouching(float deltaTime) {
     glm::quat orientation = getOrientation();
 
     // reset hand and arm positions according to hand movement
-    glm::vec3 right = orientation * IDENTITY_RIGHT;
+    glm::vec3 right = orientation * AVATAR_RIGHT;
-    glm::vec3 up = orientation * IDENTITY_UP;
+    glm::vec3 up = orientation * AVATAR_UP;
-    glm::vec3 front = orientation * IDENTITY_FRONT;
+    glm::vec3 front = orientation * AVATAR_FRONT;
 
     glm::vec3 transformedHandMovement
     = right *  _movedHandOffset.x * 2.0f
     + up	  * -_movedHandOffset.y * 2.0f
-    + front * -_movedHandOffset.y * 2.0f;
+    + front * -_movedHandOffset.z * 2.0f;
     
     _joint[ AVATAR_JOINT_RIGHT_FINGERTIPS ].position += transformedHandMovement;
             
@@ -884,32 +884,32 @@ void Avatar::initializeSkeleton() {
     
     // specify the default pose position
     _joint[ AVATAR_JOINT_PELVIS           ].defaultPosePosition = glm::vec3(  0.0,   0.0,  0.0 );
-    _joint[ AVATAR_JOINT_TORSO            ].defaultPosePosition = glm::vec3(  0.0,   0.09,  0.01 );
+    _joint[ AVATAR_JOINT_TORSO            ].defaultPosePosition = glm::vec3(  0.0,   0.09,  -0.01 );
-    _joint[ AVATAR_JOINT_CHEST            ].defaultPosePosition = glm::vec3(  0.0,   0.09,  0.01  );
+    _joint[ AVATAR_JOINT_CHEST            ].defaultPosePosition = glm::vec3(  0.0,   0.09,  -0.01  );
-    _joint[ AVATAR_JOINT_NECK_BASE        ].defaultPosePosition = glm::vec3(  0.0,   0.14,  -0.01 );
+    _joint[ AVATAR_JOINT_NECK_BASE        ].defaultPosePosition = glm::vec3(  0.0,   0.14,  0.01 );
     _joint[ AVATAR_JOINT_HEAD_BASE        ].defaultPosePosition = glm::vec3(  0.0,   0.04,  0.00 );
     
-    _joint[ AVATAR_JOINT_LEFT_COLLAR      ].defaultPosePosition = glm::vec3(  0.06,  0.04, -0.01 );
+    _joint[ AVATAR_JOINT_LEFT_COLLAR      ].defaultPosePosition = glm::vec3( -0.06,  0.04, 0.01 );
-    _joint[ AVATAR_JOINT_LEFT_SHOULDER      ].defaultPosePosition = glm::vec3(  0.05,  0.0,  -0.01 );
+    _joint[ AVATAR_JOINT_LEFT_SHOULDER      ].defaultPosePosition = glm::vec3( -0.05,  0.0,  0.01 );
     _joint[ AVATAR_JOINT_LEFT_ELBOW       ].defaultPosePosition = glm::vec3(  0.0,  -0.16,  0.0  );
     _joint[ AVATAR_JOINT_LEFT_WRIST          ].defaultPosePosition = glm::vec3(  0.0,  -0.117,  0.0  );
     _joint[ AVATAR_JOINT_LEFT_FINGERTIPS  ].defaultPosePosition = glm::vec3(  0.0,  -0.1,  0.0  );
     
-    _joint[ AVATAR_JOINT_RIGHT_COLLAR     ].defaultPosePosition = glm::vec3( -0.06,  0.04, -0.01 );
+    _joint[ AVATAR_JOINT_RIGHT_COLLAR     ].defaultPosePosition = glm::vec3( 0.06,  0.04, 0.01 );
-    _joint[ AVATAR_JOINT_RIGHT_SHOULDER      ].defaultPosePosition = glm::vec3( -0.05,  0.0,  -0.01 );
+    _joint[ AVATAR_JOINT_RIGHT_SHOULDER      ].defaultPosePosition = glm::vec3( 0.05,  0.0,  0.01 );
     _joint[ AVATAR_JOINT_RIGHT_ELBOW      ].defaultPosePosition = glm::vec3(  0.0,  -0.16,  0.0  );
     _joint[ AVATAR_JOINT_RIGHT_WRIST      ].defaultPosePosition = glm::vec3(  0.0,  -0.117,  0.0  );
     _joint[ AVATAR_JOINT_RIGHT_FINGERTIPS ].defaultPosePosition = glm::vec3(  0.0,  -0.1,  0.0  );
     
-    _joint[ AVATAR_JOINT_LEFT_HIP          ].defaultPosePosition = glm::vec3(  0.05,  0.0,  -0.02 );
+    _joint[ AVATAR_JOINT_LEFT_HIP          ].defaultPosePosition = glm::vec3(  -0.05,  0.0,  0.02 );
-    _joint[ AVATAR_JOINT_LEFT_KNEE          ].defaultPosePosition = glm::vec3( -0.01, -0.25,  0.03 );
+    _joint[ AVATAR_JOINT_LEFT_KNEE          ].defaultPosePosition = glm::vec3( 0.01, -0.25,  -0.03 );
-    _joint[ AVATAR_JOINT_LEFT_HEEL          ].defaultPosePosition = glm::vec3( -0.01, -0.22, -0.08 );
+    _joint[ AVATAR_JOINT_LEFT_HEEL          ].defaultPosePosition = glm::vec3( 0.01, -0.22, 0.08 );
-    _joint[ AVATAR_JOINT_LEFT_TOES          ].defaultPosePosition = glm::vec3(  0.00, -0.03,  0.05 );
+    _joint[ AVATAR_JOINT_LEFT_TOES          ].defaultPosePosition = glm::vec3(  0.00, -0.03,  -0.05 );
     
-    _joint[ AVATAR_JOINT_RIGHT_HIP          ].defaultPosePosition = glm::vec3( -0.05,  0.0,  -0.02 );
+    _joint[ AVATAR_JOINT_RIGHT_HIP          ].defaultPosePosition = glm::vec3(  0.05,  0.0,  0.02 );
-    _joint[ AVATAR_JOINT_RIGHT_KNEE          ].defaultPosePosition = glm::vec3(  0.01, -0.25,  0.03 );
+    _joint[ AVATAR_JOINT_RIGHT_KNEE          ].defaultPosePosition = glm::vec3(  -0.01, -0.25,  -0.03 );
-    _joint[ AVATAR_JOINT_RIGHT_HEEL          ].defaultPosePosition = glm::vec3(  0.01, -0.22, -0.08 );
+    _joint[ AVATAR_JOINT_RIGHT_HEEL          ].defaultPosePosition = glm::vec3(  -0.01, -0.22, 0.08 );
-    _joint[ AVATAR_JOINT_RIGHT_TOES          ].defaultPosePosition = glm::vec3(  0.00, -0.03,  0.05 );
+    _joint[ AVATAR_JOINT_RIGHT_TOES          ].defaultPosePosition = glm::vec3(  0.00, -0.03,  -0.05 );
     
     // specify the radii of the joints
     _joint[ AVATAR_JOINT_PELVIS           ].radius = 0.07;
@@ -1120,14 +1120,14 @@ void Avatar::updateArmIKAndConstraints(float deltaTime) {
 
 glm::quat Avatar::computeRotationFromBodyToWorldUp(float proportion) const {
     glm::quat orientation = getOrientation();
-    glm::vec3 currentUp = orientation * IDENTITY_UP;
+    glm::vec3 currentUp = orientation * AVATAR_UP;
     float angle = glm::degrees(acosf(glm::clamp(glm::dot(currentUp, _worldUpDirection), -1.0f, 1.0f)));
     if (angle < EPSILON) {
         return glm::quat();
     }
     glm::vec3 axis;
     if (angle > 179.99f) { // 180 degree rotation; must use another axis
-        axis = orientation * IDENTITY_RIGHT;
+        axis = orientation * AVATAR_RIGHT;
     } else {
         axis = glm::normalize(glm::cross(currentUp, _worldUpDirection));
     }

interface/src/Avatar.h

@@ -11,7 +11,6 @@
 #include <glm/glm.hpp>
 #include <glm/gtc/quaternion.hpp>
 #include <AvatarData.h>
-#include <Orientation.h>
 #include "world.h"
 #include "AvatarTouch.h"
 #include "InterfaceConfig.h"
@@ -71,9 +70,9 @@ public:
     const glm::vec3& getHeadPosition          ()                const { return _joint[ AVATAR_JOINT_HEAD_BASE ].position;}
     const glm::vec3& getSpringyHeadPosition   ()                const { return _joint[ AVATAR_JOINT_HEAD_BASE ].springyPosition;}
     const glm::vec3& getJointPosition         (AvatarJointID j) const { return _joint[j].springyPosition;}
-    glm::vec3        getBodyRightDirection    ()                const { return getOrientation() * IDENTITY_RIGHT; }
+    glm::vec3        getBodyRightDirection    ()                const { return getOrientation() * AVATAR_RIGHT; }
-    glm::vec3        getBodyUpDirection       ()                const { return getOrientation() * IDENTITY_UP; }
+    glm::vec3        getBodyUpDirection       ()                const { return getOrientation() * AVATAR_UP; }
-    glm::vec3        getBodyFrontDirection    ()                const { return getOrientation() * IDENTITY_FRONT; }
+    glm::vec3        getBodyFrontDirection    ()                const { return getOrientation() * AVATAR_FRONT; }
     const glm::vec3& getVelocity              ()                const { return _velocity;}
     float            getSpeed                 ()                const { return _speed;}
     float            getHeight                ()                const { return _height;}

interface/src/Head.cpp

@@ -172,9 +172,9 @@ void Head::determineIfLookingAtSomething() {
 void Head::calculateGeometry() {
     //generate orientation directions 
     glm::quat orientation = getOrientation();
-    glm::vec3 right = orientation * IDENTITY_RIGHT;
+    glm::vec3 right = orientation * AVATAR_RIGHT;
-    glm::vec3 up = orientation * IDENTITY_UP;
+    glm::vec3 up = orientation * AVATAR_UP;
-    glm::vec3 front = orientation * IDENTITY_FRONT;
+    glm::vec3 front = orientation * AVATAR_FRONT;
 
     //calculate the eye positions 
     _leftEyePosition  = _position 
@@ -347,9 +347,9 @@ void Head::renderMouth() {
     float s = sqrt(_averageLoudness);
 
     glm::quat orientation = getOrientation();
-    glm::vec3 right = orientation * IDENTITY_RIGHT;
+    glm::vec3 right = orientation * AVATAR_RIGHT;
-    glm::vec3 up = orientation * IDENTITY_UP;
+    glm::vec3 up = orientation * AVATAR_UP;
-    glm::vec3 front = orientation * IDENTITY_FRONT;
+    glm::vec3 front = orientation * AVATAR_FRONT;
 
     glm::vec3 r = right * _scale * (0.30f + s * 0.0014f );
     glm::vec3 u = up * _scale * (0.05f + s * 0.0040f );
@@ -415,9 +415,9 @@ void Head::renderEyeBrows() {
     glm::vec3 rightBottom = _leftEyePosition;
    
     glm::quat orientation = getOrientation();
-    glm::vec3 right = orientation * IDENTITY_RIGHT;
+    glm::vec3 right = orientation * AVATAR_RIGHT;
-    glm::vec3 up = orientation * IDENTITY_UP;
+    glm::vec3 up = orientation * AVATAR_UP;
-    glm::vec3 front = orientation * IDENTITY_FRONT;
+    glm::vec3 front = orientation * AVATAR_FRONT;
     
     glm::vec3 r = right * length; 
     glm::vec3 u = up * height; 
@@ -502,20 +502,20 @@ void Head::renderEyeBalls() {
 
                 //rotate the eyeball to aim towards the lookat position
                 glm::vec3 targetLookatAxis = glm::normalize(_lookAtPosition - _leftEyePosition); // the lookat direction
-                glm::vec3 rotationAxis = glm::cross(targetLookatAxis, IDENTITY_UP);
+                glm::vec3 rotationAxis = glm::cross(targetLookatAxis, AVATAR_UP);
-                float angle = 180.0f - angleBetween(targetLookatAxis, IDENTITY_UP);            
+                float angle = 180.0f - angleBetween(targetLookatAxis, AVATAR_UP);            
                 glRotatef(angle, rotationAxis.x, rotationAxis.y, rotationAxis.z);
                 glRotatef(180.0, 0.0f, 1.0f, 0.0f); //adjust roll to correct after previous rotations
             } else {
 
                 //rotate the eyeball to aim straight ahead
-                glm::vec3 rotationAxisToHeadFront = glm::cross(front, IDENTITY_UP);            
+                glm::vec3 rotationAxisToHeadFront = glm::cross(front, AVATAR_UP);            
-                float angleToHeadFront = 180.0f - angleBetween(front, IDENTITY_UP);            
+                float angleToHeadFront = 180.0f - angleBetween(front, AVATAR_UP);            
                 glRotatef(angleToHeadFront, rotationAxisToHeadFront.x, rotationAxisToHeadFront.y, rotationAxisToHeadFront.z);
 
                 //set the amount of roll (for correction after previous rotations)
-                float rollRotation = angleBetween(front, IDENTITY_FRONT);            
+                float rollRotation = angleBetween(front, AVATAR_FRONT);            
-                float dot = glm::dot(front, -IDENTITY_RIGHT);
+                float dot = glm::dot(front, -AVATAR_RIGHT);
                 if ( dot < 0.0f ) { rollRotation = -rollRotation; }
                 glRotatef(rollRotation, 0.0f, 1.0f, 0.0f); //roll the iris or correct roll about the lookat vector
             }
@@ -546,21 +546,21 @@ void Head::renderEyeBalls() {
             
                 //rotate the eyeball to aim towards the lookat position
                 glm::vec3 targetLookatAxis = glm::normalize(_lookAtPosition - _rightEyePosition);
-                glm::vec3 rotationAxis = glm::cross(targetLookatAxis, IDENTITY_UP);
+                glm::vec3 rotationAxis = glm::cross(targetLookatAxis, AVATAR_UP);
-                float angle = 180.0f - angleBetween(targetLookatAxis, IDENTITY_UP);            
+                float angle = 180.0f - angleBetween(targetLookatAxis, AVATAR_UP);            
                 glRotatef(angle, rotationAxis.x, rotationAxis.y, rotationAxis.z);
                 glRotatef(180.0f, 0.0f, 1.0f, 0.0f); //adjust roll to correct after previous rotations
 
             } else {
 
                 //rotate the eyeball to aim straight ahead
-                glm::vec3 rotationAxisToHeadFront = glm::cross(front, IDENTITY_UP);            
+                glm::vec3 rotationAxisToHeadFront = glm::cross(front, AVATAR_UP);            
-                float angleToHeadFront = 180.0f - angleBetween(front, IDENTITY_UP);            
+                float angleToHeadFront = 180.0f - angleBetween(front, AVATAR_UP);            
                 glRotatef(angleToHeadFront, rotationAxisToHeadFront.x, rotationAxisToHeadFront.y, rotationAxisToHeadFront.z);
 
                 //set the amount of roll (for correction after previous rotations)
-                float rollRotation = angleBetween(front, IDENTITY_FRONT); 
+                float rollRotation = angleBetween(front, AVATAR_FRONT); 
-                float dot = glm::dot(front, -IDENTITY_RIGHT);
+                float dot = glm::dot(front, -AVATAR_RIGHT);
                 if ( dot < 0.0f ) { rollRotation = -rollRotation; }
                 glRotatef(rollRotation, 0.0f, 1.0f, 0.0f); //roll the iris or correct roll about the lookat vector
             }
@@ -596,9 +596,9 @@ void Head::renderLookatVectors(glm::vec3 leftEyePosition, glm::vec3 rightEyePosi
 void Head::updateHairPhysics(float deltaTime) {
 
     glm::quat orientation = getOrientation();
-    glm::vec3 right = orientation * IDENTITY_RIGHT;
+    glm::vec3 right = orientation * AVATAR_RIGHT;
-    glm::vec3 up = orientation * IDENTITY_UP;
+    glm::vec3 up = orientation * AVATAR_UP;
-    glm::vec3 front = orientation * IDENTITY_FRONT;
+    glm::vec3 front = orientation * AVATAR_FRONT;
 
     for (int t = 0; t < NUM_HAIR_TUFTS; t ++) {
 

interface/src/Head.h

@@ -14,7 +14,6 @@
 #include "world.h"
 #include "InterfaceConfig.h"
 #include "SerialInterface.h"
-#include "Orientation.h"
 #include <SharedUtil.h>
 
 enum eyeContactTargets 
@@ -50,9 +49,9 @@ public:
     glm::quat getOrientation() const;
     glm::quat getWorldAlignedOrientation () const;
     
-    glm::vec3 getRightDirection() const { return getOrientation() * IDENTITY_RIGHT; }
+    glm::vec3 getRightDirection() const { return getOrientation() * AVATAR_RIGHT; }
-    glm::vec3 getUpDirection   () const { return getOrientation() * IDENTITY_UP;    }
+    glm::vec3 getUpDirection   () const { return getOrientation() * AVATAR_UP;    }
-    glm::vec3 getFrontDirection() const { return getOrientation() * IDENTITY_FRONT; }
+    glm::vec3 getFrontDirection() const { return getOrientation() * AVATAR_FRONT; }
     
     const bool getReturnToCenter() const { return _returnHeadToCenter; } // Do you want head to try to return to center (depends on interface detected)
     float getAverageLoudness() {return _averageLoudness;};

libraries/avatars/src/AvatarData.h

@@ -20,6 +20,11 @@ const int WANT_RESIN_AT_BIT = 0;
 const int WANT_COLOR_AT_BIT = 1;
 const int WANT_DELTA_AT_BIT = 2;
 
+// this is where the coordinate system is represented
+const glm::vec3 AVATAR_RIGHT = glm::vec3(1.0f, 0.0f, 0.0f);
+const glm::vec3 AVATAR_UP    = glm::vec3(0.0f, 1.0f, 0.0f);
+const glm::vec3 AVATAR_FRONT = glm::vec3(0.0f, 0.0f, -1.0f);
+
 enum KeyState
 {
     NO_KEY_DOWN,