/** * @file llhudeffectlookat.cpp * @brief LLHUDEffectLookAt class implementation * * $LicenseInfo:firstyear=2002&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, Linden Research, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ #include "llviewerprecompiledheaders.h" #include "llhudeffectlookat.h" #include "llrender.h" #include "message.h" #include "llagent.h" #include "llagentcamera.h" #include "llvoavatar.h" #include "lldrawable.h" #include "llviewerobjectlist.h" #include "llviewercontrol.h" #include "llvoavatarself.h" #include "llrendersphere.h" #include "llselectmgr.h" #include "llglheaders.h" #include "llhudrender.h" #include "llresmgr.h" #include "llviewerwindow.h" #include "llavatarnamecache.h" #include "llxmltree.h" #include "llviewercontrol.h" // [RLVa:KC] - Firestrom specific #include "rlvhandler.h" // [/RLVa:KC] //bool LLHUDEffectLookAt::sDebugLookAt = false; // packet layout const S32 SOURCE_AVATAR = 0; const S32 TARGET_OBJECT = 16; const S32 TARGET_POS = 32; const S32 LOOKAT_TYPE = 56; const S32 PKT_SIZE = 57; // throttle const F32 MAX_SENDS_PER_SEC = 4.f; const F32 MIN_DELTAPOS_FOR_UPDATE_SQUARED = 0.05f * 0.05f; const F32 MIN_TARGET_OFFSET_SQUARED = 0.0001f; // can't use actual F32_MAX, because we add this to the current frametime const F32 MAX_TIMEOUT = F32_MAX / 2.f; /** * Simple data class holding values for a particular type of attention. */ class LLAttention { public: LLAttention() : mTimeout(0.f), mPriority(0.f) {} LLAttention(F32 timeout, F32 priority, const std::string& name, LLColor3 color) : mTimeout(timeout), mPriority(priority), mName(name), mColor(color) { } F32 mTimeout, mPriority; std::string mName; LLColor3 mColor; }; /** * Simple data class holding a list of attentions, one for every type. */ class LLAttentionSet { public: LLAttentionSet(const LLAttention attentions[]) { for(int i=0; igetAttributeString("name", str); LLAttentionSet& attentions = (str.compare("Masculine") == 0) ? gBoyAttentions : gGirlAttentions; for (LLXmlTreeNode* attention_node = gender->getChildByName( "param" ); attention_node; attention_node = gender->getNextNamedChild()) { attention_node->getAttributeString("attention", str); LLAttention* attention; if (str == "idle") attention = &attentions[LOOKAT_TARGET_IDLE]; else if(str == "auto_listen") attention = &attentions[LOOKAT_TARGET_AUTO_LISTEN]; else if(str == "freelook") attention = &attentions[LOOKAT_TARGET_FREELOOK]; else if(str == "respond") attention = &attentions[LOOKAT_TARGET_RESPOND]; else if(str == "hover") attention = &attentions[LOOKAT_TARGET_HOVER]; else if(str == "conversation") attention = &attentions[LOOKAT_TARGET_CONVERSATION]; else if(str == "select") attention = &attentions[LOOKAT_TARGET_SELECT]; else if(str == "focus") attention = &attentions[LOOKAT_TARGET_FOCUS]; else if(str == "mouselook") attention = &attentions[LOOKAT_TARGET_MOUSELOOK]; else return false; F32 priority, timeout; attention_node->getAttributeF32("priority", priority); attention_node->getAttributeF32("timeout", timeout); if(timeout < 0) timeout = MAX_TIMEOUT; attention->mPriority = priority; attention->mTimeout = timeout; } return true; } static bool loadAttentions() { static bool first_time = true; if( ! first_time) { return true; // maybe not ideal but otherwise it can continue to fail forever. } first_time = false; std::string filename; filename = gDirUtilp->getExpandedFilename(LL_PATH_CHARACTER,"attentions.xml"); LLXmlTree xml_tree; bool success = xml_tree.parseFile( filename, false ); if( !success ) { return false; } LLXmlTreeNode* root = xml_tree.getRoot(); if( !root ) { return false; } //------------------------------------------------------------------------- // (root) //------------------------------------------------------------------------- if( !root->hasName( "linden_attentions" ) ) { LL_WARNS() << "Invalid linden_attentions file header: " << filename << LL_ENDL; return false; } std::string version; static LLStdStringHandle version_string = LLXmlTree::addAttributeString("version"); if( !root->getFastAttributeString( version_string, version ) || (version != "1.0") ) { LL_WARNS() << "Invalid linden_attentions file version: " << version << LL_ENDL; return false; } //------------------------------------------------------------------------- // //------------------------------------------------------------------------- for (LLXmlTreeNode* child = root->getChildByName( "gender" ); child; child = root->getNextNamedChild()) { if( !loadGender( child ) ) { return false; } } return true; } //----------------------------------------------------------------------------- // LLHUDEffectLookAt() //----------------------------------------------------------------------------- LLHUDEffectLookAt::LLHUDEffectLookAt(const U8 type) : LLHUDEffect(type), mKillTime(0.f), mLastSendTime(0.f), // //mDebugLookAt( LLCachedControl(gSavedPerAccountSettings, "DebugLookAt", false)) mDebugLookAt( LLCachedControl(gSavedPerAccountSettings, "DebugLookAt", 0)) // { clearLookAtTarget(); // parse the default sets loadAttentions(); // initialize current attention set. switches when avatar sex changes. mAttentions = &gGirlAttentions; } //----------------------------------------------------------------------------- // ~LLHUDEffectLookAt() //----------------------------------------------------------------------------- LLHUDEffectLookAt::~LLHUDEffectLookAt() { } //----------------------------------------------------------------------------- // packData() //----------------------------------------------------------------------------- void LLHUDEffectLookAt::packData(LLMessageSystem *mesgsys) { // pack both target object and position // position interpreted as offset if target object is non-null ELookAtType target_type = mTargetType; LLVector3d target_offset_global = mTargetOffsetGlobal; LLViewerObject* target_object = (LLViewerObject*)mTargetObject; LLViewerObject* source_object = (LLViewerObject*)mSourceObject; LLVOAvatar* source_avatar = NULL; if (!source_object) //kokua TODO: find out why this happens at all and fix there { LL_DEBUGS("HUDEffect") << "NULL-Object HUDEffectLookAt message" << LL_ENDL; markDead(); return; } if (source_object->isAvatar()) { source_avatar = (LLVOAvatar*)source_object; } else //AW: TODO: find out why this happens at all and fix there { LL_DEBUGS("HUDEffect") << "Non-Avatar HUDEffectLookAt message for ID: " << source_object->getID().asString() << LL_ENDL; markDead(); return; } bool is_self = source_avatar && source_avatar->isSelf(); static LLCachedControl is_private(gSavedSettings, "PrivateLookAtTarget", false); static LLCachedControl isLocalPrivate(gSavedSettings, "PrivateLocalLookAtTarget", false); if (!is_self) //AW: TODO: find out why this happens at all and fix there { LL_DEBUGS("HUDEffect") << "Non-self Avatar HUDEffectLookAt message for ID: " << source_avatar->getID().asString() << LL_ENDL; markDead(); return; } else if (isLocalPrivate && is_private) // AO: send nothing if we're not showing anything ourselves { markDead(); return; } else if (is_private && target_type != LOOKAT_TARGET_AUTO_LISTEN) // AW: spoof boring lookat target to others if we still want real local effects. { //this mimicks "do nothing" target_type = LOOKAT_TARGET_AUTO_LISTEN; target_offset_global.setVec(2.5, 0.0, 0.0); target_object = mSourceObject; } // Pack the default data LLHUDEffect::packData(mesgsys); // Pack the type-specific data. Uses a fun packed binary format. Whee! U8 packed_data[PKT_SIZE]; memset(packed_data, 0, PKT_SIZE); if (mSourceObject) { htolememcpy(&(packed_data[SOURCE_AVATAR]), mSourceObject->mID.mData, MVT_LLUUID, 16); } else { htolememcpy(&(packed_data[SOURCE_AVATAR]), LLUUID::null.mData, MVT_LLUUID, 16); } // pack both target object and position // position interpreted as offset if target object is non-null if (mTargetObject) { htolememcpy(&(packed_data[TARGET_OBJECT]), target_object->mID.mData, MVT_LLUUID, 16); } else { htolememcpy(&(packed_data[TARGET_OBJECT]), LLUUID::null.mData, MVT_LLUUID, 16); } htolememcpy(&(packed_data[TARGET_POS]), target_offset_global.mdV, MVT_LLVector3d, 24); U8 lookAtTypePacked = (U8)target_type; htolememcpy(&(packed_data[LOOKAT_TYPE]), &lookAtTypePacked, MVT_U8, 1); mesgsys->addBinaryDataFast(_PREHASH_TypeData, packed_data, PKT_SIZE); mLastSendTime = mTimer.getElapsedTimeF32(); } //----------------------------------------------------------------------------- // unpackData() //----------------------------------------------------------------------------- void LLHUDEffectLookAt::unpackData(LLMessageSystem *mesgsys, S32 blocknum) { LLVector3d new_target; U8 packed_data[PKT_SIZE]; LLUUID dataId; mesgsys->getUUIDFast(_PREHASH_Effect, _PREHASH_ID, dataId, blocknum); if (!gAgentCamera.mLookAt.isNull() && dataId == gAgentCamera.mLookAt->getID()) { return; } LLHUDEffect::unpackData(mesgsys, blocknum); LLUUID source_id; LLUUID target_id; S32 size = mesgsys->getSizeFast(_PREHASH_Effect, blocknum, _PREHASH_TypeData); if (size != PKT_SIZE) { LL_WARNS() << "LookAt effect with bad size " << size << LL_ENDL; return; } mesgsys->getBinaryDataFast(_PREHASH_Effect, _PREHASH_TypeData, packed_data, PKT_SIZE, blocknum); htolememcpy(source_id.mData, &(packed_data[SOURCE_AVATAR]), MVT_LLUUID, 16); LLViewerObject *objp = gObjectList.findObject(source_id); if (objp && objp->isAvatar()) { setSourceObject(objp); } else { //LL_WARNS() << "Could not find source avatar for lookat effect" << LL_ENDL; return; } htolememcpy(target_id.mData, &(packed_data[TARGET_OBJECT]), MVT_LLUUID, 16); objp = gObjectList.findObject(target_id); htolememcpy(new_target.mdV, &(packed_data[TARGET_POS]), MVT_LLVector3d, 24); if (objp) { setTargetObjectAndOffset(objp, new_target); } else if (target_id.isNull()) { setTargetPosGlobal(new_target); } else { //LL_WARNS() << "Could not find target object for lookat effect" << LL_ENDL; } U8 lookAtTypeUnpacked = 0; htolememcpy(&lookAtTypeUnpacked, &(packed_data[LOOKAT_TYPE]), MVT_U8, 1); if ((U8)LOOKAT_NUM_TARGETS > lookAtTypeUnpacked) { mTargetType = (ELookAtType)lookAtTypeUnpacked; } else { mTargetType = LOOKAT_TARGET_NONE; LL_DEBUGS("HUDEffect") << "Invalid target type: " << lookAtTypeUnpacked << LL_ENDL; } if (mTargetType == LOOKAT_TARGET_NONE) { clearLookAtTarget(); } } //----------------------------------------------------------------------------- // setTargetObjectAndOffset() //----------------------------------------------------------------------------- void LLHUDEffectLookAt::setTargetObjectAndOffset(LLViewerObject *objp, LLVector3d offset) { mTargetObject = objp; mTargetOffsetGlobal = offset; } //----------------------------------------------------------------------------- // setTargetPosGlobal() //----------------------------------------------------------------------------- void LLHUDEffectLookAt::setTargetPosGlobal(const LLVector3d &target_pos_global) { mTargetObject = NULL; mTargetOffsetGlobal = target_pos_global; } //----------------------------------------------------------------------------- // setLookAt() // called by agent logic to set look at behavior locally, and propagate to sim //----------------------------------------------------------------------------- bool LLHUDEffectLookAt::setLookAt(ELookAtType target_type, LLViewerObject *object, LLVector3 position) { if (!mSourceObject) { return false; } // Prefer custom FS lookat privacy code //static LLCachedControl enable_lookat_hints(gSavedSettings, "EnableLookAtTarget", true); //if (!enable_lookat_hints) //{ // // Clear the effect so it doesn't linger around if it gets disabled // if (mTargetType != LOOKAT_TARGET_IDLE) // { // mTargetObject = gAgentAvatarp; // mTargetType = LOOKAT_TARGET_IDLE; // mTargetOffsetGlobal.set(2.f, 0.f, 0.f); // setDuration(3.f); // setNeedsSendToSim(true); // } // return false; //} // if (target_type >= LOOKAT_NUM_TARGETS) { LL_WARNS() << "Bad target_type " << (int)target_type << " - ignoring." << LL_ENDL; return false; } // must be same or higher priority than existing effect if ((*mAttentions)[target_type].mPriority < (*mAttentions)[mTargetType].mPriority) { return false; } // Prefer custom FS lookat privacy code //static LLCachedControl limit_lookat_hints(gSavedSettings, "LimitLookAtTarget", true); //// Don't affect the look at if object is gAgentAvatarp (cursor head follow) //if (limit_lookat_hints && object != gAgentAvatarp) //{ // // If it is a object // if (object) // { // position += object->getRenderPosition(); // object = NULL; // } // LLVector3 agentHeadPosition = gAgentAvatarp->mHeadp->getWorldPosition(); // float dist = (float)dist_vec(agentHeadPosition, position); // static LLCachedControl limit_lookat_hints_distance(gSavedSettings, "LimitLookAtTargetDistance", 2.0f); // if (dist > limit_lookat_hints_distance) // { // LLVector3 headOffset = position - agentHeadPosition; // headOffset *= limit_lookat_hints_distance / dist; // position.setVec(agentHeadPosition + headOffset); // } //} // F32 current_time = mTimer.getElapsedTimeF32(); // FIRE-23524 Option to limit look at target to a sphere around the avatar's head. //// type of lookat behavior or target object has changed //bool lookAtChanged = (target_type != mTargetType) || (object != mTargetObject); //// lookat position has moved a certain amount and we haven't just sent an update //lookAtChanged = lookAtChanged || ((dist_vec_squared(position, mLastSentOffsetGlobal) > MIN_DELTAPOS_FOR_UPDATE_SQUARED) && // ((current_time - mLastSendTime) > (1.f / MAX_SENDS_PER_SEC))); //if (lookAtChanged) //{ // mLastSentOffsetGlobal = position; // F32 timeout = (*mAttentions)[target_type].mTimeout; // setDuration(timeout); // setNeedsSendToSim(true); //} // //if (target_type == LOOKAT_TARGET_CLEAR) //{ // clearLookAtTarget(); //} //else //{ // mTargetType = target_type; // mTargetObject = object; // if (object) // { // mTargetOffsetGlobal.setVec(position); // } // else // { // mTargetOffsetGlobal = gAgent.getPosGlobalFromAgent(position); // } //} static LLCachedControl s_EnableLimiter(gSavedSettings, "FSLookAtTargetLimitDistance"); bool lookAtShouldClamp = s_EnableLimiter && (*mAttentions)[mTargetType].mName != "None" && (*mAttentions)[mTargetType].mName != "Idle" && (*mAttentions)[mTargetType].mName != "Respond" && (*mAttentions)[mTargetType].mName != "Conversation" && (*mAttentions)[mTargetType].mName != "FreeLook" && (*mAttentions)[mTargetType].mName != "AutoListen"; if (!lookAtShouldClamp) //We do a similar but seperate calculation if we are doing limited distances { // type of lookat behavior or target object has changed bool lookAtChanged = (target_type != mTargetType) || (object != mTargetObject); // lookat position has moved a certain amount and we haven't just sent an update lookAtChanged = lookAtChanged || ((dist_vec_squared(position, mLastSentOffsetGlobal) > MIN_DELTAPOS_FOR_UPDATE_SQUARED) && ((current_time - mLastSendTime) > (1.f / MAX_SENDS_PER_SEC))); if (lookAtChanged) { mLastSentOffsetGlobal = position; F32 timeout = (*mAttentions)[target_type].mTimeout; setDuration(timeout); setNeedsSendToSim(true); } } if (target_type == LOOKAT_TARGET_CLEAR) { clearLookAtTarget(); } else { mTargetType = target_type; mTargetObject = object; if (object) { if (lookAtShouldClamp) { if (object->isAvatar()) { if (auto avatar = static_cast(object); !avatar->isSelf()) { // Looking at another avatar, have to aim at its head here since calcTargetPosition() doesn't do it anymore because we clear mTargetObject mTargetOffsetGlobal.setVec(gAgent.getPosGlobalFromAgent(avatar->mHeadp->getWorldPosition())); mTargetObject = nullptr; } else { // Continue normal when looking at ourself - lookat will be within the limit anyway mTargetOffsetGlobal.setVec(position); } } else { mTargetOffsetGlobal.setVec(object->getPositionGlobal() + (LLVector3d)(position * object->getRotationRegion())); mTargetObject = nullptr; } } else { mTargetOffsetGlobal.setVec(position); } } else { mTargetOffsetGlobal = gAgent.getPosGlobalFromAgent(position); } if (lookAtShouldClamp && !mTargetObject) { static LLCachedControl s_Radius(gSavedSettings, "FSLookAtTargetMaxDistance"); LLVector3d headPosition = gAgent.getPosGlobalFromAgent(gAgentAvatarp->mHeadp->getWorldPosition()); float distance = (float)dist_vec(mTargetOffsetGlobal, headPosition); if (distance > s_Radius) { LLVector3d vecDistFromObjectToHead = mTargetOffsetGlobal - headPosition; vecDistFromObjectToHead *= s_Radius / distance; mTargetOffsetGlobal.setVec(headPosition + vecDistFromObjectToHead); } //Do the changed calculation except this time for limited distances // type of lookat behavior or target object has changed bool lookAtChanged = (target_type != mTargetType); // lookat position has moved a certain amount and we haven't just sent an update lookAtChanged = lookAtChanged || ((dist_vec_squared(gAgent.getPosAgentFromGlobal(mTargetOffsetGlobal), mLastSentOffsetGlobal) > MIN_DELTAPOS_FOR_UPDATE_SQUARED) && ((current_time - mLastSendTime) > (1.f / MAX_SENDS_PER_SEC))); if (lookAtChanged) { mLastSentOffsetGlobal = gAgent.getPosAgentFromGlobal(mTargetOffsetGlobal); F32 timeout = (*mAttentions)[target_type].mTimeout; setDuration(timeout); setNeedsSendToSim(true); } } // FIRE-23524 Option to limit look at target to a sphere around the avatar's head. mKillTime = mTimer.getElapsedTimeF32() + mDuration; update(); } return true; } //----------------------------------------------------------------------------- // clearLookAtTarget() //----------------------------------------------------------------------------- void LLHUDEffectLookAt::clearLookAtTarget() { mTargetObject = NULL; mTargetOffsetGlobal.clearVec(); mTargetType = LOOKAT_TARGET_NONE; if (mSourceObject.notNull()) { ((LLVOAvatar*)(LLViewerObject*)mSourceObject)->stopMotion(ANIM_AGENT_HEAD_ROT); } } //----------------------------------------------------------------------------- // markDead() //----------------------------------------------------------------------------- void LLHUDEffectLookAt::markDead() { if (mSourceObject.notNull()) { ((LLVOAvatar*)(LLViewerObject*)mSourceObject)->removeAnimationData("LookAtPoint"); } mSourceObject = NULL; clearLookAtTarget(); LLHUDEffect::markDead(); } void LLHUDEffectLookAt::setSourceObject(LLViewerObject* objectp) { // restrict source objects to avatars if (objectp && objectp->isAvatar()) { LLHUDEffect::setSourceObject(objectp); } } //----------------------------------------------------------------------------- // render() //----------------------------------------------------------------------------- void LLHUDEffectLookAt::render() { if (mDebugLookAt && mSourceObject.notNull()) { static LLCachedControl hide_own(gSavedPerAccountSettings, "DebugLookAtHideOwn", false); static LLCachedControl is_private(gSavedSettings, "PrivateLookAtTarget", false); if ((hide_own || is_private) && ((LLVOAvatar*)(LLViewerObject*)mSourceObject)->isSelf()) return; //LLGLDisable gls_stencil(GL_STENCIL_TEST); LLGLDepthTest depth(GL_TRUE, GL_FALSE); // Reduce screen clutter LLVector3 target = mTargetPos + ((LLVOAvatar*)(LLViewerObject*)mSourceObject)->mHeadp->getWorldPosition(); LLColor3 lookAtColor = (*mAttentions)[mTargetType].mColor; static LLCachedControl show_names(gSavedSettings, "DebugLookAtShowNames"); if ((show_names > 0) && !gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) { // render name for crosshair const LLFontGL* fontp = LLFontGL::getFont(LLFontDescriptor("SansSerif", "Small", LLFontGL::NORMAL)); LLVector3 position = target + LLVector3(0.f, 0.f, 0.3f); std::string name; LLAvatarName nameBuffer; if (LLAvatarNameCache::get(mSourceObject->getID(), &nameBuffer)) { switch (show_names) { case 1: // Display Name (user.name) name = nameBuffer.getCompleteName(); break; case 2: // Display Name name = nameBuffer.getDisplayName(); break; case 3: // First Last name = nameBuffer.getUserNameForDisplay(); break; default: //user.name name = nameBuffer.getAccountName(); break; } } gGL.pushMatrix(); hud_render_utf8text(name, position, *fontp, LLFontGL::NORMAL, LLFontGL::DROP_SHADOW, -0.5f * fontp->getWidthF32(name), 3.0f, lookAtColor, false); gGL.popMatrix(); } // render crosshair gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE); gGL.matrixMode(LLRender::MM_MODELVIEW); gGL.pushMatrix(); gGL.translatef(target.mV[VX], target.mV[VY], target.mV[VZ]); // FIRE-16912: Draw lines for lookat targets; by Ayamo Nozaki //gGL.scalef(0.3f, 0.3f, 0.3f); gGL.scalef(0.1f, 0.1f, 0.1f); // gGL.begin(LLRender::LINES); { LLColor3 color = (*mAttentions)[mTargetType].mColor; gGL.color3f(color.mV[VRED], color.mV[VGREEN], color.mV[VBLUE]); gGL.vertex3f(-1.f, 0.f, 0.f); gGL.vertex3f(1.f, 0.f, 0.f); gGL.vertex3f(0.f, -1.f, 0.f); gGL.vertex3f(0.f, 1.f, 0.f); gGL.vertex3f(0.f, 0.f, -1.f); gGL.vertex3f(0.f, 0.f, 1.f); // FIRE-16912: Draw lines for lookat targets; by Ayamo Nozaki static LLCachedControl lookAtLines(gSavedSettings, "ExodusLookAtLines", false); if (lookAtLines && (*mAttentions)[mTargetType].mName != "None" && (*mAttentions)[mTargetType].mName != "Idle" && (*mAttentions)[mTargetType].mName != "AutoListen") { LLVector3 dist = ((mSourceObject->getWorldPosition()) - mTargetPos) * 10.f; gGL.vertex3f(0.f, 0.f, 0.f); gGL.vertex3f(dist.mV[VX], dist.mV[VY], dist.mV[VZ] + 0.5f); } // } gGL.end(); gGL.popMatrix(); } } //----------------------------------------------------------------------------- // update() //----------------------------------------------------------------------------- void LLHUDEffectLookAt::update() { // If the target object is dead, set the target object to NULL if (!mTargetObject.isNull() && mTargetObject->isDead()) { clearLookAtTarget(); } // if source avatar is null or dead, mark self as dead and return if (mSourceObject.isNull() || mSourceObject->isDead()) { markDead(); return; } // make sure the proper set of avatar attention are currently being used. LLVOAvatar* source_avatar = (LLVOAvatar*)(LLViewerObject*)mSourceObject; // for now the first cut will just switch on sex. future development could adjust // timeouts according to avatar age and/or other features. mAttentions = (source_avatar->getSex() == SEX_MALE) ? &gBoyAttentions : &gGirlAttentions; //printf("updated to %s\n", (source_avatar->getSex() == SEX_MALE) ? "male" : "female"); F32 time = mTimer.getElapsedTimeF32(); // clear out the effect if time is up if (mKillTime != 0.f && time > mKillTime) { if (mTargetType != LOOKAT_TARGET_NONE) { clearLookAtTarget(); // look at timed out (only happens on own avatar), so tell everyone setNeedsSendToSim(true); } } if (mTargetType != LOOKAT_TARGET_NONE) { if (calcTargetPosition()) { static LLCachedControl disable_look_at(gSavedSettings, "DisableLookAtAnimation", true); LLMotion* head_motion = ((LLVOAvatar*)(LLViewerObject*)mSourceObject)->findMotion(ANIM_AGENT_HEAD_ROT); if (disable_look_at()) { if (head_motion) { ((LLVOAvatar*)(LLViewerObject*)mSourceObject)->stopMotion(ANIM_AGENT_HEAD_ROT); } } else if (!head_motion || head_motion->isStopped()) { ((LLVOAvatar*)(LLViewerObject*)mSourceObject)->startMotion(ANIM_AGENT_HEAD_ROT); } } } // FIRE-12878: Don't render debug text for lookats //if (mDebugLookAt) //{ // ((LLVOAvatar*)(LLViewerObject*)mSourceObject)->addDebugText((*mAttentions)[mTargetType].mName); //} // } /** * Initializes the mTargetPos member from the current mSourceObjec and mTargetObject * (and possibly mTargetOffsetGlobal). * When mTargetObject is another avatar, it sets mTargetPos to be their eyes. * * Has the side-effect of also calling setAnimationData("LookAtPoint") with the new * mTargetPos on the source object which is assumed to be an avatar. * * Returns whether we successfully calculated a finite target position. */ bool LLHUDEffectLookAt::calcTargetPosition() { LLViewerObject *target_obj = (LLViewerObject *)mTargetObject; LLVector3 local_offset; if (target_obj) { local_offset.setVec(mTargetOffsetGlobal); } else { local_offset = gAgent.getPosAgentFromGlobal(mTargetOffsetGlobal); } LLVOAvatar* source_avatar = (LLVOAvatar*)(LLViewerObject*)mSourceObject; if (!source_avatar->isBuilt()) return false; if (target_obj && target_obj->mDrawable.notNull()) { LLQuaternion target_rot; if (target_obj->isAvatar()) { LLVOAvatar *target_av = (LLVOAvatar *)target_obj; bool looking_at_self = source_avatar->isSelf() && target_av->isSelf(); // if selecting self, stare forward if (looking_at_self && mTargetOffsetGlobal.magVecSquared() < MIN_TARGET_OFFSET_SQUARED) { // 1m in front of the avatar should be enough; changed because of distance clamp //sets the lookat point in front of the avatar //mTargetOffsetGlobal.setVec(5.0, 0.0, 0.0); mTargetOffsetGlobal.setVec(1.0, 0.0, 0.0); local_offset.setVec(mTargetOffsetGlobal); } // look the other avatar in the eye. note: what happens if target is self? -MG mTargetPos = target_av->mHeadp->getWorldPosition(); if (mTargetType == LOOKAT_TARGET_MOUSELOOK || mTargetType == LOOKAT_TARGET_FREELOOK) { // mouselook and freelook target offsets are absolute target_rot = LLQuaternion::DEFAULT; } else if (looking_at_self && gAgentCamera.cameraCustomizeAvatar()) { // *NOTE: We have to do this because animation // overrides do not set lookat behavior. // *TODO: animation overrides for lookat behavior. target_rot = target_av->mPelvisp->getWorldRotation(); } else { target_rot = target_av->mRoot->getWorldRotation(); } } else // target obj is not an avatar { if (target_obj->mDrawable->getGeneration() == -1) { mTargetPos = target_obj->getPositionAgent(); target_rot = target_obj->getWorldRotation(); } else { mTargetPos = target_obj->getRenderPosition(); target_rot = target_obj->getRenderRotation(); } } mTargetPos += (local_offset * target_rot); } else // no target obj or it's not drawable { mTargetPos = local_offset; } mTargetPos -= source_avatar->mHeadp->getWorldPosition(); if (!mTargetPos.isFinite()) return false; static LLCachedControl disable_look_at(gSavedSettings, "DisableLookAtAnimation", true); if (disable_look_at()) { source_avatar->removeAnimationData("LookAtPoint"); } else { source_avatar->setAnimationData("LookAtPoint", (void*)&mTargetPos); } return true; }