Merge remote-tracking branch 'origin/DRTVWR-600-maint-A' into brad/merge-maint-a-to-dev

1 files changed, 307 insertions, 307 deletions

diff --git a/indra/newview/llhudeffectpointat.cpp b/indra/newview/llhudeffectpointat.cpp
index fa5e27a197..eeb38cd6aa 100644
--- a/indra/newview/llhudeffectpointat.cpp
+++ b/indra/newview/llhudeffectpointat.cpp
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llhudeffectpointat.cpp
  * @brief LLHUDEffectPointAt 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$
  */
@@ -54,20 +54,20 @@ const F32 MIN_DELTAPOS_FOR_UPDATE_SQUARED = 0.05f * 0.05f;
 // can't use actual F32_MAX, because we add this to the current frametime
 const F32 MAX_TIMEOUT = F32_MAX / 4.f;
 
-const F32 POINTAT_TIMEOUTS[POINTAT_NUM_TARGETS] = 
+const F32 POINTAT_TIMEOUTS[POINTAT_NUM_TARGETS] =
 {
-	MAX_TIMEOUT, //POINTAT_TARGET_NONE
-	MAX_TIMEOUT, //POINTAT_TARGET_SELECT
-	MAX_TIMEOUT, //POINTAT_TARGET_GRAB
-	0.f, //POINTAT_TARGET_CLEAR
+    MAX_TIMEOUT, //POINTAT_TARGET_NONE
+    MAX_TIMEOUT, //POINTAT_TARGET_SELECT
+    MAX_TIMEOUT, //POINTAT_TARGET_GRAB
+    0.f, //POINTAT_TARGET_CLEAR
 };
 
-const S32 POINTAT_PRIORITIES[POINTAT_NUM_TARGETS] = 
+const S32 POINTAT_PRIORITIES[POINTAT_NUM_TARGETS] =
 {
-	0, //POINTAT_TARGET_NONE
-	1, //POINTAT_TARGET_SELECT
-	2, //POINTAT_TARGET_GRAB
-	3, //POINTAT_TARGET_CLEAR
+    0, //POINTAT_TARGET_NONE
+    1, //POINTAT_TARGET_SELECT
+    2, //POINTAT_TARGET_GRAB
+    3, //POINTAT_TARGET_CLEAR
 };
 
 // statics
@@ -78,12 +78,12 @@ bool LLHUDEffectPointAt::sDebugPointAt;
 //-----------------------------------------------------------------------------
 // LLHUDEffectPointAt()
 //-----------------------------------------------------------------------------
-LLHUDEffectPointAt::LLHUDEffectPointAt(const U8 type) : 
-	LLHUDEffect(type), 
-	mKillTime(0.f),
-	mLastSendTime(0.f)
+LLHUDEffectPointAt::LLHUDEffectPointAt(const U8 type) :
+    LLHUDEffect(type),
+    mKillTime(0.f),
+    mLastSendTime(0.f)
 {
-	clearPointAtTarget();
+    clearPointAtTarget();
 }
 
 //-----------------------------------------------------------------------------
@@ -98,41 +98,41 @@ LLHUDEffectPointAt::~LLHUDEffectPointAt()
 //-----------------------------------------------------------------------------
 void LLHUDEffectPointAt::packData(LLMessageSystem *mesgsys)
 {
-	// 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]), mTargetObject->mID.mData, MVT_LLUUID, 16);
-	}
-	else
-	{
-		htolememcpy(&(packed_data[TARGET_OBJECT]), LLUUID::null.mData, MVT_LLUUID, 16);
-	}
-
-	htolememcpy(&(packed_data[TARGET_POS]), mTargetOffsetGlobal.mdV, MVT_LLVector3d, 24);
-
-	U8 pointAtTypePacked = (U8)mTargetType;
-	htolememcpy(&(packed_data[POINTAT_TYPE]), &pointAtTypePacked, MVT_U8, 1);
-
-	mesgsys->addBinaryDataFast(_PREHASH_TypeData, packed_data, PKT_SIZE);
-
-	mLastSendTime = mTimer.getElapsedTimeF32();
+    // 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]), mTargetObject->mID.mData, MVT_LLUUID, 16);
+    }
+    else
+    {
+        htolememcpy(&(packed_data[TARGET_OBJECT]), LLUUID::null.mData, MVT_LLUUID, 16);
+    }
+
+    htolememcpy(&(packed_data[TARGET_POS]), mTargetOffsetGlobal.mdV, MVT_LLVector3d, 24);
+
+    U8 pointAtTypePacked = (U8)mTargetType;
+    htolememcpy(&(packed_data[POINTAT_TYPE]), &pointAtTypePacked, MVT_U8, 1);
+
+    mesgsys->addBinaryDataFast(_PREHASH_TypeData, packed_data, PKT_SIZE);
+
+    mLastSendTime = mTimer.getElapsedTimeF32();
 }
 
 //-----------------------------------------------------------------------------
@@ -140,61 +140,61 @@ void LLHUDEffectPointAt::packData(LLMessageSystem *mesgsys)
 //-----------------------------------------------------------------------------
 void LLHUDEffectPointAt::unpackData(LLMessageSystem *mesgsys, S32 blocknum)
 {
-	LLVector3d new_target;
-	U8 packed_data[PKT_SIZE];
-
-	LLUUID dataId;
-	mesgsys->getUUIDFast(_PREHASH_Effect, _PREHASH_ID, dataId, blocknum);
-
-	// ignore messages from ourselves
-	if (!gAgentCamera.mPointAt.isNull() && dataId == gAgentCamera.mPointAt->getID())
-	{
-		return;
-	}
-
-	LLHUDEffect::unpackData(mesgsys, blocknum);
-	LLUUID source_id;
-	LLUUID target_id;
-	U8 pointAtTypeUnpacked = 0;
-	S32 size = mesgsys->getSizeFast(_PREHASH_Effect, blocknum, _PREHASH_TypeData);
-	if (size != PKT_SIZE)
-	{
-		LL_WARNS() << "PointAt 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);
-	htolememcpy(target_id.mData, &(packed_data[TARGET_OBJECT]), MVT_LLUUID, 16);
-	htolememcpy(new_target.mdV, &(packed_data[TARGET_POS]), MVT_LLVector3d, 24);
-	htolememcpy(&pointAtTypeUnpacked, &(packed_data[POINTAT_TYPE]), MVT_U8, 1);
-
-	LLViewerObject *objp = gObjectList.findObject(source_id);
-	if (objp && objp->isAvatar())
-	{
-		setSourceObject(objp);
-	}
-	else
-	{
-		//LL_WARNS() << "Could not find source avatar for pointat effect" << LL_ENDL;
-		return;
-	}
-
-	objp = gObjectList.findObject(target_id);
-
-	if (objp)
-	{
-		setTargetObjectAndOffset(objp, new_target);
-	}
-	else if (target_id.isNull())
-	{
-		setTargetPosGlobal(new_target);
-	}
-
-	mTargetType = (EPointAtType)pointAtTypeUnpacked;
-
-//	mKillTime = mTimer.getElapsedTimeF32() + mDuration;
-	update();
+    LLVector3d new_target;
+    U8 packed_data[PKT_SIZE];
+
+    LLUUID dataId;
+    mesgsys->getUUIDFast(_PREHASH_Effect, _PREHASH_ID, dataId, blocknum);
+
+    // ignore messages from ourselves
+    if (!gAgentCamera.mPointAt.isNull() && dataId == gAgentCamera.mPointAt->getID())
+    {
+        return;
+    }
+
+    LLHUDEffect::unpackData(mesgsys, blocknum);
+    LLUUID source_id;
+    LLUUID target_id;
+    U8 pointAtTypeUnpacked = 0;
+    S32 size = mesgsys->getSizeFast(_PREHASH_Effect, blocknum, _PREHASH_TypeData);
+    if (size != PKT_SIZE)
+    {
+        LL_WARNS() << "PointAt 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);
+    htolememcpy(target_id.mData, &(packed_data[TARGET_OBJECT]), MVT_LLUUID, 16);
+    htolememcpy(new_target.mdV, &(packed_data[TARGET_POS]), MVT_LLVector3d, 24);
+    htolememcpy(&pointAtTypeUnpacked, &(packed_data[POINTAT_TYPE]), MVT_U8, 1);
+
+    LLViewerObject *objp = gObjectList.findObject(source_id);
+    if (objp && objp->isAvatar())
+    {
+        setSourceObject(objp);
+    }
+    else
+    {
+        //LL_WARNS() << "Could not find source avatar for pointat effect" << LL_ENDL;
+        return;
+    }
+
+    objp = gObjectList.findObject(target_id);
+
+    if (objp)
+    {
+        setTargetObjectAndOffset(objp, new_target);
+    }
+    else if (target_id.isNull())
+    {
+        setTargetPosGlobal(new_target);
+    }
+
+    mTargetType = (EPointAtType)pointAtTypeUnpacked;
+
+//  mKillTime = mTimer.getElapsedTimeF32() + mDuration;
+    update();
 }
 
 //-----------------------------------------------------------------------------
@@ -202,8 +202,8 @@ void LLHUDEffectPointAt::unpackData(LLMessageSystem *mesgsys, S32 blocknum)
 //-----------------------------------------------------------------------------
 void LLHUDEffectPointAt::setTargetObjectAndOffset(LLViewerObject *objp, LLVector3d offset)
 {
-	mTargetObject = objp;
-	mTargetOffsetGlobal = offset;
+    mTargetObject = objp;
+    mTargetOffsetGlobal = offset;
 }
 
 //-----------------------------------------------------------------------------
@@ -211,8 +211,8 @@ void LLHUDEffectPointAt::setTargetObjectAndOffset(LLViewerObject *objp, LLVector
 //-----------------------------------------------------------------------------
 void LLHUDEffectPointAt::setTargetPosGlobal(const LLVector3d &target_pos_global)
 {
-	mTargetObject = NULL;
-	mTargetOffsetGlobal = target_pos_global;
+    mTargetObject = NULL;
+    mTargetOffsetGlobal = target_pos_global;
 }
 
 //-----------------------------------------------------------------------------
@@ -221,64 +221,64 @@ void LLHUDEffectPointAt::setTargetPosGlobal(const LLVector3d &target_pos_global)
 //-----------------------------------------------------------------------------
 bool LLHUDEffectPointAt::setPointAt(EPointAtType target_type, LLViewerObject *object, LLVector3 position)
 {
-	if (!mSourceObject)
-	{
-		return false;
-	}
-	
-	if (target_type >= POINTAT_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 (POINTAT_PRIORITIES[target_type] < POINTAT_PRIORITIES[mTargetType])
-	{
-		return false;
-	}
-
-	F32 current_time  = mTimer.getElapsedTimeF32();
-	
-	// type of pointat behavior or target object has changed
-	bool targetTypeChanged = (target_type != mTargetType) ||
-		(object != mTargetObject);
-
-	bool targetPosChanged = (dist_vec_squared(position, mLastSentOffsetGlobal) > MIN_DELTAPOS_FOR_UPDATE_SQUARED) && 
-		((current_time - mLastSendTime) > (1.f / MAX_SENDS_PER_SEC));
-
-	if (targetTypeChanged || targetPosChanged)
-	{
-		mLastSentOffsetGlobal = position;
-		setDuration(POINTAT_TIMEOUTS[target_type]);
-		setNeedsSendToSim(true);
-//		LL_INFOS() << "Sending pointat data" << LL_ENDL;
-	}
-
-	if (target_type == POINTAT_TARGET_CLEAR)
-	{
-		clearPointAtTarget();
-	}
-	else
-	{
-		mTargetType = target_type;
-		mTargetObject = object;
-		if (object)
-		{
-			mTargetOffsetGlobal.setVec(position);
-		}
-		else
-		{
-			mTargetOffsetGlobal = gAgent.getPosGlobalFromAgent(position);
-		}
-
-		mKillTime = mTimer.getElapsedTimeF32() + mDuration;
-
-		//set up requisite animation data
-		update();
-	}
-
-	return true;
+    if (!mSourceObject)
+    {
+        return false;
+    }
+
+    if (target_type >= POINTAT_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 (POINTAT_PRIORITIES[target_type] < POINTAT_PRIORITIES[mTargetType])
+    {
+        return false;
+    }
+
+    F32 current_time  = mTimer.getElapsedTimeF32();
+
+    // type of pointat behavior or target object has changed
+    bool targetTypeChanged = (target_type != mTargetType) ||
+        (object != mTargetObject);
+
+    bool targetPosChanged = (dist_vec_squared(position, mLastSentOffsetGlobal) > MIN_DELTAPOS_FOR_UPDATE_SQUARED) &&
+        ((current_time - mLastSendTime) > (1.f / MAX_SENDS_PER_SEC));
+
+    if (targetTypeChanged || targetPosChanged)
+    {
+        mLastSentOffsetGlobal = position;
+        setDuration(POINTAT_TIMEOUTS[target_type]);
+        setNeedsSendToSim(true);
+//      LL_INFOS() << "Sending pointat data" << LL_ENDL;
+    }
+
+    if (target_type == POINTAT_TARGET_CLEAR)
+    {
+        clearPointAtTarget();
+    }
+    else
+    {
+        mTargetType = target_type;
+        mTargetObject = object;
+        if (object)
+        {
+            mTargetOffsetGlobal.setVec(position);
+        }
+        else
+        {
+            mTargetOffsetGlobal = gAgent.getPosGlobalFromAgent(position);
+        }
+
+        mKillTime = mTimer.getElapsedTimeF32() + mDuration;
+
+        //set up requisite animation data
+        update();
+    }
+
+    return true;
 }
 
 //-----------------------------------------------------------------------------
@@ -286,9 +286,9 @@ bool LLHUDEffectPointAt::setPointAt(EPointAtType target_type, LLViewerObject *ob
 //-----------------------------------------------------------------------------
 void LLHUDEffectPointAt::clearPointAtTarget()
 {
-	mTargetObject = NULL;
-	mTargetOffsetGlobal.clearVec();
-	mTargetType = POINTAT_TARGET_NONE;
+    mTargetObject = NULL;
+    mTargetOffsetGlobal.clearVec();
+    mTargetType = POINTAT_TARGET_NONE;
 }
 
 //-----------------------------------------------------------------------------
@@ -296,22 +296,22 @@ void LLHUDEffectPointAt::clearPointAtTarget()
 //-----------------------------------------------------------------------------
 void LLHUDEffectPointAt::markDead()
 {
-	if (!mSourceObject.isNull() && mSourceObject->isAvatar())
-	{
-		((LLVOAvatar*)(LLViewerObject*)mSourceObject)->removeAnimationData("PointAtPoint");
-	}
+    if (!mSourceObject.isNull() && mSourceObject->isAvatar())
+    {
+        ((LLVOAvatar*)(LLViewerObject*)mSourceObject)->removeAnimationData("PointAtPoint");
+    }
 
-	clearPointAtTarget();
-	LLHUDEffect::markDead();
+    clearPointAtTarget();
+    LLHUDEffect::markDead();
 }
 
 void LLHUDEffectPointAt::setSourceObject(LLViewerObject* objectp)
 {
-	// restrict source objects to avatars
-	if (objectp && objectp->isAvatar())
-	{
-		LLHUDEffect::setSourceObject(objectp);
-	}
+    // restrict source objects to avatars
+    if (objectp && objectp->isAvatar())
+    {
+        LLHUDEffect::setSourceObject(objectp);
+    }
 }
 
 //-----------------------------------------------------------------------------
@@ -319,30 +319,30 @@ void LLHUDEffectPointAt::setSourceObject(LLViewerObject* objectp)
 //-----------------------------------------------------------------------------
 void LLHUDEffectPointAt::render()
 {
-	update();
-	if (sDebugPointAt && mTargetType != POINTAT_TARGET_NONE)
-	{
-		//LLGLDisable gls_stencil(GL_STENCIL_TEST);
-		gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-
-		LLVector3 target = mTargetPos + mSourceObject->getRenderPosition();
-		gGL.pushMatrix();
-		gGL.translatef(target.mV[VX], target.mV[VY], target.mV[VZ]);
-		gGL.scalef(0.3f, 0.3f, 0.3f);
-		gGL.begin(LLRender::LINES);
-		{
-			gGL.color3f(1.f, 0.f, 0.f);
-			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);
-		} gGL.end();
-		gGL.popMatrix();
-	}
+    update();
+    if (sDebugPointAt && mTargetType != POINTAT_TARGET_NONE)
+    {
+        //LLGLDisable gls_stencil(GL_STENCIL_TEST);
+        gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+
+        LLVector3 target = mTargetPos + mSourceObject->getRenderPosition();
+        gGL.pushMatrix();
+        gGL.translatef(target.mV[VX], target.mV[VY], target.mV[VZ]);
+        gGL.scalef(0.3f, 0.3f, 0.3f);
+        gGL.begin(LLRender::LINES);
+        {
+            gGL.color3f(1.f, 0.f, 0.f);
+            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);
+        } gGL.end();
+        gGL.popMatrix();
+    }
 }
 
 //-----------------------------------------------------------------------------
@@ -350,40 +350,40 @@ void LLHUDEffectPointAt::render()
 //-----------------------------------------------------------------------------
 void LLHUDEffectPointAt::update()
 {
-	// If the target object is dead, set the target object to NULL
-	if (!mTargetObject.isNull() && mTargetObject->isDead())
-	{
-		clearPointAtTarget();
-	}
-
-	if (mSourceObject.isNull() || mSourceObject->isDead())
-	{
-		markDead();
-		return;
-	}
-	
-	F32 time = mTimer.getElapsedTimeF32();
-
-	// clear out the effect if time is up
-	if (mKillTime != 0.f && time > mKillTime)
-	{
-		mTargetType = POINTAT_TARGET_NONE;
-	}
-
-	if (mSourceObject->isAvatar())
-	{
-		if (mTargetType == POINTAT_TARGET_NONE)
-		{
-			((LLVOAvatar*)(LLViewerObject*)mSourceObject)->removeAnimationData("PointAtPoint");
-		}
-		else
-		{
-			if (calcTargetPosition())
-			{
-				((LLVOAvatar*)(LLViewerObject*)mSourceObject)->startMotion(ANIM_AGENT_EDITING);
-			}
-		}
-	}
+    // If the target object is dead, set the target object to NULL
+    if (!mTargetObject.isNull() && mTargetObject->isDead())
+    {
+        clearPointAtTarget();
+    }
+
+    if (mSourceObject.isNull() || mSourceObject->isDead())
+    {
+        markDead();
+        return;
+    }
+
+    F32 time = mTimer.getElapsedTimeF32();
+
+    // clear out the effect if time is up
+    if (mKillTime != 0.f && time > mKillTime)
+    {
+        mTargetType = POINTAT_TARGET_NONE;
+    }
+
+    if (mSourceObject->isAvatar())
+    {
+        if (mTargetType == POINTAT_TARGET_NONE)
+        {
+            ((LLVOAvatar*)(LLViewerObject*)mSourceObject)->removeAnimationData("PointAtPoint");
+        }
+        else
+        {
+            if (calcTargetPosition())
+            {
+                ((LLVOAvatar*)(LLViewerObject*)mSourceObject)->startMotion(ANIM_AGENT_EDITING);
+            }
+        }
+    }
 }
 
 //-----------------------------------------------------------------------------
@@ -392,71 +392,71 @@ void LLHUDEffectPointAt::update()
 //-----------------------------------------------------------------------------
 bool LLHUDEffectPointAt::calcTargetPosition()
 {
-	LLViewerObject *targetObject = (LLViewerObject *)mTargetObject;
-	LLVector3 local_offset;
-	
-	if (targetObject)
-	{
-		local_offset.setVec(mTargetOffsetGlobal);
-	}
-	else
-	{
-		local_offset = gAgent.getPosAgentFromGlobal(mTargetOffsetGlobal);
-	}
-
-	if (targetObject && targetObject->mDrawable.notNull())
-	{
-		LLQuaternion objRot;
-		if (targetObject->isAvatar())
-		{
-			LLVOAvatar *avatarp = (LLVOAvatar *)targetObject;
-			mTargetPos = avatarp->mHeadp->getWorldPosition();
-			objRot = avatarp->mPelvisp->getWorldRotation();
-		}
-		else
-		{
-			if (targetObject->mDrawable->getGeneration() == -1)
-			{
-				mTargetPos = targetObject->getPositionAgent();
-				objRot = targetObject->getWorldRotation();
-			}
-			else
-			{
-				mTargetPos = targetObject->getRenderPosition();
-				objRot = targetObject->getRenderRotation();
-			}
-		}
-
-		mTargetPos += (local_offset * objRot);
-	}
-	else
-	{
-		mTargetPos = local_offset;
-	}
-
-	mTargetPos -= mSourceObject->getRenderPosition();
-
-	if (!llfinite(mTargetPos.lengthSquared()))
-	{
-		return false;
-	}
-
-	if (mSourceObject->isAvatar())
-	{
-		((LLVOAvatar*)(LLViewerObject*)mSourceObject)->setAnimationData("PointAtPoint", (void *)&mTargetPos);
-	}
-
-	return true;
+    LLViewerObject *targetObject = (LLViewerObject *)mTargetObject;
+    LLVector3 local_offset;
+
+    if (targetObject)
+    {
+        local_offset.setVec(mTargetOffsetGlobal);
+    }
+    else
+    {
+        local_offset = gAgent.getPosAgentFromGlobal(mTargetOffsetGlobal);
+    }
+
+    if (targetObject && targetObject->mDrawable.notNull())
+    {
+        LLQuaternion objRot;
+        if (targetObject->isAvatar())
+        {
+            LLVOAvatar *avatarp = (LLVOAvatar *)targetObject;
+            mTargetPos = avatarp->mHeadp->getWorldPosition();
+            objRot = avatarp->mPelvisp->getWorldRotation();
+        }
+        else
+        {
+            if (targetObject->mDrawable->getGeneration() == -1)
+            {
+                mTargetPos = targetObject->getPositionAgent();
+                objRot = targetObject->getWorldRotation();
+            }
+            else
+            {
+                mTargetPos = targetObject->getRenderPosition();
+                objRot = targetObject->getRenderRotation();
+            }
+        }
+
+        mTargetPos += (local_offset * objRot);
+    }
+    else
+    {
+        mTargetPos = local_offset;
+    }
+
+    mTargetPos -= mSourceObject->getRenderPosition();
+
+    if (!llfinite(mTargetPos.lengthSquared()))
+    {
+        return false;
+    }
+
+    if (mSourceObject->isAvatar())
+    {
+        ((LLVOAvatar*)(LLViewerObject*)mSourceObject)->setAnimationData("PointAtPoint", (void *)&mTargetPos);
+    }
+
+    return true;
 }
 
 const LLVector3d LLHUDEffectPointAt::getPointAtPosGlobal()
 {
-	LLVector3d global_pos;
-	global_pos.setVec(mTargetPos);
-	if (mSourceObject.notNull())
-	{
-		global_pos += mSourceObject->getPositionGlobal();
-	}
-	
-	return global_pos;
+    LLVector3d global_pos;
+    global_pos.setVec(mTargetPos);
+    if (mSourceObject.notNull())
+    {
+        global_pos += mSourceObject->getPositionGlobal();
+    }
+
+    return global_pos;
 }