907 lines
29 KiB
C++
907 lines
29 KiB
C++
/**
|
|
* @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 "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; i<LOOKAT_NUM_TARGETS; i++)
|
|
{
|
|
mAttentions[i] = attentions[i];
|
|
}
|
|
}
|
|
LLAttention mAttentions[LOOKAT_NUM_TARGETS];
|
|
LLAttention& operator[](int idx) { return mAttentions[idx]; }
|
|
};
|
|
|
|
// Default attribute set data.
|
|
// Used to initialize the global attribute set objects, one of which will be
|
|
// refered to by the hud object at any given time.
|
|
// Note that the values below are only the default values and that any or all of them
|
|
// can be overwritten with customizing data from the XML file. The actual values below
|
|
// are those that will give exactly the same look-at behavior as before the ability
|
|
// to customize was added. - MG
|
|
static const
|
|
LLAttention
|
|
BOY_ATTS[] = { // default set of masculine attentions
|
|
LLAttention(MAX_TIMEOUT, 0, "None", LLColor3(0.3f, 0.3f, 0.3f)), // LOOKAT_TARGET_NONE
|
|
LLAttention(3.f, 1, "Idle", LLColor3(0.5f, 0.5f, 0.5f)), // LOOKAT_TARGET_IDLE
|
|
LLAttention(4.f, 3, "AutoListen", LLColor3(0.5f, 0.5f, 0.5f)), // LOOKAT_TARGET_AUTO_LISTEN
|
|
LLAttention(2.f, 2, "FreeLook", LLColor3(0.5f, 0.5f, 0.9f)), // LOOKAT_TARGET_FREELOOK
|
|
LLAttention(4.f, 3, "Respond", LLColor3(0.0f, 0.0f, 0.0f)), // LOOKAT_TARGET_RESPOND
|
|
LLAttention(1.f, 4, "Hover", LLColor3(0.5f, 0.9f, 0.5f)), // LOOKAT_TARGET_HOVER
|
|
LLAttention(MAX_TIMEOUT, 0, "Conversation", LLColor3(0.1f, 0.1f, 0.5f)), // LOOKAT_TARGET_CONVERSATION
|
|
LLAttention(MAX_TIMEOUT, 6, "Select", LLColor3(0.9f, 0.5f, 0.5f)), // LOOKAT_TARGET_SELECT
|
|
LLAttention(MAX_TIMEOUT, 6, "Focus", LLColor3(0.9f, 0.5f, 0.9f)), // LOOKAT_TARGET_FOCUS
|
|
LLAttention(MAX_TIMEOUT, 7, "Mouselook", LLColor3(0.9f, 0.9f, 0.5f)), // LOOKAT_TARGET_MOUSELOOK
|
|
LLAttention(0.f, 8, "Clear", LLColor3(1.0f, 1.0f, 1.0f)), // LOOKAT_TARGET_CLEAR
|
|
},
|
|
GIRL_ATTS[] = { // default set of feminine attentions
|
|
LLAttention(MAX_TIMEOUT, 0, "None", LLColor3(0.3f, 0.3f, 0.3f)), // LOOKAT_TARGET_NONE
|
|
LLAttention(3.f, 1, "Idle", LLColor3(0.5f, 0.5f, 0.5f)), // LOOKAT_TARGET_IDLE
|
|
LLAttention(4.f, 3, "AutoListen", LLColor3(0.5f, 0.5f, 0.5f)), // LOOKAT_TARGET_AUTO_LISTEN
|
|
LLAttention(2.f, 2, "FreeLook", LLColor3(0.5f, 0.5f, 0.9f)), // LOOKAT_TARGET_FREELOOK
|
|
LLAttention(4.f, 3, "Respond", LLColor3(0.0f, 0.0f, 0.0f)), // LOOKAT_TARGET_RESPOND
|
|
LLAttention(1.f, 4, "Hover", LLColor3(0.5f, 0.9f, 0.5f)), // LOOKAT_TARGET_HOVER
|
|
LLAttention(MAX_TIMEOUT, 0, "Conversation", LLColor3(0.1f, 0.1f, 0.5f)), // LOOKAT_TARGET_CONVERSATION
|
|
LLAttention(MAX_TIMEOUT, 6, "Select", LLColor3(0.9f, 0.5f, 0.5f)), // LOOKAT_TARGET_SELECT
|
|
LLAttention(MAX_TIMEOUT, 6, "Focus", LLColor3(0.9f, 0.5f, 0.9f)), // LOOKAT_TARGET_FOCUS
|
|
LLAttention(MAX_TIMEOUT, 7, "Mouselook", LLColor3(0.9f, 0.9f, 0.5f)), // LOOKAT_TARGET_MOUSELOOK
|
|
LLAttention(0.f, 8, "Clear", LLColor3(1.0f, 1.0f, 1.0f)), // LOOKAT_TARGET_CLEAR
|
|
};
|
|
|
|
static LLAttentionSet
|
|
gBoyAttentions(BOY_ATTS),
|
|
gGirlAttentions(GIRL_ATTS);
|
|
|
|
|
|
static BOOL loadGender(LLXmlTreeNode* gender)
|
|
{
|
|
if( !gender)
|
|
{
|
|
return FALSE;
|
|
}
|
|
std::string str;
|
|
gender->getAttributeString("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;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
// <linden_attentions version="1.0"> (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;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
// <gender>
|
|
//-------------------------------------------------------------------------
|
|
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),
|
|
//<FS:AO improve use of controls with radiogroups>
|
|
//mDebugLookAt( LLCachedControl<bool>(gSavedPerAccountSettings, "DebugLookAt", FALSE))
|
|
mDebugLookAt( LLCachedControl<S32>(gSavedPerAccountSettings, "DebugLookAt", FALSE))
|
|
//</FS:AO>
|
|
{
|
|
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<bool> is_private(gSavedSettings, "PrivateLookAtTarget", false);
|
|
static LLCachedControl<bool> 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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
F32 current_time = mTimer.getElapsedTimeF32();
|
|
|
|
//<FS:LO> 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);
|
|
// }
|
|
//}
|
|
|
|
|
|
// <FS:TS> FIRE-24175: Fix look at target clamping
|
|
bool isLookingAtSelf = false;
|
|
if(object){
|
|
isLookingAtSelf = object->isAvatar() && ((LLVOAvatar*)(LLViewerObject*)object)->isSelf();
|
|
}
|
|
static LLCachedControl<bool> 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";
|
|
(*mAttentions)[mTargetType].mName != "AutoListen" &&
|
|
!isLookingAtSelf;
|
|
// </FS:TS> FIRE-24175
|
|
|
|
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)
|
|
{
|
|
// <FS:TS> FIRE-24175: Fix look at target clamping
|
|
//if (mTargetObject->isAvatar() && ((LLVOAvatar*)(LLViewerObject*)mTargetObject)->isSelf())
|
|
//{
|
|
// //We use this branch and mimic our mouse/first person look pose.
|
|
// mTargetOffsetGlobal.setVec(gAgent.getPosGlobalFromAgent(gAgentAvatarp->mHeadp->getWorldPosition() + position));
|
|
// mTargetObject = NULL;
|
|
//}
|
|
//else
|
|
//{
|
|
//Otherwise, mimic looking at the object.
|
|
mTargetOffsetGlobal.setVec(object->getPositionGlobal() + (LLVector3d)(position * object->getRotationRegion()));
|
|
mTargetObject = NULL;
|
|
//}
|
|
// </FS:TS> FIRE-24175
|
|
}
|
|
else
|
|
{
|
|
mTargetOffsetGlobal.setVec(position);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mTargetOffsetGlobal = gAgent.getPosGlobalFromAgent(position);
|
|
}
|
|
|
|
if (lookAtShouldClamp)
|
|
{
|
|
static LLCachedControl<F32> s_Radius(gSavedSettings, "FSLookAtTargetMaxDistance");
|
|
|
|
LLVector3d headPosition = gAgent.getPosGlobalFromAgent(gAgentAvatarp->mHeadp->getWorldPosition());
|
|
float distance = 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);
|
|
}
|
|
}
|
|
//</FS:LO> 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<bool> hide_own(gSavedPerAccountSettings, "DebugLookAtHideOwn", false);
|
|
static LLCachedControl<bool> is_private(gSavedSettings, "PrivateLookAtTarget", false);
|
|
if ((hide_own || is_private) && ((LLVOAvatar*)(LLViewerObject*)mSourceObject)->isSelf())
|
|
return;
|
|
|
|
//LLGLDisable gls_stencil(GL_STENCIL_TEST);
|
|
|
|
LLVector3 target = mTargetPos + ((LLVOAvatar*)(LLViewerObject*)mSourceObject)->mHeadp->getWorldPosition();
|
|
LLColor3 lookAtColor = (*mAttentions)[mTargetType].mColor;
|
|
|
|
static LLCachedControl<U32> 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]);
|
|
// <FS:Ansariel> 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);
|
|
// </FS:Ansariel>
|
|
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);
|
|
|
|
// <FS:Ansariel> FIRE-16912: Draw lines for lookat targets; by Ayamo Nozaki
|
|
static LLCachedControl<bool> 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);
|
|
}
|
|
// </FS:Ansariel>
|
|
} 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())
|
|
{
|
|
LLMotion* head_motion = ((LLVOAvatar*)(LLViewerObject*)mSourceObject)->findMotion(ANIM_AGENT_HEAD_ROT);
|
|
if (!head_motion || head_motion->isStopped())
|
|
{
|
|
((LLVOAvatar*)(LLViewerObject*)mSourceObject)->startMotion(ANIM_AGENT_HEAD_ROT);
|
|
}
|
|
}
|
|
}
|
|
|
|
// <FS:Ansariel> FIRE-12878: Don't render debug text for lookats
|
|
//if (mDebugLookAt)
|
|
//{
|
|
// ((LLVOAvatar*)(LLViewerObject*)mSourceObject)->addDebugText((*mAttentions)[mTargetType].mName);
|
|
//}
|
|
// </FS:Ansariel>
|
|
}
|
|
|
|
/**
|
|
* 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)
|
|
{
|
|
//sets the lookat point in front of the avatar
|
|
mTargetOffsetGlobal.setVec(5.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;
|
|
|
|
source_avatar->setAnimationData("LookAtPoint", (void *)&mTargetPos);
|
|
|
|
return true;
|
|
}
|