//-----------------------------------------------------------------------------
// LLTargetingMotion::onUpdate()
//-----------------------------------------------------------------------------
BOOL LLTargetingMotion::onUpdate(F32 time, U8* joint_mask)
{
F32 slerp_amt = LLCriticalDamp::getInterpolant(TORSO_TARGET_HALF_LIFE);
LLVector3 target;
LLVector3* lookAtPoint = (LLVector3*)mCharacter->getAnimationData("LookAtPoint");
BOOL result = TRUE;
if (!lookAtPoint)
{
return TRUE;
}
else
{
target = *lookAtPoint;
target.normVec();
}
//LLVector3 target_plane_normal = LLVector3(1.f, 0.f, 0.f) * mPelvisJoint->getWorldRotation();
//LLVector3 torso_dir = LLVector3(1.f, 0.f, 0.f) * (mTorsoJoint->getWorldRotation() * mTorsoState->getRotation());
LLVector3 skyward(0.f, 0.f, 1.f);
LLVector3 left(skyward % target);
left.normVec();
LLVector3 up(target % left);
up.normVec();
LLQuaternion target_aim_rot(target, left, up);
LLQuaternion cur_torso_rot = mTorsoJoint->getWorldRotation();
LLVector3 right_hand_at = LLVector3(0.f, -1.f, 0.f) * mRightHandJoint->getWorldRotation();
left.setVec(skyward % right_hand_at);
left.normVec();
up.setVec(right_hand_at % left);
up.normVec();
LLQuaternion right_hand_rot(right_hand_at, left, up);
LLQuaternion new_torso_rot = (cur_torso_rot * ~right_hand_rot) * target_aim_rot;
// find ideal additive rotation to make torso point in correct direction
new_torso_rot = new_torso_rot * ~cur_torso_rot;
// slerp from current additive rotation to ideal additive rotation
new_torso_rot = nlerp(slerp_amt, mTorsoState->getRotation(), new_torso_rot);
// constraint overall torso rotation
LLQuaternion total_rot = new_torso_rot * mTorsoJoint->getRotation();
total_rot.constrain(F_PI_BY_TWO * 0.8f);
new_torso_rot = total_rot * ~mTorsoJoint->getRotation();
mTorsoState->setRotation(new_torso_rot);
return result;
}
//-----------------------------------------------------------------------------
// LLEyeMotion::onUpdate()
//-----------------------------------------------------------------------------
BOOL LLEyeMotion::onUpdate(F32 time, U8* joint_mask)
{
// Compute eye rotation.
LLQuaternion target_eye_rot;
LLVector3 eye_look_at;
F32 vergence;
//calculate jitter
if (mEyeJitterTimer.getElapsedTimeF32() > mEyeJitterTime)
{
mEyeJitterTime = EYE_JITTER_MIN_TIME + ll_frand(EYE_JITTER_MAX_TIME - EYE_JITTER_MIN_TIME);
mEyeJitterYaw = (ll_frand(2.f) - 1.f) * EYE_JITTER_MAX_YAW;
mEyeJitterPitch = (ll_frand(2.f) - 1.f) * EYE_JITTER_MAX_PITCH;
// make sure lookaway time count gets updated, because we're resetting the timer
mEyeLookAwayTime -= llmax(0.f, mEyeJitterTimer.getElapsedTimeF32());
mEyeJitterTimer.reset();
}
else if (mEyeJitterTimer.getElapsedTimeF32() > mEyeLookAwayTime)
{
if (ll_frand() > 0.1f)
{
// blink while moving eyes some percentage of the time
mEyeBlinkTime = mEyeBlinkTimer.getElapsedTimeF32();
}
if (mEyeLookAwayYaw == 0.f && mEyeLookAwayPitch == 0.f)
{
mEyeLookAwayYaw = (ll_frand(2.f) - 1.f) * EYE_LOOK_AWAY_MAX_YAW;
mEyeLookAwayPitch = (ll_frand(2.f) - 1.f) * EYE_LOOK_AWAY_MAX_PITCH;
mEyeLookAwayTime = EYE_LOOK_BACK_MIN_TIME + ll_frand(EYE_LOOK_BACK_MAX_TIME - EYE_LOOK_BACK_MIN_TIME);
}
else
{
mEyeLookAwayYaw = 0.f;
mEyeLookAwayPitch = 0.f;
mEyeLookAwayTime = EYE_LOOK_AWAY_MIN_TIME + ll_frand(EYE_LOOK_AWAY_MAX_TIME - EYE_LOOK_AWAY_MIN_TIME);
}
}
// do blinking
if (!mEyesClosed && mEyeBlinkTimer.getElapsedTimeF32() >= mEyeBlinkTime)
{
F32 leftEyeBlinkMorph = mEyeBlinkTimer.getElapsedTimeF32() - mEyeBlinkTime;
F32 rightEyeBlinkMorph = leftEyeBlinkMorph - EYE_BLINK_TIME_DELTA;
leftEyeBlinkMorph = llclamp(leftEyeBlinkMorph / EYE_BLINK_SPEED, 0.f, 1.f);
rightEyeBlinkMorph = llclamp(rightEyeBlinkMorph / EYE_BLINK_SPEED, 0.f, 1.f);
mCharacter->setVisualParamWeight("Blink_Left", leftEyeBlinkMorph);
mCharacter->setVisualParamWeight("Blink_Right", rightEyeBlinkMorph);
mCharacter->updateVisualParams();
if (rightEyeBlinkMorph == 1.f)
{
mEyesClosed = TRUE;
mEyeBlinkTime = EYE_BLINK_CLOSE_TIME;
mEyeBlinkTimer.reset();
}
}
else if (mEyesClosed)
{
if (mEyeBlinkTimer.getElapsedTimeF32() >= mEyeBlinkTime)
{
F32 leftEyeBlinkMorph = mEyeBlinkTimer.getElapsedTimeF32() - mEyeBlinkTime;
F32 rightEyeBlinkMorph = leftEyeBlinkMorph - EYE_BLINK_TIME_DELTA;
leftEyeBlinkMorph = 1.f - llclamp(leftEyeBlinkMorph / EYE_BLINK_SPEED, 0.f, 1.f);
rightEyeBlinkMorph = 1.f - llclamp(rightEyeBlinkMorph / EYE_BLINK_SPEED, 0.f, 1.f);
mCharacter->setVisualParamWeight("Blink_Left", leftEyeBlinkMorph);
mCharacter->setVisualParamWeight("Blink_Right", rightEyeBlinkMorph);
mCharacter->updateVisualParams();
if (rightEyeBlinkMorph == 0.f)
{
mEyesClosed = FALSE;
mEyeBlinkTime = EYE_BLINK_MIN_TIME + ll_frand(EYE_BLINK_MAX_TIME - EYE_BLINK_MIN_TIME);
mEyeBlinkTimer.reset();
}
}
}
BOOL has_eye_target = FALSE;
LLVector3* targetPos = (LLVector3*)mCharacter->getAnimationData("LookAtPoint");
if (targetPos)
{
LLVector3 skyward(0.f, 0.f, 1.f);
LLVector3 left;
LLVector3 up;
eye_look_at = *targetPos;
has_eye_target = TRUE;
F32 lookAtDistance = eye_look_at.normVec();
left.setVec(skyward % eye_look_at);
up.setVec(eye_look_at % left);
target_eye_rot = LLQuaternion(eye_look_at, left, up);
// convert target rotation to head-local coordinates
target_eye_rot *= ~mHeadJoint->getWorldRotation();
// eliminate any Euler roll - we're lucky that roll is applied last.
F32 roll, pitch, yaw;
target_eye_rot.getEulerAngles(&roll, &pitch, &yaw);
target_eye_rot.setQuat(0.0f, pitch, yaw);
// constrain target orientation to be in front of avatar's face
target_eye_rot.constrain(EYE_ROT_LIMIT_ANGLE);
// calculate vergence
F32 interocular_dist = (mLeftEyeState->getJoint()->getWorldPosition() - mRightEyeState->getJoint()->getWorldPosition()).magVec();
vergence = -atan2((interocular_dist / 2.f), lookAtDistance);
llclamp(vergence, -F_PI_BY_TWO, 0.f);
}
else
{
target_eye_rot = LLQuaternion::DEFAULT;
vergence = 0.f;
}
//RN: subtract 4 degrees to account for foveal angular offset relative to pupil
vergence += 4.f * DEG_TO_RAD;
// calculate eye jitter
LLQuaternion eye_jitter_rot;
// vergence not too high...
if (vergence > -0.05f)
{
//...go ahead and jitter
eye_jitter_rot.setQuat(0.f, mEyeJitterPitch + mEyeLookAwayPitch, mEyeJitterYaw + mEyeLookAwayYaw);
}
else
{
//...or don't
eye_jitter_rot.loadIdentity();
}
// calculate vergence of eyes as an object gets closer to the avatar's head
LLQuaternion vergence_quat;
if (has_eye_target)
{
vergence_quat.setQuat(vergence, LLVector3(0.f, 0.f, 1.f));
}
else
{
vergence_quat.loadIdentity();
}
// calculate eye rotations
LLQuaternion left_eye_rot = target_eye_rot;
left_eye_rot = vergence_quat * eye_jitter_rot * left_eye_rot;
LLQuaternion right_eye_rot = target_eye_rot;
vergence_quat.transQuat();
right_eye_rot = vergence_quat * eye_jitter_rot * right_eye_rot;
//if in appearance, set the eyes straight forward
if(mCharacter->getAppearanceFlag()) // no idea why this variable is reversed
{
LLVector3 forward(1.f, 0.0, 0.0);
LLVector3 left;
LLVector3 up;
left.setVec(forward % forward);
up.setVec(forward % left);
target_eye_rot = LLQuaternion(forward, left, up);
mLeftEyeState->setRotation( target_eye_rot );
mRightEyeState->setRotation( target_eye_rot );
return TRUE;
}
mLeftEyeState->setRotation( left_eye_rot );
mRightEyeState->setRotation( right_eye_rot );
return TRUE;
}
