开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
lltracker.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：22k
源码类别：

游戏引擎

开发平台：

C++ Builder

lltracker.cpp：源码内容
  1. /** 
  2.  * @file lltracker.cpp
  3.  * @brief Container for objects user is tracking.
  4.  *
  5.  * $LicenseInfo:firstyear=2003&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2003-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "llviewerprecompiledheaders.h"
  35. // library includes
  36. #include "llcoord.h"
  37. #include "lldarray.h"
  38. #include "llfontgl.h"
  39. #include "llgl.h"
  40. #include "llrender.h"
  41. #include "llinventory.h"
  42. #include "llpointer.h"
  43. #include "llstring.h"
  44. #include "lluuid.h"
  45. #include "v3math.h"
  46. #include "v3dmath.h"
  47. #include "v4color.h"
  49. // viewer includes
  50. #include "llappviewer.h"
  51. #include "lltracker.h"
  52. #include "llagent.h"
  53. #include "llcallingcard.h"
  54. #include "llfloaterworldmap.h"
  55. #include "llhudtext.h"
  56. #include "llhudview.h"
  57. #include "llinventorymodel.h"
  58. #include "llinventoryobserver.h"
  59. #include "lllandmarklist.h"
  60. #include "llsky.h"
  61. #include "llui.h"
  62. #include "llviewercamera.h"
  63. #include "llviewerinventory.h"
  64. #include "llworld.h"
  65. #include "llworldmapview.h"
  66. #include "llviewercontrol.h"
  68. const F32 DESTINATION_REACHED_RADIUS    = 3.0f;
  69. const F32 DESTINATION_VISITED_RADIUS    = 6.0f;
  71. // this last one is useful for when the landmark is
  72. // very close to agent when tracking is turned on
  73. const F32 DESTINATION_UNVISITED_RADIUS = 12.0f;
  75. const S32 ARROW_OFF_RADIUS_SQRD = 100;
  77. const S32 HUD_ARROW_SIZE = 32;
  79. // static
  80. LLTracker *LLTracker::sTrackerp = NULL;
  81. BOOL LLTracker::sCheesyBeacon = FALSE;
  83. LLTracker::LLTracker()
  84. : mTrackingStatus(TRACKING_NOTHING),
  85. mTrackingLocationType(LOCATION_NOTHING),
  86. mHUDArrowCenterX(0),
  87. mHUDArrowCenterY(0),
  88. mToolTip( "" ),
  89. mTrackedLandmarkName(""),
  90. mHasReachedLandmark(FALSE),
  91. mHasLandmarkPosition(FALSE),
  92. mLandmarkHasBeenVisited(FALSE),
  93. mTrackedLocationName( "" ),
  94. mIsTrackingLocation(FALSE),
  95. mHasReachedLocation(FALSE)
  96. { }
  99. LLTracker::~LLTracker()
  100. { 
  101. purgeBeaconText();
  102. }
  105. // static
  106. void LLTracker::stopTracking(void* userdata)
  107. {
  108. BOOL clear_ui = ((BOOL)(intptr_t)userdata);
  109. instance()->stopTrackingAll(clear_ui);
  110. }
  113. // static virtual
  114. void LLTracker::drawHUDArrow()
  115. {
  116. static LLUIColor map_track_color = LLUIColorTable::instance().getColor("MapTrackColor", LLColor4::white);
  118. /* tracking autopilot destination has been disabled 
  119.    -- 2004.01.09, Leviathan
  120. // Draw dot for autopilot target
  121. if (gAgent.getAutoPilot())
  122. {
  123. instance()->drawMarker( gAgent.getAutoPilotTargetGlobal(), map_track_color );
  124. return;
  125. }
  126. */
  127. switch (getTrackingStatus())
  128. { 
  129. case TRACKING_AVATAR:
  130. // Tracked avatar
  131. if(LLAvatarTracker::instance().haveTrackingInfo())
  132. {
  133. instance()->drawMarker( LLAvatarTracker::instance().getGlobalPos(), map_track_color );
  134. } 
  135. break;
  137. case TRACKING_LANDMARK:
  138. instance()->drawMarker( getTrackedPositionGlobal(), map_track_color );
  139. break;
  141. case TRACKING_LOCATION:
  142. // HACK -- try to keep the location just above the terrain
  143. #if 0
  144. // UNHACKED by CRO - keep location where the location is
  145. instance()->mTrackedPositionGlobal.mdV[VZ] = 
  146. 0.9f * instance()->mTrackedPositionGlobal.mdV[VZ]
  147. + 0.1f * (LLWorld::getInstance()->resolveLandHeightGlobal(getTrackedPositionGlobal()) + 1.5f);
  148. #endif
  149. instance()->mTrackedPositionGlobal.mdV[VZ] = llclamp((F32)instance()->mTrackedPositionGlobal.mdV[VZ], LLWorld::getInstance()->resolveLandHeightGlobal(getTrackedPositionGlobal()) + 1.5f, (F32)instance()->getTrackedPositionGlobal().mdV[VZ]);
  150. instance()->drawMarker( getTrackedPositionGlobal(), map_track_color );
  151. break;
  153. default:
  154. break;
  155. }
  156. }
  159. // static 
  160. void LLTracker::render3D()
  161. {
  162. if (!gFloaterWorldMap)
  163. {
  164. return;
  165. }
  167. static LLUIColor map_track_color = LLUIColorTable::instance().getColor("MapTrackColor", LLColor4::white);
  169. // Arbitary location beacon
  170. if( instance()->mIsTrackingLocation )
  171.   {
  172. if (!instance()->mBeaconText)
  173. {
  174. instance()->mBeaconText = (LLHUDText *)LLHUDObject::addHUDObject(LLHUDObject::LL_HUD_TEXT);
  175. instance()->mBeaconText->setDoFade(FALSE);
  176. }
  178. LLVector3d pos_global = instance()->mTrackedPositionGlobal;
  179. // (z-attenuation < 1) means compute "shorter" distance in z-axis,
  180. // so cancel tracking even if avatar is a little above or below.
  181. F32 dist = gFloaterWorldMap->getDistanceToDestination(pos_global, 0.5f);
  182. if (dist < DESTINATION_REACHED_RADIUS)
  183. {
  184. instance()->stopTrackingLocation();
  185. }
  186. else
  187. {
  188. renderBeacon( instance()->mTrackedPositionGlobal, map_track_color, 
  189.    instance()->mBeaconText, instance()->mTrackedLocationName );
  190. }
  191. }
  193. // Landmark beacon
  194. else if( !instance()->mTrackedLandmarkAssetID.isNull() )
  195. {
  196. if (!instance()->mBeaconText)
  197. {
  198. instance()->mBeaconText = (LLHUDText *)LLHUDObject::addHUDObject(LLHUDObject::LL_HUD_TEXT);
  199. instance()->mBeaconText->setDoFade(FALSE);
  200. }
  202. if (instance()->mHasLandmarkPosition)
  203. {
  204. F32 dist = gFloaterWorldMap->getDistanceToDestination(instance()->mTrackedPositionGlobal, 1.0f);
  206. if (   !instance()->mLandmarkHasBeenVisited
  207. && dist < DESTINATION_VISITED_RADIUS )
  208. {
  209. // its close enough ==> flag as visited
  210. instance()->setLandmarkVisited();
  211. }
  213. if (   !instance()->mHasReachedLandmark 
  214. && dist < DESTINATION_REACHED_RADIUS )
  215. {
  216. // its VERY CLOSE ==> automatically stop tracking
  217. instance()->stopTrackingLandmark();
  218. }
  219. else
  220. {
  221. if (    instance()->mHasReachedLandmark 
  222.  && dist > DESTINATION_UNVISITED_RADIUS )
  223. {
  224. // this is so that landmark beacons don't immediately 
  225. // disappear when they're created only a few meters 
  226. // away, yet disappear when the agent wanders away 
  227. // and back again
  228. instance()->mHasReachedLandmark = FALSE;
  229. }
  230. renderBeacon( instance()->mTrackedPositionGlobal, map_track_color, 
  231.   instance()->mBeaconText, instance()->mTrackedLandmarkName );
  232. }
  233. }
  234. else
  235. {
  236. // probably just finished downloading the asset
  237. instance()->cacheLandmarkPosition();
  238. }
  239. }
  240. else
  241. {
  242. // Avatar beacon
  243. LLAvatarTracker& av_tracker = LLAvatarTracker::instance();
  244. if(av_tracker.haveTrackingInfo())
  245. {
  246. if (!instance()->mBeaconText)
  247. {
  248. instance()->mBeaconText = (LLHUDText *)LLHUDObject::addHUDObject(LLHUDObject::LL_HUD_TEXT);
  249. instance()->mBeaconText->setDoFade(FALSE);
  250. }
  252. F32 dist = gFloaterWorldMap->getDistanceToDestination(instance()->mTrackedPositionGlobal, 0.0f);
  253. if (dist < DESTINATION_REACHED_RADIUS)
  254. {
  255. instance()->stopTrackingAvatar();
  256. }
  257. else
  258. {
  259. renderBeacon( av_tracker.getGlobalPos(), map_track_color, 
  260.    instance()->mBeaconText, av_tracker.getName() );
  261. }
  262. }
  263. else
  264. {
  265. BOOL stop_tracking = FALSE;
  266. const LLUUID& avatar_id = av_tracker.getAvatarID();
  267. if(avatar_id.isNull())
  268. {
  269. stop_tracking = TRUE;
  270. }
  271. else 
  272. {
  273. const LLRelationship* buddy = av_tracker.getBuddyInfo(avatar_id);
  274. if(buddy && !buddy->isOnline() && !gAgent.isGodlike())
  275. {
  276. stop_tracking = TRUE;
  277. }
  278. if(!buddy && !gAgent.isGodlike())
  279. {
  280. stop_tracking = TRUE;
  281. }
  282. }
  283. if(stop_tracking)
  284. {
  285. instance()->stopTrackingAvatar();
  286. }
  287. }
  288. }
  289. }
  292. // static 
  293. void LLTracker::trackAvatar( const LLUUID& avatar_id, const std::string& name )
  294. {
  295. instance()->stopTrackingLandmark();
  296. instance()->stopTrackingLocation();
  298. LLAvatarTracker::instance().track( avatar_id, name );
  299. instance()->mTrackingStatus = TRACKING_AVATAR;
  300. instance()->mLabel = name;
  301. instance()->mToolTip = "";
  302. }
  305. // static 
  306. void LLTracker::trackLandmark( const LLUUID& asset_id, const LLUUID& item_id, const std::string& name)
  307. {
  308. instance()->stopTrackingAvatar();
  309. instance()->stopTrackingLocation();
  311.   instance()->mTrackedLandmarkAssetID = asset_id;
  312.   instance()->mTrackedLandmarkItemID = item_id;
  313.   instance()->mTrackedLandmarkName = name;
  314. instance()->cacheLandmarkPosition();
  315. instance()->mTrackingStatus = TRACKING_LANDMARK;
  316. instance()->mLabel = name;
  317. instance()->mToolTip = "";
  318. }
  321. // static 
  322. void LLTracker::trackLocation(const LLVector3d& pos_global, const std::string& full_name, const std::string& tooltip, ETrackingLocationType location_type)
  323. {
  324. instance()->stopTrackingAvatar();
  325. instance()->stopTrackingLandmark();
  327. instance()->mTrackedPositionGlobal = pos_global;
  328. instance()->mTrackedLocationName = full_name;
  329. instance()->mIsTrackingLocation = TRUE;
  330. instance()->mTrackingStatus = TRACKING_LOCATION;
  331. instance()->mTrackingLocationType = location_type;
  332. instance()->mLabel = full_name;
  333. instance()->mToolTip = tooltip;
  334. }
  337. // static 
  338. BOOL LLTracker::handleMouseDown(S32 x, S32 y)
  339. {
  340. BOOL eat_mouse_click = FALSE;
  341. // fortunately, we can always compute the tracking arrow center
  342. S32 dist_sqrd = (x - instance()->mHUDArrowCenterX) * (x - instance()->mHUDArrowCenterX) + 
  343. (y - instance()->mHUDArrowCenterY) * (y - instance()->mHUDArrowCenterY);
  344. if (dist_sqrd < ARROW_OFF_RADIUS_SQRD)
  345. {
  346. /* tracking autopilot destination has been disabled
  347.    -- 2004.01.09, Leviathan
  348. // turn off tracking
  349. if (gAgent.getAutoPilot())
  350. {
  351. gAgent.stopAutoPilot(TRUE); // TRUE because cancelled by user
  352. eat_mouse_click = TRUE;
  353. }
  354. */
  355. if (getTrackingStatus())
  356. {
  357. instance()->stopTrackingAll();
  358. eat_mouse_click = TRUE;
  359. }
  360. }
  361. return eat_mouse_click;
  362. }
  365. // static 
  366. LLVector3d LLTracker::getTrackedPositionGlobal()
  367. {
  368. LLVector3d pos_global;
  369. switch (getTrackingStatus())
  370. {
  371. case TRACKING_AVATAR:
  372. {
  373. LLAvatarTracker& av_tracker = LLAvatarTracker::instance();
  374. if (av_tracker.haveTrackingInfo())
  375. {
  376. pos_global = av_tracker.getGlobalPos(); }
  377. break;
  378. }
  379. case TRACKING_LANDMARK:
  380. if( instance()->mHasLandmarkPosition )
  381. {
  382. pos_global = instance()->mTrackedPositionGlobal;
  383. }
  384. break;
  385. case TRACKING_LOCATION:
  386. pos_global = instance()->mTrackedPositionGlobal;
  387. break;
  388. default:
  389. break;
  390. }
  391. return pos_global;
  392. }
  395. // static
  396. BOOL LLTracker::hasLandmarkPosition()
  397. {
  398. if (!instance()->mHasLandmarkPosition)
  399. {
  400. // maybe we just received the landmark position info
  401. instance()->cacheLandmarkPosition();
  402. }
  403. return instance()->mHasLandmarkPosition;
  404. }
  407. // static
  408. const std::string& LLTracker::getTrackedLocationName()
  409. {
  410. return instance()->mTrackedLocationName;
  411. }
  413. F32 pulse_func(F32 t, F32 z)
  414. {
  415. if (!LLTracker::sCheesyBeacon)
  416. {
  417. return 0.f;
  418. }
  420. t *= F_PI;
  421. z -= t*64.f - 256.f;
  423. F32 a = cosf(z*F_PI/512.f)*10.0f;
  424. a = llmax(a, 9.9f);
  425. a -= 9.9f;
  426. a *= 10.f;
  427. return a;
  428. }
  430. void draw_shockwave(F32 center_z, F32 t, S32 steps, LLColor4 color)
  431. {
  432. if (!LLTracker::sCheesyBeacon)
  433. {
  434. return;
  435. }
  437. t *= 0.6284f/F_PI;
  439. t -= (F32) (S32) t;
  441. t = llmax(t, 0.5f);
  442. t -= 0.5f;
  443. t *= 2.0f;
  445. F32 radius = t*16536.f;
  447. // Inexact, but reasonably fast.
  448. F32 delta = F_TWO_PI / steps;
  449. F32 sin_delta = sin( delta );
  450. F32 cos_delta = cos( delta );
  451. F32 x = radius;
  452. F32 y = 0.f;
  454. LLColor4 ccol = LLColor4(1,1,1,(1.f-t)*0.25f);
  455. gGL.begin(LLRender::TRIANGLE_FAN);
  456. gGL.color4fv(ccol.mV);
  457. gGL.vertex3f(0.f, 0.f, center_z);
  458. // make sure circle is complete
  459. steps += 1;
  461. color.mV[3] = (1.f-t*t);
  463. gGL.color4fv(color.mV);
  464. while( steps-- )
  465. {
  466. // Successive rotations
  467. gGL.vertex3f( x, y, center_z );
  468. F32 x_new = x * cos_delta - y * sin_delta;
  469. y = x * sin_delta +  y * cos_delta;
  470. x = x_new;
  471. }
  472. gGL.end();
  473. }
  476. // static 
  477. void LLTracker::renderBeacon(LLVector3d pos_global, 
  478.  const LLColor4& color, 
  479.  LLHUDText* hud_textp, 
  480.  const std::string& label )
  481. {
  482. sCheesyBeacon = gSavedSettings.getBOOL("CheesyBeacon");
  483. LLVector3d to_vec = pos_global - gAgent.getCameraPositionGlobal();
  485. F32 dist = (F32)to_vec.magVec();
  486. F32 color_frac = 1.f;
  487. if (dist > 0.99f * LLViewerCamera::getInstance()->getFar())
  488. {
  489. color_frac = 0.4f;
  490. // pos_global = gAgent.getCameraPositionGlobal() + 0.99f*(LLViewerCamera::getInstance()->getFar()/dist)*to_vec;
  491. }
  492. else
  493. {
  494. color_frac = 1.f - 0.6f*(dist/LLViewerCamera::getInstance()->getFar());
  495. }
  497. LLColor4 fogged_color = color_frac * color + (1 - color_frac)*gSky.getFogColor();
  499. F32 FADE_DIST = 3.f;
  500. fogged_color.mV[3] = llmax(0.2f, llmin(0.5f,(dist-FADE_DIST)/FADE_DIST));
  502. LLVector3 pos_agent = gAgent.getPosAgentFromGlobal(pos_global);
  504. LLGLSTracker gls_tracker; // default+ CULL_FACE + LIGHTING + GL_BLEND + GL_ALPHA_TEST
  505. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  506. LLGLDisable cull_face(GL_CULL_FACE);
  507. LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
  510. glMatrixMode(GL_MODELVIEW);
  511. glPushMatrix();
  512. glTranslatef(pos_agent.mV[0], pos_agent.mV[1], pos_agent.mV[2]);
  514. draw_shockwave(1024.f, gRenderStartTime.getElapsedTimeF32(), 32, fogged_color);
  516. gGL.color4fv(fogged_color.mV);
  517. const U32 BEACON_VERTS = 256;
  518. const F32 step = 1024.0f/BEACON_VERTS;
  520. LLVector3 x_axis = LLViewerCamera::getInstance()->getLeftAxis();
  521. F32 t = gRenderStartTime.getElapsedTimeF32();
  522. F32 dr = dist/LLViewerCamera::getInstance()->getFar();
  524. for (U32 i = 0; i < BEACON_VERTS; i++)
  525. {
  526. F32 x = x_axis.mV[0];
  527. F32 y = x_axis.mV[1];
  529. F32 z = i * step;
  530. F32 z_next = (i+1)*step;
  532. F32 a = pulse_func(t, z);
  533. F32 an = pulse_func(t, z_next);
  535. LLColor4 c_col = fogged_color + LLColor4(a,a,a,a);
  536. LLColor4 col_next = fogged_color + LLColor4(an,an,an,an);
  537. LLColor4 col_edge = fogged_color * LLColor4(a,a,a,0.0f);
  538. LLColor4 col_edge_next = fogged_color * LLColor4(an,an,an,0.0f);
  540. a *= 2.f;
  541. a += 1.0f+dr;
  543. an *= 2.f;
  544. an += 1.0f+dr;
  546. gGL.begin(LLRender::TRIANGLE_STRIP);
  547. gGL.color4fv(col_edge.mV);
  548. gGL.vertex3f(-x*a, -y*a, z);
  549. gGL.color4fv(col_edge_next.mV);
  550. gGL.vertex3f(-x*an, -y*an, z_next);
  552. gGL.color4fv(c_col.mV);
  553. gGL.vertex3f(0, 0, z);
  554. gGL.color4fv(col_next.mV);
  555. gGL.vertex3f(0, 0, z_next);
  557. gGL.color4fv(col_edge.mV);
  558. gGL.vertex3f(x*a,y*a,z);
  559. gGL.color4fv(col_edge_next.mV);
  560. gGL.vertex3f(x*an,y*an,z_next);
  562. gGL.end();
  563. }
  565. //gCylinder.render(1000);
  566. glPopMatrix();
  568. std::string text;
  569. text = llformat( "%.0f m", to_vec.magVec());
  571. LLWString wstr;
  572. wstr += utf8str_to_wstring(label);
  573. wstr += 'n';
  574. wstr += utf8str_to_wstring(text);
  576. hud_textp->setFont(LLFontGL::getFontSansSerif());
  577. hud_textp->setZCompare(FALSE);
  578. hud_textp->setColor(LLColor4(1.f, 1.f, 1.f, llmax(0.2f, llmin(1.f,(dist-FADE_DIST)/FADE_DIST))));
  580. hud_textp->setString(wstr);
  581. hud_textp->setVertAlignment(LLHUDText::ALIGN_VERT_CENTER);
  582. hud_textp->setPositionAgent(pos_agent);
  583. }
  586. void LLTracker::stopTrackingAll(BOOL clear_ui)
  587. {
  588. switch (mTrackingStatus)
  589. {
  590. case TRACKING_AVATAR :
  591. stopTrackingAvatar(clear_ui);
  592. break;
  593. case TRACKING_LANDMARK :
  594. stopTrackingLandmark(clear_ui);
  595. break;
  596. case TRACKING_LOCATION :
  597. stopTrackingLocation(clear_ui);
  598. break;
  599. default:
  600. mTrackingStatus = TRACKING_NOTHING;
  601. break;
  602. }
  603. }
  606. void LLTracker::stopTrackingAvatar(BOOL clear_ui)
  607. {
  608. LLAvatarTracker& av_tracker = LLAvatarTracker::instance();
  609. if( !av_tracker.getAvatarID().isNull() )
  610. {
  611. av_tracker.untrack( av_tracker.getAvatarID() );
  612. }
  614. purgeBeaconText();
  615. gFloaterWorldMap->clearAvatarSelection(clear_ui);
  616. mTrackingStatus = TRACKING_NOTHING;
  617. }
  620. void LLTracker::stopTrackingLandmark(BOOL clear_ui)
  621. {
  622. purgeBeaconText();
  623. mTrackedLandmarkAssetID.setNull();
  624. mTrackedLandmarkItemID.setNull();
  625. mTrackedLandmarkName.assign("");
  626. mTrackedPositionGlobal.zeroVec();
  627. mHasLandmarkPosition = FALSE;
  628. mHasReachedLandmark = FALSE;
  629. mLandmarkHasBeenVisited = TRUE;
  630. gFloaterWorldMap->clearLandmarkSelection(clear_ui);
  631. mTrackingStatus = TRACKING_NOTHING;
  632. }
  635. void LLTracker::stopTrackingLocation(BOOL clear_ui)
  636. {
  637. purgeBeaconText();
  638. mTrackedLocationName.assign("");
  639. mIsTrackingLocation = FALSE;
  640. mTrackedPositionGlobal.zeroVec();
  641. gFloaterWorldMap->clearLocationSelection(clear_ui);
  642. mTrackingStatus = TRACKING_NOTHING;
  643. mTrackingLocationType = LOCATION_NOTHING;
  644. }
  646. void LLTracker::clearFocus()
  647. {
  648. instance()->mTrackingStatus = TRACKING_NOTHING;
  649. }
  651. void LLTracker::drawMarker(const LLVector3d& pos_global, const LLColor4& color)
  652. {
  653. // get position
  654. LLVector3 pos_local = gAgent.getPosAgentFromGlobal(pos_global);
  656. // check in frustum
  657. LLCoordGL screen;
  658. S32 x = 0;
  659. S32 y = 0;
  660. const BOOL CLAMP = TRUE;
  662. if (LLViewerCamera::getInstance()->projectPosAgentToScreen(pos_local, screen, CLAMP)
  663. || LLViewerCamera::getInstance()->projectPosAgentToScreenEdge(pos_local, screen) )
  664. {
  665. gHUDView->screenPointToLocal(screen.mX, screen.mY, &x, &y);
  667. // the center of the rendered position of the arrow obeys 
  668. // the following rules:
  669. // (1) it lies on an ellipse centered on the target position 
  670. // (2) it lies on the line between the target and the window center
  671. // (3) right now the radii of the ellipse are fixed, but eventually
  672. //     they will be a function of the target text
  673. // 
  674. // from those rules we can compute the position of the 
  675. // lower left corner of the image
  676. LLRect rect = gHUDView->getRect();
  677. S32 x_center = lltrunc(0.5f * (F32)rect.getWidth());
  678. S32 y_center = lltrunc(0.5f * (F32)rect.getHeight());
  679. x = x - x_center; // x and y relative to center
  680. y = y - y_center;
  681. F32 dist = sqrt((F32)(x*x + y*y));
  682. S32 half_arrow_size = lltrunc(0.5f * HUD_ARROW_SIZE);
  683. if (dist > 0.f)
  684. {
  685. const F32 ARROW_ELLIPSE_RADIUS_X = 2 * HUD_ARROW_SIZE;
  686. const F32 ARROW_ELLIPSE_RADIUS_Y = HUD_ARROW_SIZE;
  688. // compute where the arrow should be
  689. F32 x_target = (F32)(x + x_center) - (ARROW_ELLIPSE_RADIUS_X * ((F32)x / dist) );
  690. F32 y_target = (F32)(y + y_center) - (ARROW_ELLIPSE_RADIUS_Y * ((F32)y / dist) );
  692. // keep the arrow within the window
  693. F32 x_clamped = llclamp( x_target, (F32)half_arrow_size, (F32)(rect.getWidth() - half_arrow_size));
  694. F32 y_clamped = llclamp( y_target, (F32)half_arrow_size, (F32)(rect.getHeight() - half_arrow_size));
  696. F32 slope = (F32)(y) / (F32)(x);
  697. F32 window_ratio = (F32)(rect.getHeight() - HUD_ARROW_SIZE) / (F32)(rect.getWidth() - HUD_ARROW_SIZE);
  699. // if the arrow has been clamped on one axis
  700. // then we need to compute the other axis
  701. if (llabs(slope) > window_ratio)
  702. {  
  703. if (y_clamped != (F32)y_target)
  704. {
  705. // clamp by y 
  706. x_clamped = (y_clamped - (F32)y_center) / slope + (F32)x_center;
  707. }
  708. }
  709. else if (x_clamped != (F32)x_target)
  710. {
  711. // clamp by x
  712. y_clamped = (x_clamped - (F32)x_center) * slope + (F32)y_center;
  713. }
  714. mHUDArrowCenterX = lltrunc(x_clamped);
  715. mHUDArrowCenterY = lltrunc(y_clamped);
  716. }
  717. else
  718. {
  719. // recycle the old values
  720. x = mHUDArrowCenterX - x_center;
  721. y = mHUDArrowCenterY - y_center;
  722. }
  724. F32 angle = atan2( (F32)y, (F32)x );
  726. gl_draw_scaled_rotated_image(mHUDArrowCenterX - half_arrow_size, 
  727.  mHUDArrowCenterY - half_arrow_size, 
  728.  HUD_ARROW_SIZE, HUD_ARROW_SIZE, 
  729.  RAD_TO_DEG * angle, 
  730.  LLWorldMapView::sTrackArrowImage->getImage(), 
  731.  color);
  732. }
  733. }
  736. void LLTracker::setLandmarkVisited()
  737. {
  738. // poke the inventory item
  739. if (!mTrackedLandmarkItemID.isNull())
  740. {
  741. LLInventoryItem* i = gInventory.getItem( mTrackedLandmarkItemID );
  742. LLViewerInventoryItem* item = (LLViewerInventoryItem*)i;
  743. if (   item 
  744. && !(item->getFlags()&LLInventoryItem::II_FLAGS_LANDMARK_VISITED))
  745. {
  746. U32 flags = item->getFlags();
  747. flags |= LLInventoryItem::II_FLAGS_LANDMARK_VISITED;
  748. item->setFlags(flags);
  749. LLMessageSystem* msg = gMessageSystem;
  750. msg->newMessage("ChangeInventoryItemFlags");
  751. msg->nextBlock("AgentData");
  752. msg->addUUID("AgentID", gAgent.getID());
  753. msg->addUUID("SessionID", gAgent.getSessionID());
  754. msg->nextBlock("InventoryData");
  755. msg->addUUID("ItemID", mTrackedLandmarkItemID);
  756. msg->addU32("Flags", flags);
  757. gAgent.sendReliableMessage();
  759. LLInventoryModel::LLCategoryUpdate up(item->getParentUUID(), 0);
  760. gInventory.accountForUpdate(up);
  762. // need to communicate that the icon needs to change...
  763. gInventory.addChangedMask(LLInventoryObserver::INTERNAL, item->getUUID());
  764. gInventory.notifyObservers();
  765. }
  766. }
  767. }
  770. void LLTracker::cacheLandmarkPosition()
  771. {
  772. // the landmark asset download may have finished, in which case
  773. // we'll now be able to figure out where we're trying to go
  774. BOOL found_landmark = FALSE;
  775. if( mTrackedLandmarkAssetID == LLFloaterWorldMap::getHomeID())
  776. {
  777. LLVector3d pos_global;
  778. if ( gAgent.getHomePosGlobal( &mTrackedPositionGlobal ))
  779. {
  780. found_landmark = TRUE;
  781. }
  782. else
  783. {
  784. llwarns << "LLTracker couldn't find home pos" << llendl;
  785. mTrackedLandmarkAssetID.setNull();
  786. mTrackedLandmarkItemID.setNull();
  787. }
  788. }
  789. else
  790. {
  791. LLLandmark* landmark = gLandmarkList.getAsset(mTrackedLandmarkAssetID);
  792. if(landmark && landmark->getGlobalPos(mTrackedPositionGlobal))
  793. {
  794. found_landmark = TRUE;
  796. // cache the object's visitation status
  797. mLandmarkHasBeenVisited = FALSE;
  798. LLInventoryItem* item = gInventory.getItem(mTrackedLandmarkItemID);
  799. if (   item 
  800. && item->getFlags()&LLInventoryItem::II_FLAGS_LANDMARK_VISITED)
  801. {
  802. mLandmarkHasBeenVisited = TRUE;
  803. }
  804. }
  805. }
  806. if ( found_landmark && gFloaterWorldMap )
  807. {
  808. mHasReachedLandmark = FALSE;
  809. F32 dist = gFloaterWorldMap->getDistanceToDestination(mTrackedPositionGlobal, 1.0f);
  810. if ( dist < DESTINATION_UNVISITED_RADIUS )
  811. {
  812. mHasReachedLandmark = TRUE;
  813. }
  814. mHasLandmarkPosition = TRUE;
  815. }
  816. mHasLandmarkPosition = found_landmark;
  817. }
  820. void LLTracker::purgeBeaconText()
  821. {
  822. if(!mBeaconText.isNull())
  823. {
  824. mBeaconText->markDead();
  825. mBeaconText = NULL;
  826. }
  827. }