/** * @file lltracker.cpp * @brief Container for objects user is tracking. * * $LicenseInfo:firstyear=2003&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" // library includes #include "llcoord.h" #include "llfontgl.h" #include "llgl.h" #include "llrender.h" #include "llinventory.h" #include "llinventorydefines.h" #include "llpointer.h" #include "llstring.h" #include "lluuid.h" #include "v3math.h" #include "v3dmath.h" #include "v4color.h" // viewer includes #include "llappviewer.h" #include "lltracker.h" #include "llagent.h" #include "llagentcamera.h" #include "llcallingcard.h" #include "llfloaterworldmap.h" #include "llhudtext.h" #include "llhudview.h" #include "llinventorymodel.h" #include "llinventoryobserver.h" #include "lllandmarklist.h" #include "llprogressview.h" #include "llsky.h" #include "llui.h" #include "llviewercamera.h" #include "llviewerinventory.h" #include "llviewerwindow.h" #include "llworld.h" #include "llworldmapview.h" #include "llviewercontrol.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), mHasReachedLocation(FALSE) { } LLTracker::~LLTracker() { purgeBeaconText(); } // static void LLTracker::stopTracking(bool clear_ui) { instance()->stopTrackingAll(clear_ui); } // static virtual void LLTracker::drawHUDArrow() { if (!LLWorld::instanceExists()) { return; } static LLCachedControl<bool> render_beacon(gSavedSettings, "RenderTrackerBeacon", true); if (!render_beacon) { return; } if (gViewerWindow->getProgressView()->getVisible()) return; static LLUIColor map_track_color = LLUIColorTable::instance().getColor("MapTrackColor", LLColor4::white); /* tracking autopilot destination has been disabled -- 2004.01.09, Leviathan // Draw dot for autopilot target if (gAgent.getAutoPilot()) { instance()->drawMarker( gAgent.getAutoPilotTargetGlobal(), map_track_color ); return; } */ switch (getTrackingStatus()) { case TRACKING_AVATAR: // Tracked avatar if(LLAvatarTracker::instance().haveTrackingInfo()) { instance()->drawMarker( LLAvatarTracker::instance().getGlobalPos(), map_track_color ); } break; case TRACKING_LANDMARK: instance()->drawMarker( getTrackedPositionGlobal(), map_track_color ); break; case TRACKING_LOCATION: // 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 * (LLWorld::getInstance()->resolveLandHeightGlobal(getTrackedPositionGlobal()) + 1.5f); #endif instance()->mTrackedPositionGlobal.mdV[VZ] = llclamp((F32)instance()->mTrackedPositionGlobal.mdV[VZ], LLWorld::getInstance()->resolveLandHeightGlobal(getTrackedPositionGlobal()) + 1.5f, (F32)instance()->getTrackedPositionGlobal().mdV[VZ]); instance()->drawMarker( getTrackedPositionGlobal(), map_track_color ); break; default: break; } } // static void LLTracker::render3D() { if (!gFloaterWorldMap || !gSavedSettings.getBOOL("RenderTrackerBeacon")) { return; } static LLUIColor map_track_color = LLUIColorTable::instance().getColor("MapTrackColor", LLColor4::white); static LLUIColor map_track_color_under = LLUIColorTable::instance().getColor("MapTrackColorUnder", LLColor4::white); // 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(false,true); } else { renderBeacon( instance()->mTrackedPositionGlobal, map_track_color, map_track_color_under, 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, map_track_color, map_track_color_under, 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()->getTrackedPositionGlobal(), 0.0f); if (dist < DESTINATION_REACHED_RADIUS) { instance()->stopTrackingAvatar(); } else { renderBeacon( av_tracker.getGlobalPos(), map_track_color, map_track_color_under, 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 std::string& name ) { instance()->stopTrackingLandmark(); instance()->stopTrackingLocation(); LLAvatarTracker::instance().track( avatar_id, name ); instance()->mTrackingStatus = TRACKING_AVATAR; instance()->mLabel = name; instance()->mToolTip = ""; } // static void LLTracker::trackLandmark( const LLUUID& asset_id, const LLUUID& item_id, const std::string& 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; instance()->mToolTip = ""; } // static void LLTracker::trackLocation(const LLVector3d& pos_global, const std::string& full_name, const std::string& 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 std::string& LLTracker::getTrackedLocationName() { return instance()->mTrackedLocationName; } F32 pulse_func(F32 t, F32 z, bool tracking_avatar, std::string direction) { if (!LLTracker::sCheesyBeacon) { return 0.f; } t *= F_PI; if ("DOWN" == direction) { z += t*64.f - 256.f; } else { z -= t*64.f - 256.f; } F32 a = cosf(z*F_PI/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/F_PI; 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); gGL.begin(LLRender::TRIANGLE_FAN); gGL.color4fv(ccol.mV); gGL.vertex3f(0.f, 0.f, center_z); // make sure circle is complete steps += 1; color.mV[3] = (1.f-t*t); gGL.color4fv(color.mV); while( steps-- ) { // Successive rotations gGL.vertex3f( x, y, center_z ); F32 x_new = x * cos_delta - y * sin_delta; y = x * sin_delta + y * cos_delta; x = x_new; } gGL.end(); } void LLTracker::drawBeacon(LLVector3 pos_agent, std::string direction, LLColor4 fogged_color, F32 dist) { const U32 BEACON_VERTS = 256; F32 step; gGL.matrixMode(LLRender::MM_MODELVIEW); gGL.pushMatrix(); if ("DOWN" == direction) { gGL.translatef(pos_agent.mV[0], pos_agent.mV[1], pos_agent.mV[2]); draw_shockwave(1024.f, gRenderStartTime.getElapsedTimeF32(), 32, fogged_color); step = (5020.0f - pos_agent.mV[2]) / BEACON_VERTS; } else { gGL.translatef(pos_agent.mV[0], pos_agent.mV[1], 0); step = pos_agent.mV[2] / BEACON_VERTS; } gGL.color4fv(fogged_color.mV); LLVector3 x_axis = LLViewerCamera::getInstance()->getLeftAxis(); F32 t = gRenderStartTime.getElapsedTimeF32(); 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; bool tracking_avatar = getTrackingStatus() == TRACKING_AVATAR; F32 a = pulse_func(t, z, tracking_avatar, direction); F32 an = pulse_func(t, z_next, tracking_avatar, direction); 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; an *= 2.f; an += 1.0f; gGL.begin(LLRender::TRIANGLE_STRIP); gGL.color4fv(col_edge.mV); gGL.vertex3f(-x*a, -y*a, z); gGL.color4fv(col_edge_next.mV); gGL.vertex3f(-x*an, -y*an, z_next); gGL.color4fv(c_col.mV); gGL.vertex3f(0, 0, z); gGL.color4fv(col_next.mV); gGL.vertex3f(0, 0, z_next); gGL.color4fv(col_edge.mV); gGL.vertex3f(x*a,y*a,z); gGL.color4fv(col_edge_next.mV); gGL.vertex3f(x*an,y*an,z_next); gGL.end(); } gGL.popMatrix(); } // static void LLTracker::renderBeacon(LLVector3d pos_global, const LLColor4& color, const LLColor4& color_under, LLHUDText* hud_textp, const std::string& label ) { sCheesyBeacon = gSavedSettings.getBOOL("CheesyBeacon"); LLVector3d to_vec = pos_global - gAgentCamera.getCameraPositionGlobal(); F32 dist = (F32)to_vec.magVec(); F32 color_frac = 1.f; if (dist > 0.99f * LLViewerCamera::getInstance()->getFar()) { color_frac = 0.4f; // pos_global = gAgentCamera.getCameraPositionGlobal() + 0.99f*(LLViewerCamera::getInstance()->getFar()/dist)*to_vec; } else { color_frac = 1.f - 0.6f*(dist/LLViewerCamera::getInstance()->getFar()); } LLColor4 fogged_color = color_frac * color + (1 - color_frac)*gSky.getSkyFogColor(); LLColor4 fogged_color_under = color_frac * color_under + (1 - color_frac) * gSky.getSkyFogColor(); F32 FADE_DIST = 3.f; fogged_color.mV[3] = llmax(0.2f, llmin(0.5f,(dist-FADE_DIST)/FADE_DIST)); fogged_color_under.mV[3] = llmax(0.2f, llmin(0.5f,(dist-FADE_DIST)/FADE_DIST)); LLVector3 pos_agent = gAgent.getPosAgentFromGlobal(pos_global); LLGLSTracker gls_tracker; gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE); LLGLDisable cull_face(GL_CULL_FACE); LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE); LLTracker::drawBeacon(pos_agent, "DOWN", fogged_color, dist); LLTracker::drawBeacon(pos_agent, "UP", fogged_color_under, dist); std::string text; text = llformat( "%.0f m", to_vec.magVec()); std::string str; str += label; str += '\n'; str += text; hud_textp->setFont(LLFontGL::getFontSansSerif()); 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(str); 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, bool dest_reached) { purgeBeaconText(); mTrackedLocationName.assign(""); mIsTrackingLocation = FALSE; mTrackedPositionGlobal.zeroVec(); gFloaterWorldMap->clearLocationSelection(clear_ui, dest_reached); mTrackingStatus = TRACKING_NOTHING; mTrackingLocationType = LOCATION_NOTHING; } void LLTracker::clearFocus() { instance()->mTrackingStatus = TRACKING_NOTHING; } void LLTracker::drawMarker(const LLVector3d& pos_global, const LLColor4& color) { // 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 (LLViewerCamera::getInstance()->projectPosAgentToScreen(pos_local, screen, CLAMP) || LLViewerCamera::getInstance()->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->getImage(), color); } } void LLTracker::setLandmarkVisited() { // poke the inventory item if (!mTrackedLandmarkItemID.isNull()) { LLInventoryItem* i = gInventory.getItem( mTrackedLandmarkItemID ); LLViewerInventoryItem* item = (LLViewerInventoryItem*)i; if ( item && !(item->getFlags()&LLInventoryItemFlags::II_FLAGS_LANDMARK_VISITED)) { U32 flags = item->getFlags(); flags |= LLInventoryItemFlags::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 { LL_WARNS() << "LLTracker couldn't find home pos" << LL_ENDL; 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()&LLInventoryItemFlags::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; } }