lltracker.cpp

Go to the documentation of this file.

#include "llviewerprecompiledheaders.h"

// library includes
#include "llcoord.h"
#include "lldarray.h"
#include "llfontgl.h"
#include "llgl.h"
#include "llinventory.h"
#include "llmemory.h"
#include "llstring.h"
#include "lluuid.h"
#include "v3math.h"
#include "v3dmath.h"
#include "v4color.h"

// viewer includes
#include "viewer.h"
#include "lltracker.h"
#include "llagent.h"
#include "llcallingcard.h"
#include "llcolorscheme.h"
#include "llcylinder.h"
#include "llfloaterworldmap.h"
#include "llhudtext.h"
#include "llhudview.h"
#include "llinventorymodel.h"
#include "lllandmarklist.h"
#include "llsky.h"
#include "llui.h"
#include "llviewercamera.h"
#include "llviewerinventory.h"
#include "llworld.h"
#include "llworldmapview.h"

const F32 DESTINATION_REACHED_RADIUS    = 3.0f;
const F32 DESTINATION_VISITED_RADIUS    = 6.0f;

// this last one is useful for when the landmark is
// very close to agent when tracking is turned on
const F32 DESTINATION_UNVISITED_RADIUS = 12.0f;

const S32 ARROW_OFF_RADIUS_SQRD = 100;

const S32 HUD_ARROW_SIZE = 32;

// static
LLTracker *LLTracker::sTrackerp = NULL;
BOOL LLTracker::sCheesyBeacon = FALSE;

LLTracker::LLTracker()
:       mTrackingStatus(TRACKING_NOTHING),
        mTrackingLocationType(LOCATION_NOTHING),
        mHUDArrowCenterX(0),
        mHUDArrowCenterY(0),
        mToolTip( "" ),
        mTrackedLandmarkName(""),
        mHasReachedLandmark(FALSE),
        mHasLandmarkPosition(FALSE),
        mLandmarkHasBeenVisited(FALSE),
        mTrackedLocationName( "" ),
        mIsTrackingLocation(FALSE)
{ }


LLTracker::~LLTracker()
{ 
        purgeBeaconText();
}


// static
void LLTracker::stopTracking(void* userdata)
{
        BOOL clear_ui = ((BOOL)(intptr_t)userdata);
        instance()->stopTrackingAll(clear_ui);
}


// static virtual
void LLTracker::drawHUDArrow()
{
        /* tracking autopilot destination has been disabled 
           -- 2004.01.09, Leviathan
        // Draw dot for autopilot target
        if (gAgent.getAutoPilot())
        {
                instance()->drawMarker( gAgent.getAutoPilotTargetGlobal(), gTrackColor );
                return;
        }
        */
        switch (getTrackingStatus())
        { 
        case TRACKING_AVATAR:
                // Tracked avatar
                if(LLAvatarTracker::instance().haveTrackingInfo())
                {
                        instance()->drawMarker( LLAvatarTracker::instance().getGlobalPos(), gTrackColor );
                } 
                break;

        case TRACKING_LANDMARK:
                instance()->drawMarker( getTrackedPositionGlobal(), gTrackColor );
                break;

        case TRACKING_LOCATION:
                if (!gWorldp)
                {
                        break;
                }
                // HACK -- try to keep the location just above the terrain
#if 0
                // UNHACKED by CRO - keep location where the location is
                instance()->mTrackedPositionGlobal.mdV[VZ] = 
                                0.9f * instance()->mTrackedPositionGlobal.mdV[VZ]
                                + 0.1f * (gWorldp->resolveLandHeightGlobal(getTrackedPositionGlobal()) + 1.5f);
#endif
                instance()->mTrackedPositionGlobal.mdV[VZ] = llclamp((F32)instance()->mTrackedPositionGlobal.mdV[VZ], gWorldp->resolveLandHeightGlobal(getTrackedPositionGlobal()) + 1.5f, (F32)instance()->getTrackedPositionGlobal().mdV[VZ]);
                instance()->drawMarker( getTrackedPositionGlobal(), gTrackColor );
                break;

        default:
                break;
        }
}


// static 
void LLTracker::render3D()
{
        if (!gFloaterWorldMap)
        {
                return;
        }

        // Arbitary location beacon
        if( instance()->mIsTrackingLocation )
        {
                if (!instance()->mBeaconText)
                {
                        instance()->mBeaconText = (LLHUDText *)LLHUDObject::addHUDObject(LLHUDObject::LL_HUD_TEXT);
                        instance()->mBeaconText->setDoFade(FALSE);
                }

                LLVector3d pos_global = instance()->mTrackedPositionGlobal;
                // (z-attenuation < 1) means compute "shorter" distance in z-axis,
                // so cancel tracking even if avatar is a little above or below.
                F32 dist = gFloaterWorldMap->getDistanceToDestination(pos_global, 0.5f);
                if (dist < DESTINATION_REACHED_RADIUS)
                {
                        instance()->stopTrackingLocation();
                }
                else
                {
                        renderBeacon( instance()->mTrackedPositionGlobal, gTrackColor, 
                                                instance()->mBeaconText, instance()->mTrackedLocationName );
                }
        }

        // Landmark beacon
        else if( !instance()->mTrackedLandmarkAssetID.isNull() )
        {
                if (!instance()->mBeaconText)
                {
                        instance()->mBeaconText = (LLHUDText *)LLHUDObject::addHUDObject(LLHUDObject::LL_HUD_TEXT);
                        instance()->mBeaconText->setDoFade(FALSE);
                }

                if (instance()->mHasLandmarkPosition)
                {
                        F32 dist = gFloaterWorldMap->getDistanceToDestination(instance()->mTrackedPositionGlobal, 1.0f);

                        if (   !instance()->mLandmarkHasBeenVisited
                                && dist < DESTINATION_VISITED_RADIUS )
                        {
                                // its close enough ==> flag as visited
                                instance()->setLandmarkVisited();
                        }

                        if (   !instance()->mHasReachedLandmark 
                                && dist < DESTINATION_REACHED_RADIUS )
                        {
                                // its VERY CLOSE ==> automatically stop tracking
                                instance()->stopTrackingLandmark();
                        }
                        else
                        {
                                if (    instance()->mHasReachedLandmark 
                                         && dist > DESTINATION_UNVISITED_RADIUS )
                                {
                                        // this is so that landmark beacons don't immediately 
                                        // disappear when they're created only a few meters 
                                        // away, yet disappear when the agent wanders away 
                                        // and back again
                                        instance()->mHasReachedLandmark = FALSE;
                                }
                                renderBeacon( instance()->mTrackedPositionGlobal, gTrackColor, 
                                                          instance()->mBeaconText, instance()->mTrackedLandmarkName );
                        }
                }
                else
                {
                        // probably just finished downloading the asset
                        instance()->cacheLandmarkPosition();
                }
        }
        else
        {
                // Avatar beacon
                LLAvatarTracker& av_tracker = LLAvatarTracker::instance();
                if(av_tracker.haveTrackingInfo())
                {
                        if (!instance()->mBeaconText)
                        {
                                instance()->mBeaconText = (LLHUDText *)LLHUDObject::addHUDObject(LLHUDObject::LL_HUD_TEXT);
                                instance()->mBeaconText->setDoFade(FALSE);
                        }
                        
                        F32 dist = gFloaterWorldMap->getDistanceToDestination(instance()->mTrackedPositionGlobal, 0.0f);
                        if (dist < DESTINATION_REACHED_RADIUS)
                        {
                                instance()->stopTrackingAvatar();
                        }
                        else
                        {
                                renderBeacon( av_tracker.getGlobalPos(), gTrackColor, 
                                                        instance()->mBeaconText, av_tracker.getName() );
                        }
                }
                else
                {
                        BOOL stop_tracking = FALSE;
                        const LLUUID& avatar_id = av_tracker.getAvatarID();
                        if(avatar_id.isNull())
                        {
                                stop_tracking = TRUE;
                        }
                        else 
                        {
                                const LLRelationship* buddy = av_tracker.getBuddyInfo(avatar_id);
                                if(buddy && !buddy->isOnline() && !gAgent.isGodlike())
                                {
                                        stop_tracking = TRUE;
                                }
                                if(!buddy && !gAgent.isGodlike())
                                {
                                        stop_tracking = TRUE;
                                }
                        }
                        if(stop_tracking)
                        {
                                instance()->stopTrackingAvatar();
                        }
                }
        }
}


// static 
void LLTracker::trackAvatar( const LLUUID& avatar_id, const LLString& name )
{
        instance()->stopTrackingLandmark();
        instance()->stopTrackingLocation();
        
        LLAvatarTracker::instance().track( avatar_id, name );
        instance()->mTrackingStatus = TRACKING_AVATAR;
        instance()->mLabel = name;
}


// static 
void LLTracker::trackLandmark( const LLUUID& asset_id, const LLUUID& item_id, const LLString& name)
{
        instance()->stopTrackingAvatar();
        instance()->stopTrackingLocation();
        
        instance()->mTrackedLandmarkAssetID = asset_id;
        instance()->mTrackedLandmarkItemID = item_id;
        instance()->mTrackedLandmarkName = name;
        instance()->cacheLandmarkPosition();
        instance()->mTrackingStatus = TRACKING_LANDMARK;
        instance()->mLabel = name;
}


// static 
void LLTracker::trackLocation(const LLVector3d& pos_global, const LLString& full_name, const LLString& tooltip, ETrackingLocationType location_type)
{
        instance()->stopTrackingAvatar();
        instance()->stopTrackingLandmark();

        instance()->mTrackedPositionGlobal = pos_global;
        instance()->mTrackedLocationName = full_name;
        instance()->mIsTrackingLocation = TRUE;
        instance()->mTrackingStatus = TRACKING_LOCATION;
        instance()->mTrackingLocationType = location_type;
        instance()->mLabel = full_name;
        instance()->mToolTip = tooltip;
}


// static 
BOOL LLTracker::handleMouseDown(S32 x, S32 y)
{
        BOOL eat_mouse_click = FALSE;
        // fortunately, we can always compute the tracking arrow center
        S32 dist_sqrd = (x - instance()->mHUDArrowCenterX) * (x - instance()->mHUDArrowCenterX) + 
                                        (y - instance()->mHUDArrowCenterY) * (y - instance()->mHUDArrowCenterY);
        if (dist_sqrd < ARROW_OFF_RADIUS_SQRD)
        {
                /* tracking autopilot destination has been disabled
                   -- 2004.01.09, Leviathan
                // turn off tracking
                if (gAgent.getAutoPilot())
                {
                        gAgent.stopAutoPilot(TRUE);     // TRUE because cancelled by user
                        eat_mouse_click = TRUE;
                }
                */
                if (getTrackingStatus())
                {
                        instance()->stopTrackingAll();
                        eat_mouse_click = TRUE;
                }
        }
        return eat_mouse_click;
}


// static 
LLVector3d LLTracker::getTrackedPositionGlobal()
{
        LLVector3d pos_global;
        switch (getTrackingStatus())
        {
        case TRACKING_AVATAR:
        {
                LLAvatarTracker& av_tracker = LLAvatarTracker::instance();
                if (av_tracker.haveTrackingInfo())
                {
                        pos_global = av_tracker.getGlobalPos(); }
                break;
        }
        case TRACKING_LANDMARK:
                if( instance()->mHasLandmarkPosition )
                {
                        pos_global = instance()->mTrackedPositionGlobal;
                }
                break;
        case TRACKING_LOCATION:
                pos_global = instance()->mTrackedPositionGlobal;
                break;
        default:
                break;
        }
        return pos_global;
}


// static
BOOL LLTracker::hasLandmarkPosition()
{
        if (!instance()->mHasLandmarkPosition)
        {
                // maybe we just received the landmark position info
                instance()->cacheLandmarkPosition();
        }
        return instance()->mHasLandmarkPosition;
}


// static
const LLString& LLTracker::getTrackedLocationName()
{
        return instance()->mTrackedLocationName;
}

F32 pulse_func(F32 t, F32 z)
{
        if (!LLTracker::sCheesyBeacon)
        {
                return 0.f;
        }
        
        t *= 3.14159f;
        z -= t*64.f - 256.f;
        
        F32 a = cosf(z*3.14159/512.f)*10.0f;
        a = llmax(a, 9.9f);
        a -= 9.9f;
        a *= 10.f;
        return a;
}

void draw_shockwave(F32 center_z, F32 t, S32 steps, LLColor4 color)
{
        if (!LLTracker::sCheesyBeacon)
        {
                return;
        }
        
        t *= 0.6284f/3.14159f;
        
        t -= (F32) (S32) t;     

        t = llmax(t, 0.5f);
        t -= 0.5f;
        t *= 2.0f;
        
        F32 radius = t*16536.f;
        
        // Inexact, but reasonably fast.
        F32 delta = F_TWO_PI / steps;
        F32 sin_delta = sin( delta );
        F32 cos_delta = cos( delta );
        F32 x = radius;
        F32 y = 0.f;

        LLColor4 ccol = LLColor4(1,1,1,(1.f-t)*0.25f);
        glBegin(GL_TRIANGLE_FAN);
        glColor4fv(ccol.mV);
        glVertex3f(0.f, 0.f, center_z);
        // make sure circle is complete
        steps += 1;
        
        color.mV[3] = (1.f-t*t);
        
        glColor4fv(color.mV);
        while( steps-- )
        {
                // Successive rotations
                glVertex3f( x, y, center_z );
                F32 x_new = x * cos_delta - y * sin_delta;
                y = x * sin_delta +  y * cos_delta;
                x = x_new;
        }
        glEnd();
}


// static 
void LLTracker::renderBeacon(LLVector3d pos_global, 
                                                         const LLColor4& color, 
                                                         LLHUDText* hud_textp, 
                                                         const std::string& label )
{
        sCheesyBeacon = gSavedSettings.getBOOL("CheesyBeacon");
        LLVector3d to_vec = pos_global - gAgent.getCameraPositionGlobal();

        F32 dist = (F32)to_vec.magVec();
        F32 color_frac = 1.f;
        if (dist > 0.99f * gCamera->getFar())
        {
                color_frac = 0.4f;
        //      pos_global = gAgent.getCameraPositionGlobal() + 0.99f*(gCamera->getFar()/dist)*to_vec;
        }
        else
        {
                color_frac = 1.f - 0.6f*(dist/gCamera->getFar());
        }

        LLColor4 fogged_color = color_frac * color + (1 - color_frac)*gSky.getFogColor();

        F32 FADE_DIST = 3.f;
        fogged_color.mV[3] = llmax(0.2f, llmin(0.5f,(dist-FADE_DIST)/FADE_DIST));

        LLVector3 pos_agent = gAgent.getPosAgentFromGlobal(pos_global);

        LLGLSTracker gls_tracker; // default - TEXTURE + CULL_FACE + LIGHTING + GL_BLEND + GL_ALPHA_TEST
        LLGLDisable cull_face(GL_CULL_FACE);
        LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
        
        
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
                glTranslatef(pos_agent.mV[0], pos_agent.mV[1], pos_agent.mV[2]);
                
                draw_shockwave(1024.f, gRenderStartTime.getElapsedTimeF32(), 32, fogged_color);

                //glScalef(1.f, 1.f, 1000.f);
                glColor4fv(fogged_color.mV);
                const U32 BEACON_VERTS = 256;
                const F32 step = 1024.0f/BEACON_VERTS;
                
                LLVector3 x_axis = gCamera->getLeftAxis();
                F32 t = gRenderStartTime.getElapsedTimeF32();
                F32 dr = dist/gCamera->getFar();
                
                for (U32 i = 0; i < BEACON_VERTS; i++)
                {
                        F32 x = x_axis.mV[0];
                        F32 y = x_axis.mV[1];
                        
                        F32 z = i * step;
                        F32 z_next = (i+1)*step;
                
                        F32 a = pulse_func(t, z);
                        F32 an = pulse_func(t, z_next);
                        
                        LLColor4 c_col = fogged_color + LLColor4(a,a,a,a);
                        LLColor4 col_next = fogged_color + LLColor4(an,an,an,an);
                        LLColor4 col_edge = fogged_color * LLColor4(a,a,a,0.0f);
                        LLColor4 col_edge_next = fogged_color * LLColor4(an,an,an,0.0f);
                        
                        a *= 2.f;
                        a += 1.0f+dr;
                        
                        an *= 2.f;
                        an += 1.0f+dr;
                
                        glBegin(GL_TRIANGLE_STRIP);
                        glColor4fv(col_edge.mV);
                        glVertex3f(-x*a, -y*a, z);
                        glColor4fv(col_edge_next.mV);
                        glVertex3f(-x*an, -y*an, z_next);
                        
                        glColor4fv(c_col.mV);
                        glVertex3f(0, 0, z);
                        glColor4fv(col_next.mV);
                        glVertex3f(0, 0, z_next);
                        
                        glColor4fv(col_edge.mV);
                        glVertex3f(x*a,y*a,z);
                        glColor4fv(col_edge_next.mV);
                        glVertex3f(x*an,y*an,z_next);
                        
                        glEnd();
                }
                                                        
                //gCylinder.render(1000);
        glPopMatrix();

        char text[1024];                /* Flawfinder: ignore */
        snprintf(text, sizeof(text), "%.0f m", to_vec.magVec());                /* Flawfinder: ignore */

        LLWString wstr;
        wstr += utf8str_to_wstring(label);
        wstr += '\n';
        wstr += utf8str_to_wstring(text);

        hud_textp->setFont(LLFontGL::sSansSerif);
        hud_textp->setZCompare(FALSE);
        hud_textp->setColor(LLColor4(1.f, 1.f, 1.f, llmax(0.2f, llmin(1.f,(dist-FADE_DIST)/FADE_DIST))));

        hud_textp->setString(wstr);
        hud_textp->setVertAlignment(LLHUDText::ALIGN_VERT_CENTER);
        hud_textp->setPositionAgent(pos_agent);
}


void LLTracker::stopTrackingAll(BOOL clear_ui)
{
        switch (mTrackingStatus)
        {
        case TRACKING_AVATAR :
                stopTrackingAvatar(clear_ui);
                break;
        case TRACKING_LANDMARK :
                stopTrackingLandmark(clear_ui);
                break;
        case TRACKING_LOCATION :
                stopTrackingLocation(clear_ui);
                break;
        default:
                mTrackingStatus = TRACKING_NOTHING;
                break;
        }
}


void LLTracker::stopTrackingAvatar(BOOL clear_ui)
{
        LLAvatarTracker& av_tracker = LLAvatarTracker::instance();
        if( !av_tracker.getAvatarID().isNull() )
        {
                av_tracker.untrack( av_tracker.getAvatarID() );
        }

        purgeBeaconText();
        gFloaterWorldMap->clearAvatarSelection(clear_ui);
        mTrackingStatus = TRACKING_NOTHING;
}


void LLTracker::stopTrackingLandmark(BOOL clear_ui)
{
        purgeBeaconText();
        mTrackedLandmarkAssetID.setNull();
        mTrackedLandmarkItemID.setNull();
        mTrackedLandmarkName.assign("");
        mTrackedPositionGlobal.zeroVec();
        mHasLandmarkPosition = FALSE;
        mHasReachedLandmark = FALSE;
        mLandmarkHasBeenVisited = TRUE;
        gFloaterWorldMap->clearLandmarkSelection(clear_ui);
        mTrackingStatus = TRACKING_NOTHING;
}


void LLTracker::stopTrackingLocation(BOOL clear_ui)
{
        purgeBeaconText();
        mTrackedLocationName.assign("");
        mIsTrackingLocation = FALSE;
        mTrackedPositionGlobal.zeroVec();
        gFloaterWorldMap->clearLocationSelection(clear_ui);
        mTrackingStatus = TRACKING_NOTHING;
        mTrackingLocationType = LOCATION_NOTHING;
}


void LLTracker::drawMarker(const LLVector3d& pos_global, const LLColor4& color)
{
        if (!gCamera) 
        {
                return;
        }

        // get position
        LLVector3 pos_local = gAgent.getPosAgentFromGlobal(pos_global);

        // check in frustum
        LLCoordGL screen;
        S32 x = 0;
        S32 y = 0;
        const BOOL CLAMP = TRUE;

        if (gCamera->projectPosAgentToScreen(pos_local, screen, CLAMP)
                || gCamera->projectPosAgentToScreenEdge(pos_local, screen) )
        {
                gHUDView->screenPointToLocal(screen.mX, screen.mY, &x, &y);

                // the center of the rendered position of the arrow obeys 
                // the following rules:
                // (1) it lies on an ellipse centered on the target position 
                // (2) it lies on the line between the target and the window center
                // (3) right now the radii of the ellipse are fixed, but eventually
                //     they will be a function of the target text
                // 
                // from those rules we can compute the position of the 
                // lower left corner of the image
                LLRect rect = gHUDView->getRect();
                S32 x_center = lltrunc(0.5f * (F32)rect.getWidth());
                S32 y_center = lltrunc(0.5f * (F32)rect.getHeight());
                x = x - x_center;       // x and y relative to center
                y = y - y_center;
                F32 dist = sqrt((F32)(x*x + y*y));
                S32 half_arrow_size = lltrunc(0.5f * HUD_ARROW_SIZE);
                if (dist > 0.f)
                {
                        const F32 ARROW_ELLIPSE_RADIUS_X = 2 * HUD_ARROW_SIZE;
                        const F32 ARROW_ELLIPSE_RADIUS_Y = HUD_ARROW_SIZE;

                        // compute where the arrow should be
                        F32 x_target = (F32)(x + x_center) - (ARROW_ELLIPSE_RADIUS_X * ((F32)x / dist) );       
                        F32 y_target = (F32)(y + y_center) - (ARROW_ELLIPSE_RADIUS_Y * ((F32)y / dist) );

                        // keep the arrow within the window
                        F32 x_clamped = llclamp( x_target, (F32)half_arrow_size, (F32)(rect.getWidth() - half_arrow_size));
                        F32 y_clamped = llclamp( y_target, (F32)half_arrow_size, (F32)(rect.getHeight() - half_arrow_size));

                        F32 slope = (F32)(y) / (F32)(x);
                        F32 window_ratio = (F32)(rect.getHeight() - HUD_ARROW_SIZE) / (F32)(rect.getWidth() - HUD_ARROW_SIZE);

                        // if the arrow has been clamped on one axis
                        // then we need to compute the other axis
                        if (llabs(slope) > window_ratio)
                        {  
                                if (y_clamped != (F32)y_target)
                                {
                                        // clamp by y 
                                        x_clamped = (y_clamped - (F32)y_center) / slope + (F32)x_center;
                                }
                        }
                        else if (x_clamped != (F32)x_target)
                        {
                                // clamp by x
                                y_clamped = (x_clamped - (F32)x_center) * slope + (F32)y_center;
                        }
                        mHUDArrowCenterX = lltrunc(x_clamped);
                        mHUDArrowCenterY = lltrunc(y_clamped);
                }
                else
                {
                        // recycle the old values
                        x = mHUDArrowCenterX - x_center;
                        y = mHUDArrowCenterY - y_center;
                }

                F32 angle = atan2( (F32)y, (F32)x );

                gl_draw_scaled_rotated_image(mHUDArrowCenterX - half_arrow_size, 
                                                                         mHUDArrowCenterY - half_arrow_size, 
                                                                         HUD_ARROW_SIZE, HUD_ARROW_SIZE, 
                                                                         RAD_TO_DEG * angle, 
                                                                         LLWorldMapView::sTrackArrowImage, 
                                                                         color);
        }
}


void LLTracker::setLandmarkVisited()
{
        // poke the inventory item
        if (!mTrackedLandmarkItemID.isNull())
        {
                LLInventoryItem* i = gInventory.getItem( mTrackedLandmarkItemID );
                LLViewerInventoryItem* item = (LLViewerInventoryItem*)i;
                if (   item 
                        && !(item->getFlags()&LLInventoryItem::II_FLAGS_LANDMARK_VISITED))
                {
                        U32 flags = item->getFlags();
                        flags |= LLInventoryItem::II_FLAGS_LANDMARK_VISITED;
                        item->setFlags(flags);
                        LLMessageSystem* msg = gMessageSystem;
                        msg->newMessage("ChangeInventoryItemFlags");
                        msg->nextBlock("AgentData");
                        msg->addUUID("AgentID", gAgent.getID());
                        msg->addUUID("SessionID", gAgent.getSessionID());
                        msg->nextBlock("InventoryData");
                        msg->addUUID("ItemID", mTrackedLandmarkItemID);
                        msg->addU32("Flags", flags);
                        gAgent.sendReliableMessage();

                        LLInventoryModel::LLCategoryUpdate up(item->getParentUUID(), 0);
                        gInventory.accountForUpdate(up);

                        // need to communicate that the icon needs to change...
                        gInventory.addChangedMask(LLInventoryObserver::INTERNAL, item->getUUID());
                        gInventory.notifyObservers();
                }
        }
}


void LLTracker::cacheLandmarkPosition()
{
        // the landmark asset download may have finished, in which case
        // we'll now be able to figure out where we're trying to go
        BOOL found_landmark = FALSE;
        if( mTrackedLandmarkAssetID == LLFloaterWorldMap::getHomeID())
        {
                LLVector3d pos_global;
                if ( gAgent.getHomePosGlobal( &mTrackedPositionGlobal ))
                {
                        found_landmark = TRUE;
                }
                else
                {
                        llwarns << "LLTracker couldn't find home pos" << llendl;
                        mTrackedLandmarkAssetID.setNull();
                        mTrackedLandmarkItemID.setNull();
                }
        }
        else
        {
                LLLandmark* landmark = gLandmarkList.getAsset(mTrackedLandmarkAssetID);
                if(landmark && landmark->getGlobalPos(mTrackedPositionGlobal))
                {
                        found_landmark = TRUE;

                        // cache the object's visitation status
                        mLandmarkHasBeenVisited = FALSE;
                        LLInventoryItem* item = gInventory.getItem(mTrackedLandmarkItemID);
                        if (   item 
                                && item->getFlags()&LLInventoryItem::II_FLAGS_LANDMARK_VISITED)
                        {
                                mLandmarkHasBeenVisited = TRUE;
                        }
                }
        }
        if ( found_landmark && gFloaterWorldMap )
        {
                mHasReachedLandmark = FALSE;
                F32 dist = gFloaterWorldMap->getDistanceToDestination(mTrackedPositionGlobal, 1.0f);
                if ( dist < DESTINATION_UNVISITED_RADIUS )
                {
                        mHasReachedLandmark = TRUE;
                }
                mHasLandmarkPosition = TRUE;
        }
        mHasLandmarkPosition = found_landmark;
}


void LLTracker::purgeBeaconText()
{
        if(!mBeaconText.isNull())
        {
                mBeaconText->markDead();
                mBeaconText = NULL;
        }
}

---