Merge pull request #2549 from AndrewMeadows/avatar-interaction

name changes to get rid of "tweaked" angles in Head code

interface/src/Audio.cpp

@@ -522,7 +522,7 @@ void Audio::handleAudioInput() {
         if (audioMixer && audioMixer->getActiveSocket()) {
             MyAvatar* interfaceAvatar = Application::getInstance()->getAvatar();
             glm::vec3 headPosition = interfaceAvatar->getHead()->getPosition();
-            glm::quat headOrientation = interfaceAvatar->getHead()->getTweakedOrientation();
+            glm::quat headOrientation = interfaceAvatar->getHead()->getFinalOrientation();
 
             // we need the amount of bytes in the buffer + 1 for type
             // + 12 for 3 floats for position + float for bearing + 1 attenuation byte

interface/src/avatar/FaceModel.cpp

@@ -50,9 +50,9 @@ void FaceModel::maybeUpdateNeckRotation(const JointState& parentState, const FBX
     glm::mat3 axes = glm::mat3_cast(_rotation);
     glm::mat3 inverse = glm::mat3(glm::inverse(parentState.transform * glm::translate(state.translation) *
         joint.preTransform * glm::mat4_cast(joint.preRotation)));
-    state.rotation = glm::angleAxis(- RADIANS_PER_DEGREE * _owningHead->getTweakedRoll(), glm::normalize(inverse * axes[2])) 
+    state.rotation = glm::angleAxis(- RADIANS_PER_DEGREE * _owningHead->getFinalRoll(), glm::normalize(inverse * axes[2])) 
-        * glm::angleAxis(RADIANS_PER_DEGREE * _owningHead->getTweakedYaw(), glm::normalize(inverse * axes[1])) 
+        * glm::angleAxis(RADIANS_PER_DEGREE * _owningHead->getFinalYaw(), glm::normalize(inverse * axes[1])) 
-        * glm::angleAxis(- RADIANS_PER_DEGREE * _owningHead->getTweakedPitch(), glm::normalize(inverse * axes[0])) 
+        * glm::angleAxis(- RADIANS_PER_DEGREE * _owningHead->getFinalPitch(), glm::normalize(inverse * axes[0])) 
         * joint.rotation;
 }
 
@@ -60,7 +60,7 @@ void FaceModel::maybeUpdateEyeRotation(const JointState& parentState, const FBXJ
     // likewise with the eye joints
     glm::mat4 inverse = glm::inverse(parentState.transform * glm::translate(state.translation) *
         joint.preTransform * glm::mat4_cast(joint.preRotation * joint.rotation));
-    glm::vec3 front = glm::vec3(inverse * glm::vec4(_owningHead->getTweakedOrientation() * IDENTITY_FRONT, 0.0f));
+    glm::vec3 front = glm::vec3(inverse * glm::vec4(_owningHead->getFinalOrientation() * IDENTITY_FRONT, 0.0f));
     glm::vec3 lookAt = glm::vec3(inverse * glm::vec4(_owningHead->getLookAtPosition() +
         _owningHead->getSaccade() - _translation, 1.0f));
     glm::quat between = rotationBetween(front, lookAt);

interface/src/avatar/Head.cpp

@@ -36,9 +36,9 @@ Head::Head(Avatar* owningAvatar) :
     _leftEyeBlinkVelocity(0.0f),
     _rightEyeBlinkVelocity(0.0f),
     _timeWithoutTalking(0.0f),
-    _pitchTweak(0.f),
+    _deltaPitch(0.f),
-    _yawTweak(0.f),
+    _deltaYaw(0.f),
-    _rollTweak(0.f),
+    _deltaRoll(0.f),
     _isCameraMoving(false),
     _faceModel(this)
 {
@@ -50,7 +50,7 @@ void Head::init() {
 }
 
 void Head::reset() {
-    _yaw = _pitch = _roll = 0.0f;
+    _baseYaw = _basePitch = _baseRoll = 0.0f;
     _leanForward = _leanSideways = 0.0f;
     _faceModel.reset();
 }
@@ -178,14 +178,14 @@ void Head::setScale (float scale) {
     _scale = scale;
 }
 
-glm::quat Head::getTweakedOrientation() const {
+glm::quat Head::getFinalOrientation() const {
     return _owningAvatar->getOrientation() * glm::quat(glm::radians(
-                glm::vec3(getTweakedPitch(), getTweakedYaw(), getTweakedRoll() )));
+                glm::vec3(getFinalPitch(), getFinalYaw(), getFinalRoll() )));
 }
 
 glm::quat Head::getCameraOrientation () const {
     Avatar* owningAvatar = static_cast<Avatar*>(_owningAvatar);
-    return owningAvatar->getWorldAlignedOrientation() * glm::quat(glm::radians(glm::vec3(_pitch, 0.f, 0.0f)));
+    return owningAvatar->getWorldAlignedOrientation() * glm::quat(glm::radians(glm::vec3(_basePitch, 0.f, 0.0f)));
 }
 
 glm::quat Head::getEyeRotation(const glm::vec3& eyePosition) const {
@@ -197,16 +197,16 @@ glm::vec3 Head::getScalePivot() const {
     return _faceModel.isActive() ? _faceModel.getTranslation() : _position;
 }
 
-float Head::getTweakedYaw() const {
+float Head::getFinalYaw() const {
-    return glm::clamp(_yaw + _yawTweak, MIN_HEAD_YAW, MAX_HEAD_YAW);
+    return glm::clamp(_baseYaw + _deltaYaw, MIN_HEAD_YAW, MAX_HEAD_YAW);
 }
 
-float Head::getTweakedPitch() const {
+float Head::getFinalPitch() const {
-    return glm::clamp(_pitch + _pitchTweak, MIN_HEAD_PITCH, MAX_HEAD_PITCH);
+    return glm::clamp(_basePitch + _deltaPitch, MIN_HEAD_PITCH, MAX_HEAD_PITCH);
 }
 
-float Head::getTweakedRoll() const {
+float Head::getFinalRoll() const {
-    return glm::clamp(_roll + _rollTweak, MIN_HEAD_ROLL, MAX_HEAD_ROLL);
+    return glm::clamp(_baseRoll + _deltaRoll, MIN_HEAD_ROLL, MAX_HEAD_ROLL);
 }
 
 void Head::renderLookatVectors(glm::vec3 leftEyePosition, glm::vec3 rightEyePosition, glm::vec3 lookatPosition) {

interface/src/avatar/Head.h

@@ -45,8 +45,12 @@ public:
     void setReturnToCenter (bool returnHeadToCenter) { _returnHeadToCenter = returnHeadToCenter; }
     void setRenderLookatVectors(bool onOff) { _renderLookatVectors = onOff; }
     
-    glm::quat getTweakedOrientation() const;
+    /// \return orientationBody * orientationBase+Delta
+    glm::quat getFinalOrientation() const;
+
+    /// \return orientationBody * orientationBasePitch
     glm::quat getCameraOrientation () const;
+
     const glm::vec3& getAngularVelocity() const { return _angularVelocity; }
     void setAngularVelocity(glm::vec3 angularVelocity) { _angularVelocity = angularVelocity; }
     
@@ -70,18 +74,18 @@ public:
     /// Returns the point about which scaling occurs.
     glm::vec3 getScalePivot() const;
 
-    void setPitchTweak(float pitch) { _pitchTweak = pitch; }
+    void setDeltaPitch(float pitch) { _deltaPitch = pitch; }
-    float getPitchTweak() const { return _pitchTweak; }
+    float getDeltaPitch() const { return _deltaPitch; }
 
-    void setYawTweak(float yaw) { _yawTweak = yaw; }
+    void setDeltaYaw(float yaw) { _deltaYaw = yaw; }
-    float getYawTweak() const { return _yawTweak; }
+    float getDeltaYaw() const { return _deltaYaw; }
     
-    void setRollTweak(float roll) { _rollTweak = roll; }
+    void setDeltaRoll(float roll) { _deltaRoll = roll; }
-    float getRollTweak() const { return _rollTweak; }
+    float getDeltaRoll() const { return _deltaRoll; }
     
-    virtual float getTweakedPitch() const;
+    virtual float getFinalPitch() const;
-    virtual float getTweakedYaw() const;
+    virtual float getFinalYaw() const;
-    virtual float getTweakedRoll() const;
+    virtual float getFinalRoll() const;
     
 private:
     // disallow copies of the Head, copy of owning Avatar is disallowed too
@@ -106,10 +110,10 @@ private:
     float _rightEyeBlinkVelocity;
     float _timeWithoutTalking;
 
-    // tweaked angles affect the rendered head, but not the camera
+    // delta angles for local head rotation
-    float _pitchTweak;
+    float _deltaPitch;
-    float _yawTweak;
+    float _deltaYaw;
-    float _rollTweak;
+    float _deltaRoll;
 
     bool _isCameraMoving;
     FaceModel _faceModel;

interface/src/avatar/MyAvatar.cpp

@@ -118,9 +118,9 @@ void MyAvatar::update(float deltaTime) {
         OculusManager::getEulerAngles(yaw, pitch, roll);
 
         // but these euler angles are stored in degrees
-        head->setYaw(yaw * DEGREES_PER_RADIAN);
+        head->setBaseYaw(yaw * DEGREES_PER_RADIAN);
-        head->setPitch(pitch * DEGREES_PER_RADIAN);
+        head->setBasePitch(pitch * DEGREES_PER_RADIAN);
-        head->setRoll(roll * DEGREES_PER_RADIAN);
+        head->setBaseRoll(roll * DEGREES_PER_RADIAN);
     }
 
     //  Get audio loudness data from audio input device
@@ -230,7 +230,7 @@ void MyAvatar::simulate(float deltaTime) {
 
     if (!Application::getInstance()->getFaceshift()->isActive() && OculusManager::isConnected() &&
             fabsf(forwardAcceleration) > OCULUS_ACCELERATION_PULL_THRESHOLD &&
-            fabs(getHead()->getYaw()) > OCULUS_YAW_OFFSET_THRESHOLD) {
+            fabs(getHead()->getBaseYaw()) > OCULUS_YAW_OFFSET_THRESHOLD) {
             
         // if we're wearing the oculus
         // and this acceleration is above the pull threshold
@@ -240,7 +240,7 @@ void MyAvatar::simulate(float deltaTime) {
         _bodyYaw = getAbsoluteHeadYaw();
 
         // set the head yaw to zero for this draw
-        getHead()->setYaw(0);
+        getHead()->setBaseYaw(0);
 
         // correct the oculus yaw offset
         OculusManager::updateYawOffset();
@@ -365,9 +365,9 @@ void MyAvatar::updateFromGyros(float deltaTime) {
         // restore rotation, lean to neutral positions
         const float RESTORE_PERIOD = 0.25f;   // seconds
         float restorePercentage = glm::clamp(deltaTime/RESTORE_PERIOD, 0.f, 1.f);
-        head->setPitchTweak(glm::mix(head->getPitchTweak(), 0.0f, restorePercentage));
+        head->setDeltaPitch(glm::mix(head->getDeltaPitch(), 0.0f, restorePercentage));
-        head->setYawTweak(glm::mix(head->getYawTweak(), 0.0f, restorePercentage));
+        head->setDeltaYaw(glm::mix(head->getDeltaYaw(), 0.0f, restorePercentage));
-        head->setRollTweak(glm::mix(head->getRollTweak(), 0.0f, restorePercentage));
+        head->setDeltaRoll(glm::mix(head->getDeltaRoll(), 0.0f, restorePercentage));
         head->setLeanSideways(glm::mix(head->getLeanSideways(), 0.0f, restorePercentage));
         head->setLeanForward(glm::mix(head->getLeanForward(), 0.0f, restorePercentage));
         return;
@@ -378,9 +378,9 @@ void MyAvatar::updateFromGyros(float deltaTime) {
     const float AVATAR_HEAD_PITCH_MAGNIFY = 1.0f;
     const float AVATAR_HEAD_YAW_MAGNIFY = 1.0f;
     const float AVATAR_HEAD_ROLL_MAGNIFY = 1.0f;
-    head->setPitchTweak(estimatedRotation.x * AVATAR_HEAD_PITCH_MAGNIFY);
+    head->setDeltaPitch(estimatedRotation.x * AVATAR_HEAD_PITCH_MAGNIFY);
-    head->setYawTweak(estimatedRotation.y * AVATAR_HEAD_YAW_MAGNIFY);
+    head->setDeltaYaw(estimatedRotation.y * AVATAR_HEAD_YAW_MAGNIFY);
-    head->setRollTweak(estimatedRotation.z * AVATAR_HEAD_ROLL_MAGNIFY);
+    head->setDeltaRoll(estimatedRotation.z * AVATAR_HEAD_ROLL_MAGNIFY);
 
     //  Update torso lean distance based on accelerometer data
     const float TORSO_LENGTH = 0.5f;
@@ -506,7 +506,7 @@ void MyAvatar::saveData(QSettings* settings) {
     settings->setValue("bodyPitch", _bodyPitch);
     settings->setValue("bodyRoll", _bodyRoll);
 
-    settings->setValue("headPitch", getHead()->getPitch());
+    settings->setValue("headPitch", getHead()->getBasePitch());
 
     settings->setValue("position_x", _position.x);
     settings->setValue("position_y", _position.y);
@@ -532,7 +532,7 @@ void MyAvatar::loadData(QSettings* settings) {
     _bodyPitch = loadSetting(settings, "bodyPitch", 0.0f);
     _bodyRoll = loadSetting(settings, "bodyRoll", 0.0f);
 
-    getHead()->setPitch(loadSetting(settings, "headPitch", 0.0f));
+    getHead()->setBasePitch(loadSetting(settings, "headPitch", 0.0f));
 
     _position.x = loadSetting(settings, "position_x", 0.0f);
     _position.y = loadSetting(settings, "position_y", 0.0f);
@@ -575,9 +575,9 @@ void MyAvatar::orbit(const glm::vec3& position, int deltaX, int deltaY) {
     setOrientation(orientation);
     
     // then vertically
-    float oldPitch = getHead()->getPitch();
+    float oldPitch = getHead()->getBasePitch();
-    getHead()->setPitch(oldPitch - deltaY * ANGULAR_SCALE);
+    getHead()->setBasePitch(oldPitch - deltaY * ANGULAR_SCALE);
-    rotation = glm::angleAxis(glm::radians((getHead()->getPitch() - oldPitch)), orientation * IDENTITY_RIGHT);
+    rotation = glm::angleAxis(glm::radians((getHead()->getBasePitch() - oldPitch)), orientation * IDENTITY_RIGHT);
 
     setPosition(position + rotation * (getPosition() - position));
 }
@@ -683,7 +683,7 @@ void MyAvatar::updateThrust(float deltaTime) {
     _thrust -= _driveKeys[DOWN] * _scale * THRUST_MAG_DOWN * _thrustMultiplier * deltaTime * up;
     _bodyYawDelta -= _driveKeys[ROT_RIGHT] * YAW_SPEED * deltaTime;
     _bodyYawDelta += _driveKeys[ROT_LEFT] * YAW_SPEED * deltaTime;
-    getHead()->setPitch(getHead()->getPitch() + (_driveKeys[ROT_UP] - _driveKeys[ROT_DOWN]) * PITCH_SPEED * deltaTime);
+    getHead()->setBasePitch(getHead()->getBasePitch() + (_driveKeys[ROT_UP] - _driveKeys[ROT_DOWN]) * PITCH_SPEED * deltaTime);
 
     //  If thrust keys are being held down, slowly increase thrust to allow reaching great speeds
     if (_driveKeys[FWD] || _driveKeys[BACK] || _driveKeys[RIGHT] || _driveKeys[LEFT] || _driveKeys[UP] || _driveKeys[DOWN]) {

libraries/avatars/src/AvatarData.cpp

@@ -93,9 +93,9 @@ QByteArray AvatarData::toByteArray() {
     destinationBuffer += packFloatRatioToTwoByte(destinationBuffer, _targetScale);
 
     // Head rotation (NOTE: This needs to become a quaternion to save two bytes)
-    destinationBuffer += packFloatAngleToTwoByte(destinationBuffer, _headData->getTweakedYaw());
+    destinationBuffer += packFloatAngleToTwoByte(destinationBuffer, _headData->getFinalYaw());
-    destinationBuffer += packFloatAngleToTwoByte(destinationBuffer, _headData->getTweakedPitch());
+    destinationBuffer += packFloatAngleToTwoByte(destinationBuffer, _headData->getFinalPitch());
-    destinationBuffer += packFloatAngleToTwoByte(destinationBuffer, _headData->getTweakedRoll());
+    destinationBuffer += packFloatAngleToTwoByte(destinationBuffer, _headData->getFinalRoll());
     
     // Head lean X,Z (head lateral and fwd/back motion relative to torso)
     memcpy(destinationBuffer, &_headData->_leanSideways, sizeof(_headData->_leanSideways));
@@ -288,9 +288,9 @@ int AvatarData::parseDataAtOffset(const QByteArray& packet, int offset) {
             }
             return maxAvailableSize;
         }
-        _headData->setYaw(headYaw);
+        _headData->setBaseYaw(headYaw);
-        _headData->setPitch(headPitch);
+        _headData->setBasePitch(headPitch);
-        _headData->setRoll(headRoll);
+        _headData->setBaseRoll(headRoll);
     } // 6 bytes
         
     // Head lean (relative to pelvis)

libraries/avatars/src/AvatarData.h

@@ -128,8 +128,8 @@ public:
     void setHeadOrientation(const glm::quat& orientation) { _headData->setOrientation(orientation); }
 
     // access to Head().set/getMousePitch (degrees)
-    float getHeadPitch() const { return _headData->getPitch(); }
+    float getHeadPitch() const { return _headData->getBasePitch(); }
-    void setHeadPitch(float value) { _headData->setPitch(value); };
+    void setHeadPitch(float value) { _headData->setBasePitch(value); };
 
     // access to Head().set/getAverageLoudness
     float getAudioLoudness() const { return _headData->getAudioLoudness(); }

libraries/avatars/src/HeadData.cpp

@@ -14,9 +14,9 @@
 #include "HeadData.h"
 
 HeadData::HeadData(AvatarData* owningAvatar) :
-    _yaw(0.0f),
+    _baseYaw(0.0f),
-    _pitch(0.0f),
+    _basePitch(0.0f),
-    _roll(0.0f),
+    _baseRoll(0.0f),
     _leanSideways(0.0f),
     _leanForward(0.0f),
     _lookAtPosition(0.0f, 0.0f, 0.0f),
@@ -32,7 +32,7 @@ HeadData::HeadData(AvatarData* owningAvatar) :
 }
 
 glm::quat HeadData::getOrientation() const {
-    return _owningAvatar->getOrientation() * glm::quat(glm::radians(glm::vec3(_pitch, _yaw, _roll)));
+    return _owningAvatar->getOrientation() * glm::quat(glm::radians(glm::vec3(_basePitch, _baseYaw, _baseRoll)));
 }
 
 void HeadData::setOrientation(const glm::quat& orientation) {
@@ -44,21 +44,21 @@ void HeadData::setOrientation(const glm::quat& orientation) {
     
     // the rest goes to the head
     glm::vec3 eulers = glm::degrees(safeEulerAngles(glm::inverse(bodyOrientation) * orientation));
-    _pitch = eulers.x;
+    _basePitch = eulers.x;
-    _yaw = eulers.y;
+    _baseYaw = eulers.y;
-    _roll = eulers.z;
+    _baseRoll = eulers.z;
 }
 
 void HeadData::addYaw(float yaw) {
-    setYaw(_yaw + yaw);
+    setBaseYaw(_baseYaw + yaw);
 }
 
 void HeadData::addPitch(float pitch) {
-    setPitch(_pitch + pitch);
+    setBasePitch(_basePitch + pitch);
 }
 
 void HeadData::addRoll(float roll) {
-    setRoll(_roll + roll);
+    setBaseRoll(_baseRoll + roll);
 }
 
 

libraries/avatars/src/HeadData.h

@@ -36,15 +36,15 @@ public:
     void setLeanSideways(float leanSideways) { _leanSideways = leanSideways; }
     float getLeanForward() const { return _leanForward; }
     void setLeanForward(float leanForward) { _leanForward = leanForward; }
-    float getYaw() const { return _yaw; }
+    float getBaseYaw() const { return _baseYaw; }
-    void setYaw(float yaw) { _yaw = glm::clamp(yaw, MIN_HEAD_YAW, MAX_HEAD_YAW); }
+    void setBaseYaw(float yaw) { _baseYaw = glm::clamp(yaw, MIN_HEAD_YAW, MAX_HEAD_YAW); }
-    float getPitch() const { return _pitch; }
+    float getBasePitch() const { return _basePitch; }
-    void setPitch(float pitch) { _pitch = glm::clamp(pitch, MIN_HEAD_PITCH, MAX_HEAD_PITCH); }
+    void setBasePitch(float pitch) { _basePitch = glm::clamp(pitch, MIN_HEAD_PITCH, MAX_HEAD_PITCH); }
-    float getRoll() const { return _roll; }
+    float getBaseRoll() const { return _baseRoll; }
-    void setRoll(float roll) { _roll = glm::clamp(roll, MIN_HEAD_ROLL, MAX_HEAD_ROLL); }
+    void setBaseRoll(float roll) { _baseRoll = glm::clamp(roll, MIN_HEAD_ROLL, MAX_HEAD_ROLL); }
-    virtual float getTweakedYaw() const { return _yaw; }
+    virtual float getFinalYaw() const { return _baseYaw; }
-    virtual float getTweakedPitch() const { return _pitch; }
+    virtual float getFinalPitch() const { return _basePitch; }
-    virtual float getTweakedRoll() const { return _roll; }
+    virtual float getFinalRoll() const { return _baseRoll; }
 
     glm::quat getOrientation() const;
     void setOrientation(const glm::quat& orientation);
@@ -73,9 +73,9 @@ public:
     
 protected:
     // degrees
-    float _yaw;
+    float _baseYaw;
-    float _pitch;
+    float _basePitch;
-    float _roll;
+    float _baseRoll;
     float _leanSideways;
     float _leanForward;