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

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

游戏引擎

开发平台：

C++ Builder

llworldmapview.cpp：源码内容
  1. /** 
  2.  * @file llworldmapview.cpp
  3.  * @brief LLWorldMapView class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-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. #include "llworldmapview.h"
  37. #include "indra_constants.h"
  38. #include "llui.h"
  39. #include "llmath.h" // clampf()
  40. #include "llregionhandle.h"
  41. #include "lleventflags.h"
  42. #include "llfloaterreg.h"
  43. #include "llrender.h"
  44. #include "lltooltip.h"
  46. #include "llagent.h"
  47. #include "llcallingcard.h"
  48. #include "llviewercontrol.h"
  49. #include "llfloatermap.h"
  50. #include "llfloaterworldmap.h"
  51. #include "llfocusmgr.h"
  52. #include "lllocalcliprect.h"
  53. #include "lltextbox.h"
  54. #include "lltextureview.h"
  55. #include "lltracker.h"
  56. #include "llviewercamera.h"
  57. #include "llviewertexture.h"
  58. #include "llviewertexturelist.h"
  59. #include "llviewerregion.h"
  60. #include "llviewerwindow.h"
  61. #include "lltrans.h"
  63. #include "llglheaders.h"
  65. // Basically a C++ implementation of the OCEAN_COLOR defined in mapstitcher.py 
  66. // Please ensure consistency between those 2 files (TODO: would be better to get that color from an asset source...)
  67. // # Constants
  68. // OCEAN_COLOR = "#1D475F"
  69. const F32 OCEAN_RED   = (F32)(0x1D)/255.f;
  70. const F32 OCEAN_GREEN = (F32)(0x47)/255.f;
  71. const F32 OCEAN_BLUE  = (F32)(0x5F)/255.f;
  73. const F32 GODLY_TELEPORT_HEIGHT = 200.f;
  74. const S32 SCROLL_HINT_WIDTH = 65;
  75. const F32 BIG_DOT_RADIUS = 5.f;
  76. BOOL LLWorldMapView::sHandledLastClick = FALSE;
  78. LLUIImagePtr LLWorldMapView::sAvatarSmallImage = NULL;
  79. LLUIImagePtr LLWorldMapView::sAvatarYouImage = NULL;
  80. LLUIImagePtr LLWorldMapView::sAvatarYouLargeImage = NULL;
  81. LLUIImagePtr LLWorldMapView::sAvatarLevelImage = NULL;
  82. LLUIImagePtr LLWorldMapView::sAvatarAboveImage = NULL;
  83. LLUIImagePtr LLWorldMapView::sAvatarBelowImage = NULL;
  85. LLUIImagePtr LLWorldMapView::sTelehubImage = NULL;
  86. LLUIImagePtr LLWorldMapView::sInfohubImage = NULL;
  87. LLUIImagePtr LLWorldMapView::sHomeImage = NULL;
  88. LLUIImagePtr LLWorldMapView::sEventImage = NULL;
  89. LLUIImagePtr LLWorldMapView::sEventMatureImage = NULL;
  90. LLUIImagePtr LLWorldMapView::sEventAdultImage = NULL;
  92. LLUIImagePtr LLWorldMapView::sTrackCircleImage = NULL;
  93. LLUIImagePtr LLWorldMapView::sTrackArrowImage = NULL;
  95. LLUIImagePtr LLWorldMapView::sClassifiedsImage = NULL;
  96. LLUIImagePtr LLWorldMapView::sForSaleImage = NULL;
  97. LLUIImagePtr LLWorldMapView::sForSaleAdultImage = NULL;
  99. F32 LLWorldMapView::sPanX = 0.f;
  100. F32 LLWorldMapView::sPanY = 0.f;
  101. F32 LLWorldMapView::sTargetPanX = 0.f;
  102. F32 LLWorldMapView::sTargetPanY = 0.f;
  103. S32 LLWorldMapView::sTrackingArrowX = 0;
  104. S32 LLWorldMapView::sTrackingArrowY = 0;
  105. bool LLWorldMapView::sVisibleTilesLoaded = false;
  106. F32 LLWorldMapView::sMapScale = 128.f;
  108. std::map<std::string,std::string> LLWorldMapView::sStringsMap;
  110. // Fetch and draw info thresholds
  111. const F32 DRAW_TEXT_THRESHOLD = 96.f; // Don't draw text under that resolution value (res = width region in meters)
  112. const S32 DRAW_SIMINFO_THRESHOLD = 3; // Max level for which we load or display sim level information (level in LLWorldMipmap sense)
  113. const S32 DRAW_LANDFORSALE_THRESHOLD = 2; // Max level for which we load or display land for sale picture data (level in LLWorldMipmap sense)
  115. // When on, draw an outline for each mipmap tile gotten from S3
  116. #define DEBUG_DRAW_TILE 0
  119. void LLWorldMapView::initClass()
  120. {
  121. sAvatarSmallImage = LLUI::getUIImage("map_avatar_8.tga");
  122. sAvatarYouImage = LLUI::getUIImage("map_avatar_16.tga");
  123. sAvatarYouLargeImage = LLUI::getUIImage("map_avatar_you_32.tga");
  124. sAvatarLevelImage = LLUI::getUIImage("map_avatar_32.tga");
  125. sAvatarAboveImage = LLUI::getUIImage("map_avatar_above_32.tga");
  126. sAvatarBelowImage = LLUI::getUIImage("map_avatar_below_32.tga");
  128. sHomeImage = LLUI::getUIImage("map_home.tga");
  129. sTelehubImage =  LLUI::getUIImage("map_telehub.tga");
  130. sInfohubImage =  LLUI::getUIImage("map_infohub.tga");
  131. sEventImage = LLUI::getUIImage("Parcel_PG_Dark");
  132. sEventMatureImage = LLUI::getUIImage("Parcel_M_Dark");
  133. // To Do: update the image resource for adult events.
  134. sEventAdultImage = LLUI::getUIImage("Parcel_R_Dark");
  136. sTrackCircleImage = LLUI::getUIImage("map_track_16.tga");
  137. sTrackArrowImage = LLUI::getUIImage("direction_arrow.tga");
  138. sClassifiedsImage = LLUI::getUIImage("icon_top_pick.tga");
  139. sForSaleImage = LLUI::getUIImage("icon_for_sale.tga");
  140. // To Do: update the image resource for adult lands on sale.
  141. sForSaleAdultImage =    LLUI::getUIImage("icon_for_sale_adult.tga");
  143. sStringsMap["loading"] = LLTrans::getString("texture_loading");
  144. sStringsMap["offline"] = LLTrans::getString("worldmap_offline");
  145. }
  147. // static
  148. void LLWorldMapView::cleanupClass()
  149. {
  150. sAvatarSmallImage = NULL;
  151. sAvatarYouImage = NULL;
  152. sAvatarYouLargeImage = NULL;
  153. sAvatarLevelImage = NULL;
  154. sAvatarAboveImage = NULL;
  155. sAvatarBelowImage = NULL;
  157. sTelehubImage = NULL;
  158. sInfohubImage = NULL;
  159. sHomeImage = NULL;
  160. sEventImage = NULL;
  161. sEventMatureImage = NULL;
  162. sEventAdultImage = NULL;
  164. sTrackCircleImage = NULL;
  165. sTrackArrowImage = NULL;
  166. sClassifiedsImage = NULL;
  167. sForSaleImage = NULL;
  168. sForSaleAdultImage = NULL;
  169. }
  171. LLWorldMapView::LLWorldMapView()
  172. : LLPanel(),
  173. mBackgroundColor( LLColor4( OCEAN_RED, OCEAN_GREEN, OCEAN_BLUE, 1.f ) ),
  174. mItemPicked(FALSE),
  175. mPanning( FALSE ),
  176. mMouseDownPanX( 0 ),
  177. mMouseDownPanY( 0 ),
  178. mMouseDownX( 0 ),
  179. mMouseDownY( 0 ),
  180. mSelectIDStart(0)
  181. {
  182. //LL_INFOS("World Map") << "Creating the Map -> LLWorldMapView::LLWorldMapView()" << LL_ENDL;
  184. clearLastClick();
  185. }
  187. BOOL LLWorldMapView::postBuild()
  188. {
  189. mTextBoxNorth = getChild<LLTextBox> ("floater_map_north");
  190. mTextBoxEast = getChild<LLTextBox> ("floater_map_east");
  191. mTextBoxWest = getChild<LLTextBox> ("floater_map_west");
  192. mTextBoxSouth = getChild<LLTextBox> ("floater_map_south");
  193. mTextBoxSouthEast = getChild<LLTextBox> ("floater_map_southeast");
  194. mTextBoxNorthEast = getChild<LLTextBox> ("floater_map_northeast");
  195. mTextBoxSouthWest = getChild<LLTextBox> ("floater_map_southwest");
  196. mTextBoxNorthWest = getChild<LLTextBox> ("floater_map_northwest");
  198. mTextBoxNorth->setText(getString("world_map_north"));
  199. mTextBoxEast->setText(getString ("world_map_east"));
  200. mTextBoxWest->setText(getString("world_map_west"));
  201. mTextBoxSouth->setText(getString ("world_map_south"));
  202. mTextBoxSouthEast ->setText(getString ("world_map_southeast"));
  203. mTextBoxNorthEast ->setText(getString ("world_map_northeast"));
  204. mTextBoxSouthWest->setText(getString ("world_map_southwest"));
  205. mTextBoxNorthWest ->setText(getString("world_map_northwest"));
  207. mTextBoxNorth->reshapeToFitText();
  208. mTextBoxEast->reshapeToFitText();
  209. mTextBoxWest->reshapeToFitText();
  210. mTextBoxSouth->reshapeToFitText();
  211. mTextBoxSouthEast ->reshapeToFitText();
  212. mTextBoxNorthEast ->reshapeToFitText();
  213. mTextBoxSouthWest->reshapeToFitText();
  214. mTextBoxNorthWest ->reshapeToFitText();
  216. return true;
  217. }
  220. LLWorldMapView::~LLWorldMapView()
  221. {
  222. //LL_INFOS("World Map") << "Destroying the map -> LLWorldMapView::~LLWorldMapView()" << LL_ENDL;
  223. cleanupTextures();
  224. }
  227. // static
  228. void LLWorldMapView::cleanupTextures()
  229. {
  230. }
  233. // static
  234. void LLWorldMapView::setScale( F32 scale )
  235. {
  236. if (scale != sMapScale)
  237. {
  238. F32 old_scale = sMapScale;
  240. sMapScale = scale;
  241. if (sMapScale <= 0.f)
  242. {
  243. sMapScale = 0.1f;
  244. }
  246. F32 ratio = (scale / old_scale);
  247. sPanX *= ratio;
  248. sPanY *= ratio;
  249. sTargetPanX = sPanX;
  250. sTargetPanY = sPanY;
  251. sVisibleTilesLoaded = false;
  252. }
  253. }
  256. // static
  257. void LLWorldMapView::translatePan( S32 delta_x, S32 delta_y )
  258. {
  259. sPanX += delta_x;
  260. sPanY += delta_y;
  261. sTargetPanX = sPanX;
  262. sTargetPanY = sPanY;
  263. sVisibleTilesLoaded = false;
  264. }
  267. // static
  268. void LLWorldMapView::setPan( S32 x, S32 y, BOOL snap )
  269. {
  270. sTargetPanX = (F32)x;
  271. sTargetPanY = (F32)y;
  272. if (snap)
  273. {
  274. sPanX = sTargetPanX;
  275. sPanY = sTargetPanY;
  276. }
  277. sVisibleTilesLoaded = false;
  278. }
  280. bool LLWorldMapView::showRegionInfo()
  281. {
  282. return (LLWorldMipmap::scaleToLevel(sMapScale) <= DRAW_SIMINFO_THRESHOLD ? true : false);
  283. }
  285. ///////////////////////////////////////////////////////////////////////////////////
  286. // HELPERS
  288. BOOL is_agent_in_region(LLViewerRegion* region, LLSimInfo* info)
  289. {
  290. return (region && info && info->isName(region->getName()));
  291. }
  293. ///////////////////////////////////////////////////////////////////////////////////
  295. void LLWorldMapView::draw()
  296. {
  297. static LLUIColor map_track_color = LLUIColorTable::instance().getColor("MapTrackColor", LLColor4::white);
  299. LLTextureView::clearDebugImages();
  301. F64 current_time = LLTimer::getElapsedSeconds();
  303. mVisibleRegions.clear();
  305. // animate pan if necessary
  306. sPanX = lerp(sPanX, sTargetPanX, LLCriticalDamp::getInterpolant(0.1f));
  307. sPanY = lerp(sPanY, sTargetPanY, LLCriticalDamp::getInterpolant(0.1f));
  309. const S32 width = getRect().getWidth();
  310. const S32 height = getRect().getHeight();
  311. const F32 half_width = F32(width) / 2.0f;
  312. const F32 half_height = F32(height) / 2.0f;
  313. LLVector3d camera_global = gAgent.getCameraPositionGlobal();
  315. S32 level = LLWorldMipmap::scaleToLevel(sMapScale);
  317. LLLocalClipRect clip(getLocalRect());
  318. {
  319. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  321. glMatrixMode(GL_MODELVIEW);
  323. // Clear the background alpha to 0
  324. gGL.flush();
  325. gGL.setColorMask(false, true);
  326. gGL.setAlphaRejectSettings(LLRender::CF_GREATER_EQUAL, 0.f);
  327. gGL.setSceneBlendType(LLRender::BT_REPLACE);
  328. gGL.color4f(0.0f, 0.0f, 0.0f, 0.0f);
  329. gl_rect_2d(0, height, width, 0);
  330. }
  332. gGL.flush();
  334. gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
  335. gGL.setColorMask(true, true);
  337. // Draw the image tiles
  338. drawMipmap(width, height);
  339. gGL.flush();
  341. gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
  342. gGL.setColorMask(true, true);
  344. // Draw per sim overlayed information (names, mature, offline...)
  345. for (LLWorldMap::sim_info_map_t::const_iterator it = LLWorldMap::getInstance()->getRegionMap().begin();
  346.  it != LLWorldMap::getInstance()->getRegionMap().end(); ++it)
  347. {
  348. U64 handle = it->first;
  349. LLSimInfo* info = it->second;
  351. LLVector3d origin_global = from_region_handle(handle);
  353. // Find x and y position relative to camera's center.
  354. LLVector3d rel_region_pos = origin_global - camera_global;
  355. F32 relative_x = (rel_region_pos.mdV[0] / REGION_WIDTH_METERS) * sMapScale;
  356. F32 relative_y = (rel_region_pos.mdV[1] / REGION_WIDTH_METERS) * sMapScale;
  358. // Coordinates of the sim in pixels in the UI panel
  359. // When the view isn't panned, 0,0 = center of rectangle
  360. F32 bottom =    sPanY + half_height + relative_y;
  361. F32 left =      sPanX + half_width + relative_x;
  362. F32 top =       bottom + sMapScale ;
  363. F32 right =     left + sMapScale ;
  365. // Discard if region is outside the screen rectangle (not visible on screen)
  366. if ((top < 0.f)   || (bottom > height) ||
  367. (right < 0.f) || (left > width)       )
  368. {
  369. // Drop the "land for sale" fetching priority since it's outside the view rectangle
  370. info->dropImagePriority();
  371. continue;
  372. }
  374. // This list is used by other methods to know which regions are indeed displayed on screen
  376. mVisibleRegions.push_back(handle);
  378. // Update the agent count for that region if we're not too zoomed out already
  379. if (level <= DRAW_SIMINFO_THRESHOLD)
  380. {
  381. info->updateAgentCount(current_time);
  382. }
  384. if (info->isDown())
  385. {
  386. // Draw a transparent red square over down sims
  387. gGL.blendFunc(LLRender::BF_DEST_ALPHA, LLRender::BF_SOURCE_ALPHA);
  388. gGL.color4f(0.2f, 0.0f, 0.0f, 0.4f);
  390. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  391. gGL.begin(LLRender::QUADS);
  392. gGL.vertex2f(left, top);
  393. gGL.vertex2f(left, bottom);
  394. gGL.vertex2f(right, bottom);
  395. gGL.vertex2f(right, top);
  396. gGL.end();
  397. }
  398.         // As part of the AO project, we no longer want to draw access indicators;
  399. // it's too complicated to get all the rules straight and will only
  400. // cause confusion.
  401. /**********************
  402.         else if (!info->isPG() && gAgent.isTeen())
  403. {
  404. // If this is a mature region, and you are not, draw a line across it
  405. gGL.blendFunc(LLRender::BF_DEST_ALPHA, LLRender::BF_ZERO);
  407. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  408. gGL.color3f(1.f, 0.f, 0.f);
  409. gGL.begin(LLRender::LINES);
  410. gGL.vertex2f(left, top);
  411. gGL.vertex2f(right, bottom);
  412. gGL.vertex2f(left, bottom);
  413. gGL.vertex2f(right, top);
  414. gGL.end();
  415. }
  416.  **********************/
  417. else if (gSavedSettings.getBOOL("MapShowLandForSale") && (level <= DRAW_LANDFORSALE_THRESHOLD))
  418. {
  419. // Draw the overlay image "Land for Sale / Land for Auction"
  420. LLViewerFetchedTexture* overlayimage = info->getLandForSaleImage();
  421. if (overlayimage)
  422. {
  423. // Inform the fetch mechanism of the size we need
  424. S32 draw_size = llround(sMapScale);
  425. overlayimage->setKnownDrawSize(llround(draw_size * LLUI::sGLScaleFactor.mV[VX]), llround(draw_size * LLUI::sGLScaleFactor.mV[VY]));
  426. // Draw something whenever we have enough info
  427. if (overlayimage->hasGLTexture())
  428. {
  429. gGL.blendFunc(LLRender::BF_DEST_ALPHA, LLRender::BF_ZERO);
  430. gGL.getTexUnit(0)->bind(overlayimage);
  431. gGL.color4f(1.f, 1.f, 1.f, 1.f);
  432. gGL.begin(LLRender::QUADS);
  433. gGL.texCoord2f(0.f, 1.f);
  434. gGL.vertex3f(left, top, -0.5f);
  435. gGL.texCoord2f(0.f, 0.f);
  436. gGL.vertex3f(left, bottom, -0.5f);
  437. gGL.texCoord2f(1.f, 0.f);
  438. gGL.vertex3f(right, bottom, -0.5f);
  439. gGL.texCoord2f(1.f, 1.f);
  440. gGL.vertex3f(right, top, -0.5f);
  441. gGL.end();
  442. }
  443. }
  444. }
  445. else
  446. {
  447. // If we're not displaying the "land for sale", drop its fetching priority
  448. info->dropImagePriority();
  449. }
  451. // Draw the region name in the lower left corner
  452. if (sMapScale >= DRAW_TEXT_THRESHOLD)
  453. {
  454. LLFontGL* font = LLFontGL::getFont(LLFontDescriptor("SansSerif", "Small", LLFontGL::BOLD));
  455. std::string mesg;
  456. if (info->isDown())
  457. {
  458. mesg = llformat( "%s (%s)", info->getName().c_str(), sStringsMap["offline"].c_str());
  459. }
  460. else
  461. {
  462. mesg = info->getName();
  463. }
  464. if (!mesg.empty())
  465. {
  466. font->renderUTF8(
  467. mesg, 0,
  468. llfloor(left + 3), llfloor(bottom + 2),
  469. LLColor4::white,
  470. LLFontGL::LEFT, LLFontGL::BASELINE, LLFontGL::NORMAL, LLFontGL::DROP_SHADOW);
  471. }
  472. }
  473. }
  477. // Draw background rectangle
  478. LLGLSUIDefault gls_ui;
  479. {
  480. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  481. gGL.setAlphaRejectSettings(LLRender::CF_GREATER_EQUAL, 0.f);
  482. gGL.blendFunc(LLRender::BF_ONE_MINUS_DEST_ALPHA, LLRender::BF_DEST_ALPHA);
  483. gGL.color4fv( mBackgroundColor.mV );
  484. gl_rect_2d(0, height, width, 0);
  485. }
  487. gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
  488. gGL.setSceneBlendType(LLRender::BT_ALPHA);
  490. // Draw item infos if we're not zoomed out too much and there's something to draw
  491. if ((level <= DRAW_SIMINFO_THRESHOLD) && (gSavedSettings.getBOOL("MapShowInfohubs") || 
  492.   gSavedSettings.getBOOL("MapShowTelehubs") ||
  493.   gSavedSettings.getBOOL("MapShowLandForSale") || 
  494.   gSavedSettings.getBOOL("MapShowEvents") || 
  495.   gSavedSettings.getBOOL("ShowMatureEvents") ||
  496.   gSavedSettings.getBOOL("ShowAdultEvents")))
  497. {
  498. drawItems();
  499. }
  501. // Draw the Home location (always)
  502. LLVector3d home;
  503. if (gAgent.getHomePosGlobal(&home))
  504. {
  505. drawImage(home, sHomeImage);
  506. }
  508. // Draw the current agent after all that other stuff.
  509. LLVector3d pos_global = gAgent.getPositionGlobal();
  510. drawImage(pos_global, sAvatarYouImage);
  512. LLVector3 pos_map = globalPosToView(pos_global);
  513. if (!pointInView(llround(pos_map.mV[VX]), llround(pos_map.mV[VY])))
  514. {
  515. drawTracking(pos_global,
  516.  lerp(LLColor4::yellow, LLColor4::orange, 0.4f),
  517.  TRUE,
  518.  "You are here",
  519.  "",
  520.  llround(LLFontGL::getFontSansSerifSmall()->getLineHeight())); // offset vertically by one line, to avoid overlap with target tracking
  521. }
  523. // Draw the current agent viewing angle
  524. drawFrustum();
  526. // Draw icons for the avatars in each region.
  527. // Drawn this after the current agent avatar so one can see nearby people
  528. if (gSavedSettings.getBOOL("MapShowPeople") && (level <= DRAW_SIMINFO_THRESHOLD))
  529. {
  530. drawAgents();
  531. }
  533. // Always draw tracking information
  534. LLTracker::ETrackingStatus tracking_status = LLTracker::getTrackingStatus();
  535. if ( LLTracker::TRACKING_AVATAR == tracking_status )
  536. {
  537. drawTracking( LLAvatarTracker::instance().getGlobalPos(), map_track_color, TRUE, LLTracker::getLabel(), "" );
  538. }
  539. else if ( LLTracker::TRACKING_LANDMARK == tracking_status
  540.   || LLTracker::TRACKING_LOCATION == tracking_status )
  541. {
  542. // While fetching landmarks, will have 0,0,0 location for a while,
  543. // so don't draw. JC
  544. LLVector3d pos_global = LLTracker::getTrackedPositionGlobal();
  545. if (!pos_global.isExactlyZero())
  546. {
  547. drawTracking( pos_global, map_track_color, TRUE, LLTracker::getLabel(), LLTracker::getToolTip() );
  548. }
  549. }
  550. else if (LLWorldMap::getInstance()->isTracking())
  551. {
  552. if (LLWorldMap::getInstance()->isTrackingInvalidLocation())
  553. {
  554. // We know this location to be invalid, draw a blue circle
  555. LLColor4 loading_color(0.0, 0.5, 1.0, 1.0);
  556. drawTracking( LLWorldMap::getInstance()->getTrackedPositionGlobal(), loading_color, TRUE, getString("InvalidLocation"), "");
  557. }
  558. else
  559. {
  560. // We don't know yet what that location is, draw a throbing blue circle
  561. double value = fmod(current_time, 2);
  562. value = 0.5 + 0.5*cos(value * F_PI);
  563. LLColor4 loading_color(0.0, F32(value/2), F32(value), 1.0);
  564. drawTracking( LLWorldMap::getInstance()->getTrackedPositionGlobal(), loading_color, TRUE, getString("Loading"), "");
  565. }
  566. }
  569. // turn off the scissor
  570. LLGLDisable no_scissor(GL_SCISSOR_TEST);
  572. updateDirections();
  574. LLView::draw();
  576. // Get sim info for all sims in view
  577. updateVisibleBlocks();
  578. } // end draw()
  581. //virtual
  582. void LLWorldMapView::setVisible(BOOL visible)
  583. {
  584. LLPanel::setVisible(visible);
  585. if (!visible)
  586. {
  587. // Drop the download of tiles and images priority to nil if we hide the map
  588. LLWorldMap::getInstance()->dropImagePriorities();
  589. }
  590. }
  592. void LLWorldMapView::drawMipmap(S32 width, S32 height)
  593. {
  594. // Compute the level of the mipmap to use for the current scale level
  595. S32 level = LLWorldMipmap::scaleToLevel(sMapScale);
  596. // Set the tile boost level so that unused tiles get to 0
  597. LLWorldMap::getInstance()->equalizeBoostLevels();
  599. // Render whatever we already have loaded if we haven't the current level
  600. // complete and use it as a background (scaled up or scaled down)
  601. if (!sVisibleTilesLoaded)
  602. {
  603. // Note: the (load = false) parameter avoids missing tiles to be fetched (i.e. we render what we have, no more)
  604. // Check all the lower res levels and render them in reverse order (worse to best)
  605. // We need to traverse all the levels as the user can zoom in very fast
  606. for (S32 l = LLWorldMipmap::MAP_LEVELS; l > level; l--)
  607. {
  608. drawMipmapLevel(width, height, l, false);
  609. }
  610. // Skip the current level, as we'll do it anyway here under...
  612. // Just go one level down in res as it can really get too much stuff 
  613. // when zooming out and too small to see anyway...
  614. if (level > 1)
  615. {
  616. drawMipmapLevel(width, height, level - 1, false);
  617. }
  618. }
  619. else
  620. {
  621. //LL_INFOS("World Map") << "Render complete, don't draw background..." << LL_ENDL;
  622. }
  624. // Render the current level
  625. sVisibleTilesLoaded = drawMipmapLevel(width, height, level);
  627. return;
  628. }
  630. // Return true if all the tiles required to render that level have been fetched or are truly missing
  631. bool LLWorldMapView::drawMipmapLevel(S32 width, S32 height, S32 level, bool load)
  632. {
  633. // Check input level
  634. llassert (level > 0);
  635. if (level <= 0)
  636. return false;
  638. // Count tiles hit and completed
  639. S32 completed_tiles = 0;
  640. S32 total_tiles = 0;
  642. // Size in meters (global) of each tile of that level
  643. S32 tile_width = LLWorldMipmap::MAP_TILE_SIZE * (1 << (level - 1));
  644. // Dimension of the screen in meter at that scale
  645. LLVector3d pos_SW = viewPosToGlobal(0, 0);
  646. LLVector3d pos_NE = viewPosToGlobal(width, height);
  647. // Add external band of tiles on the outskirt so to hit the partially displayed tiles right and top
  648. pos_NE[VX] += tile_width;
  649. pos_NE[VY] += tile_width;
  651. // Iterate through the tiles on screen: we just need to ask for one tile every tile_width meters
  652. U32 grid_x, grid_y;
  653. for (F64 index_y = pos_SW[VY]; index_y < pos_NE[VY]; index_y += tile_width)
  654. {
  655. for (F64 index_x = pos_SW[VX]; index_x < pos_NE[VX]; index_x += tile_width)
  656. {
  657. // Compute the world coordinates of the current point
  658. LLVector3d pos_global(index_x, index_y, pos_SW[VZ]);
  659. // Convert to the mipmap level coordinates for that point (i.e. which tile to we hit)
  660. LLWorldMipmap::globalToMipmap(pos_global[VX], pos_global[VY], level, &grid_x, &grid_y);
  661. // Get the tile. Note: NULL means that the image does not exist (so it's considered "complete" as far as fetching is concerned)
  662. LLPointer<LLViewerFetchedTexture> simimage = LLWorldMap::getInstance()->getObjectsTile(grid_x, grid_y, level, load);
  663. if (simimage)
  664. {
  665. // Checks that the image has a valid texture
  666. if (simimage->hasGLTexture())
  667. {
  668. // Increment the number of completly fetched tiles
  669. completed_tiles++;
  671. // Convert those coordinates (SW corner of the mipmap tile) into world (meters) coordinates
  672. pos_global[VX] = grid_x * REGION_WIDTH_METERS;
  673. pos_global[VY] = grid_y * REGION_WIDTH_METERS;
  674. // Now to screen coordinates for SW corner of that tile
  675. LLVector3 pos_screen = globalPosToView (pos_global);
  676. F32 left   = pos_screen[VX];
  677. F32 bottom = pos_screen[VY];
  678. // Compute the NE corner coordinates of the tile now
  679. pos_global[VX] += tile_width;
  680. pos_global[VY] += tile_width;
  681. pos_screen = globalPosToView (pos_global);
  682. F32 right  = pos_screen[VX];
  683. F32 top    = pos_screen[VY];
  685. // Draw the tile
  686. LLGLSUIDefault gls_ui;
  687. gGL.getTexUnit(0)->bind(simimage.get());
  688. simimage->setAddressMode(LLTexUnit::TAM_CLAMP);
  690. gGL.setSceneBlendType(LLRender::BT_ALPHA);
  691. gGL.color4f(1.f, 1.0f, 1.0f, 1.0f);
  693. gGL.begin(LLRender::QUADS);
  694. gGL.texCoord2f(0.f, 1.f);
  695. gGL.vertex3f(left, top, 0.f);
  696. gGL.texCoord2f(0.f, 0.f);
  697. gGL.vertex3f(left, bottom, 0.f);
  698. gGL.texCoord2f(1.f, 0.f);
  699. gGL.vertex3f(right, bottom, 0.f);
  700. gGL.texCoord2f(1.f, 1.f);
  701. gGL.vertex3f(right, top, 0.f);
  702. gGL.end();
  703. #if DEBUG_DRAW_TILE
  704. drawTileOutline(level, top, left, bottom, right);
  705. #endif // DEBUG_DRAW_TILE
  706. }
  707. //else
  708. //{
  709. // Waiting for a tile -> the level is not complete
  710. // LL_INFOS("World Map") << "Unfetched tile. level = " << level << LL_ENDL;
  711. //}
  712. }
  713. else
  714. {
  715. // Unexistent tiles are counted as "completed"
  716. completed_tiles++;
  717. }
  718. // Increment the number of tiles in that level / screen
  719. total_tiles++;
  720. }
  721. }
  722. return (completed_tiles == total_tiles);
  723. }
  725. // Draw lines (rectangle outline and cross) to visualize the position of the tile
  726. // Used for debug only
  727. void LLWorldMapView::drawTileOutline(S32 level, F32 top, F32 left, F32 bottom, F32 right)
  728. {
  729. gGL.blendFunc(LLRender::BF_DEST_ALPHA, LLRender::BF_ZERO);
  731. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  732. if (level == 1)
  733. gGL.color3f(1.f, 0.f, 0.f); // red
  734. else if (level == 2)
  735. gGL.color3f(0.f, 1.f, 0.f); // green
  736. else if (level == 3)
  737. gGL.color3f(0.f, 0.f, 1.f); // blue
  738. else if (level == 4)
  739. gGL.color3f(1.f, 1.f, 0.f); // yellow
  740. else if (level == 5)
  741. gGL.color3f(1.f, 0.f, 1.f); // magenta
  742. else if (level == 6)
  743. gGL.color3f(0.f, 1.f, 1.f); // cyan
  744. else if (level == 7)
  745. gGL.color3f(1.f, 1.f, 1.f); // white
  746. else
  747. gGL.color3f(0.f, 0.f, 0.f); // black
  748. gGL.begin(LLRender::LINE_STRIP);
  749. gGL.vertex2f(left, top);
  750. gGL.vertex2f(right, bottom);
  751. gGL.vertex2f(left, bottom);
  752. gGL.vertex2f(right, top);
  753. gGL.vertex2f(left, top);
  754. gGL.vertex2f(left, bottom);
  755. gGL.vertex2f(right, bottom);
  756. gGL.vertex2f(right, top);
  757. gGL.end();
  758. }
  760. void LLWorldMapView::drawGenericItems(const LLSimInfo::item_info_list_t& items, LLUIImagePtr image)
  761. {
  762. LLSimInfo::item_info_list_t::const_iterator e;
  763. for (e = items.begin(); e != items.end(); ++e)
  764. {
  765. drawGenericItem(*e, image);
  766. }
  767. }
  769. void LLWorldMapView::drawGenericItem(const LLItemInfo& item, LLUIImagePtr image)
  770. {
  771. drawImage(item.getGlobalPosition(), image);
  772. }
  775. void LLWorldMapView::drawImage(const LLVector3d& global_pos, LLUIImagePtr image, const LLColor4& color)
  776. {
  777. LLVector3 pos_map = globalPosToView( global_pos );
  778. image->draw(llround(pos_map.mV[VX] - image->getWidth() /2.f),
  779. llround(pos_map.mV[VY] - image->getHeight()/2.f),
  780. color);
  781. }
  783. void LLWorldMapView::drawImageStack(const LLVector3d& global_pos, LLUIImagePtr image, U32 count, F32 offset, const LLColor4& color)
  784. {
  785. LLVector3 pos_map = globalPosToView( global_pos );
  786. for(U32 i=0; i<count; i++)
  787. {
  788. image->draw(llround(pos_map.mV[VX] - image->getWidth() /2.f),
  789. llround(pos_map.mV[VY] - image->getHeight()/2.f + i*offset),
  790. color);
  791. }
  792. }
  794. void LLWorldMapView::drawItems()
  795. {
  796. bool mature_enabled = gAgent.canAccessMature();
  797. bool adult_enabled = gAgent.canAccessAdult();
  799.     BOOL show_mature = mature_enabled && gSavedSettings.getBOOL("ShowMatureEvents");
  800. BOOL show_adult = adult_enabled && gSavedSettings.getBOOL("ShowAdultEvents");
  802. for (handle_list_t::iterator iter = mVisibleRegions.begin(); iter != mVisibleRegions.end(); ++iter)
  803. {
  804. U64 handle = *iter;
  805. LLSimInfo* info = LLWorldMap::getInstance()->simInfoFromHandle(handle);
  806. if ((info == NULL) || (info->isDown()))
  807. {
  808. continue;
  809. }
  810. // Infohubs
  811. if (gSavedSettings.getBOOL("MapShowInfohubs"))
  812. {
  813. drawGenericItems(info->getInfoHub(), sInfohubImage);
  814. }
  815. // Telehubs
  816. if (gSavedSettings.getBOOL("MapShowTelehubs"))
  817. {
  818. drawGenericItems(info->getTeleHub(), sTelehubImage);
  819. }
  820. // Land for sale
  821. if (gSavedSettings.getBOOL("MapShowLandForSale"))
  822. {
  823. drawGenericItems(info->getLandForSale(), sForSaleImage);
  824. // for 1.23, we're showing normal land and adult land in the same UI; you don't
  825. // get a choice about which ones you want. If you're currently asking for adult
  826. // content and land you'll get the adult land.
  827. if (gAgent.canAccessAdult())
  828. {
  829. drawGenericItems(info->getLandForSaleAdult(), sForSaleAdultImage);
  830. }
  831. }
  832. // PG Events
  833. if (gSavedSettings.getBOOL("MapShowEvents"))
  834. {
  835. drawGenericItems(info->getPGEvent(), sEventImage);
  836. }
  837. // Mature Events
  838. if (show_mature)
  839. {
  840. drawGenericItems(info->getMatureEvent(), sEventMatureImage);
  841. }
  842. // Adult Events
  843. if (show_adult)
  844. {
  845. drawGenericItems(info->getAdultEvent(), sEventAdultImage);
  846. }
  847. }
  848. }
  850. void LLWorldMapView::drawAgents()
  851. {
  852. static LLUIColor map_avatar_color = LLUIColorTable::instance().getColor("MapAvatarColor", LLColor4::white);
  854. for (handle_list_t::iterator iter = mVisibleRegions.begin(); iter != mVisibleRegions.end(); ++iter)
  855. {
  856. U64 handle = *iter;
  857. LLSimInfo* siminfo = LLWorldMap::getInstance()->simInfoFromHandle(handle);
  858. if ((siminfo == NULL) || (siminfo->isDown()))
  859. {
  860. continue;
  861. }
  862. LLSimInfo::item_info_list_t::const_iterator it = siminfo->getAgentLocation().begin();
  863. while (it != siminfo->getAgentLocation().end())
  864. {
  865. // Show Individual agents (or little stacks where real agents are)
  867. // Here's how we'd choose the color if info.mID were available but it's not being sent:
  868. // LLColor4 color = (agent_count == 1 && is_agent_friend(info.mID)) ? friend_color : avatar_color;
  869. drawImageStack(it->getGlobalPosition(), sAvatarSmallImage, it->getCount(), 3.f, map_avatar_color);
  870. ++it;
  871. }
  872. }
  873. }
  875. void LLWorldMapView::drawFrustum()
  876. {
  877. // Draw frustum
  878. F32 meters_to_pixels = sMapScale/ REGION_WIDTH_METERS;
  880. F32 horiz_fov = LLViewerCamera::getInstance()->getView() * LLViewerCamera::getInstance()->getAspect();
  881. F32 far_clip_meters = LLViewerCamera::getInstance()->getFar();
  882. F32 far_clip_pixels = far_clip_meters * meters_to_pixels;
  884. F32 half_width_meters = far_clip_meters * tan( horiz_fov / 2 );
  885. F32 half_width_pixels = half_width_meters * meters_to_pixels;
  887. F32 ctr_x = getRect().getWidth() * 0.5f + sPanX;
  888. F32 ctr_y = getRect().getHeight() * 0.5f + sPanY;
  890. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  892. // Since we don't rotate the map, we have to rotate the frustum.
  893. gGL.pushMatrix();
  894. gGL.translatef( ctr_x, ctr_y, 0 );
  895. glRotatef( atan2( LLViewerCamera::getInstance()->getAtAxis().mV[VX], LLViewerCamera::getInstance()->getAtAxis().mV[VY] ) * RAD_TO_DEG, 0.f, 0.f, -1.f);
  897. // Draw triangle with more alpha in far pixels to make it 
  898. // fade out in distance.
  899. gGL.begin( LLRender::TRIANGLES  );
  900. gGL.color4f(1.f, 1.f, 1.f, 0.25f);
  901. gGL.vertex2f( 0, 0 );
  903. gGL.color4f(1.f, 1.f, 1.f, 0.02f);
  904. gGL.vertex2f( -half_width_pixels, far_clip_pixels );
  906. gGL.color4f(1.f, 1.f, 1.f, 0.02f);
  907. gGL.vertex2f(  half_width_pixels, far_clip_pixels );
  908. gGL.end();
  909. gGL.popMatrix();
  910. }
  913. LLVector3 LLWorldMapView::globalPosToView( const LLVector3d& global_pos )
  914. {
  915. LLVector3d relative_pos_global = global_pos - gAgent.getCameraPositionGlobal();
  916. LLVector3 pos_local;
  917. pos_local.setVec(relative_pos_global);  // convert to floats from doubles
  919. pos_local.mV[VX] *= sMapScale / REGION_WIDTH_METERS;
  920. pos_local.mV[VY] *= sMapScale / REGION_WIDTH_METERS;
  921. // leave Z component in meters
  924. pos_local.mV[VX] += getRect().getWidth() / 2 + sPanX;
  925. pos_local.mV[VY] += getRect().getHeight() / 2 + sPanY;
  927. return pos_local;
  928. }
  931. void LLWorldMapView::drawTracking(const LLVector3d& pos_global, const LLColor4& color, BOOL draw_arrow,
  932.   const std::string& label, const std::string& tooltip, S32 vert_offset )
  933. {
  934. LLVector3 pos_local = globalPosToView( pos_global );
  935. S32 x = llround( pos_local.mV[VX] );
  936. S32 y = llround( pos_local.mV[VY] );
  937. LLFontGL* font = LLFontGL::getFontSansSerifSmall();
  938. S32 text_x = x;
  939. S32 text_y = (S32)(y - sTrackCircleImage->getHeight()/2 - font->getLineHeight());
  941. BOOL is_in_window = true;
  943. if(    x < 0 
  944. || y < 0 
  945. || x >= getRect().getWidth() 
  946. || y >= getRect().getHeight() )
  947. {
  948. if (draw_arrow)
  949. {
  950. drawTrackingCircle( getRect(), x, y, color, 3, 15 );
  951. drawTrackingArrow( getRect(), x, y, color );
  952. text_x = sTrackingArrowX;
  953. text_y = sTrackingArrowY;
  954. }
  955. is_in_window = false;
  956. }
  957. else if (LLTracker::getTrackingStatus() == LLTracker::TRACKING_LOCATION &&
  958. LLTracker::getTrackedLocationType() != LLTracker::LOCATION_NOTHING)
  959. {
  960. drawTrackingCircle( getRect(), x, y, color, 3, 15 );
  961. }
  962. else
  963. {
  964. drawImage(pos_global, sTrackCircleImage, color);
  965. }
  967. // clamp text position to on-screen
  968. const S32 TEXT_PADDING = DEFAULT_TRACKING_ARROW_SIZE + 2;
  969. S32 half_text_width = llfloor(font->getWidthF32(label) * 0.5f);
  970. text_x = llclamp(text_x, half_text_width + TEXT_PADDING, getRect().getWidth() - half_text_width - TEXT_PADDING);
  971. text_y = llclamp(text_y + vert_offset, TEXT_PADDING + vert_offset, getRect().getHeight() - llround(font->getLineHeight()) - TEXT_PADDING - vert_offset);
  973. if (label != "")
  974. {
  975. font->renderUTF8(
  976. label, 0,
  977. text_x, 
  978. text_y,
  979. LLColor4::white, LLFontGL::HCENTER,
  980. LLFontGL::BASELINE, LLFontGL::NORMAL, LLFontGL::DROP_SHADOW);
  982. if (tooltip != "")
  983. {
  984. text_y -= (S32)font->getLineHeight();
  986. font->renderUTF8(
  987. tooltip, 0,
  988. text_x, 
  989. text_y,
  990. LLColor4::white, LLFontGL::HCENTER,
  991. LLFontGL::BASELINE, LLFontGL::NORMAL, LLFontGL::DROP_SHADOW);
  992. }
  993. }
  994. }
  996. // If you change this, then you need to change LLTracker::getTrackedPositionGlobal() as well
  997. LLVector3d LLWorldMapView::viewPosToGlobal( S32 x, S32 y )
  998. {
  999. x -= llfloor((getRect().getWidth() / 2 + sPanX));
  1000. y -= llfloor((getRect().getHeight() / 2 + sPanY));
  1002. LLVector3 pos_local( (F32)x, (F32)y, 0.f );
  1004. pos_local *= ( REGION_WIDTH_METERS / sMapScale );
  1006. LLVector3d pos_global;
  1007. pos_global.setVec( pos_local );
  1008. pos_global += gAgent.getCameraPositionGlobal();
  1009. if(gAgent.isGodlike())
  1010. {
  1011. pos_global.mdV[VZ] = GODLY_TELEPORT_HEIGHT; // Godly height should always be 200.
  1012. }
  1013. else
  1014. {
  1015. pos_global.mdV[VZ] = gAgent.getPositionAgent().mV[VZ]; // Want agent's height, not camera's
  1016. }
  1018. return pos_global;
  1019. }
  1022. BOOL LLWorldMapView::handleToolTip( S32 x, S32 y, MASK mask )
  1023. {
  1024. LLVector3d pos_global = viewPosToGlobal(x, y);
  1025. U64 handle = to_region_handle(pos_global);
  1026. std::string tooltip_msg;
  1028. LLSimInfo* info = LLWorldMap::getInstance()->simInfoFromHandle(handle);
  1029. if (info)
  1030. {
  1031. LLViewerRegion *region = gAgent.getRegion();
  1033. std::string message = llformat("%s (%s)", info->getName().c_str(), info->getAccessString().c_str());
  1035. if (!info->isDown())
  1036. {
  1037. S32 agent_count = info->getAgentCount();
  1038. if (region && (region->getHandle() == handle))
  1039. {
  1040. ++agent_count; // Bump by 1 if we're here
  1041. }
  1043. // We may not have an agent count when the map is really
  1044. // zoomed out, so don't display anything about the count. JC
  1045. if (agent_count > 0)
  1046. {
  1047. // Merov: i18n horror!!! Even using gettext(), concatenating strings is not localizable. 
  1048. // The singular/plural switch form here under might make no sense in some languages. Don't do that.
  1049. message += llformat("n%d ", agent_count);
  1051. if (agent_count == 1)
  1052. {
  1053. message += "person";
  1054. }
  1055. else
  1056. {
  1057. message += "people";
  1058. }
  1059. }
  1060. }
  1061. tooltip_msg.assign( message );
  1063. // Optionally show region flags
  1064. std::string region_flags = info->getFlagsString();
  1066. if (!region_flags.empty())
  1067. {
  1068. tooltip_msg += 'n';
  1069. tooltip_msg += region_flags;
  1070. }
  1072. const S32 SLOP = 9;
  1073. S32 screen_x, screen_y;
  1075. localPointToScreen(x, y, &screen_x, &screen_y);
  1076. LLRect sticky_rect_screen;
  1077. sticky_rect_screen.setCenterAndSize(screen_x, screen_y, SLOP, SLOP);
  1079. LLToolTipMgr::instance().show(LLToolTip::Params()
  1080. .message(tooltip_msg)
  1081. .sticky_rect(sticky_rect_screen));
  1082. }
  1083. return TRUE;
  1084. }
  1086. // Pass relative Z of 0 to draw at same level.
  1087. // static
  1088. static void drawDot(F32 x_pixels, F32 y_pixels,
  1089.  const LLColor4& color,
  1090.  F32 relative_z,
  1091.  F32 dot_radius,
  1092.  LLUIImagePtr dot_image)
  1093. {
  1094. const F32 HEIGHT_THRESHOLD = 7.f;
  1096. if(-HEIGHT_THRESHOLD <= relative_z && relative_z <= HEIGHT_THRESHOLD)
  1097. {
  1098. dot_image->draw(llround(x_pixels) - dot_image->getWidth()/2,
  1099. llround(y_pixels) - dot_image->getHeight()/2, 
  1100. color);
  1101. }
  1102. else
  1103. {
  1104. // Draw V indicator for above or below
  1105. // *TODO: Replace this vector drawing with icons
  1107. F32 left = x_pixels - dot_radius;
  1108. F32 right = x_pixels + dot_radius;
  1109. F32 center = (left + right) * 0.5f;
  1110. F32 top = y_pixels + dot_radius;
  1111. F32 bottom = y_pixels - dot_radius;
  1113. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  1114. gGL.color4fv( color.mV );
  1115. LLUI::setLineWidth(3.0f);
  1116. F32 point = relative_z > HEIGHT_THRESHOLD ? top : bottom; // Y pos of the point of the V
  1117. F32 back = relative_z > HEIGHT_THRESHOLD ? bottom : top; // Y pos of the ends of the V
  1118. gGL.begin( LLRender::LINES );
  1119. gGL.vertex2f(left, back);
  1120. gGL.vertex2f(center, point);
  1121. gGL.vertex2f(center, point);
  1122. gGL.vertex2f(right, back);
  1123. gGL.end();
  1124. LLUI::setLineWidth(1.0f);
  1125. }
  1126. }
  1128. // Pass relative Z of 0 to draw at same level.
  1129. // static
  1130. void LLWorldMapView::drawAvatar(F32 x_pixels, 
  1131. F32 y_pixels,
  1132. const LLColor4& color,
  1133. F32 relative_z,
  1134. F32 dot_radius)
  1135. {
  1136. const F32 HEIGHT_THRESHOLD = 7.f;
  1137. LLUIImagePtr dot_image = sAvatarLevelImage;
  1138. if(relative_z < -HEIGHT_THRESHOLD) 
  1139. {
  1140. dot_image = sAvatarBelowImage; 
  1141. }
  1142. else if(relative_z > HEIGHT_THRESHOLD) 
  1143. { 
  1144. dot_image = sAvatarAboveImage;
  1145. }
  1146. S32 dot_width = llround(dot_radius * 2.f);
  1147. dot_image->draw(llround(x_pixels - dot_radius),
  1148. llround(y_pixels - dot_radius),
  1149. dot_width,
  1150. dot_width,
  1151. color);
  1152. }
  1154. // Pass relative Z of 0 to draw at same level.
  1155. // static
  1156. void LLWorldMapView::drawTrackingDot( F32 x_pixels, 
  1157.   F32 y_pixels,
  1158.   const LLColor4& color,
  1159.   F32 relative_z,
  1160.   F32 dot_radius)
  1161. {
  1162. drawDot(x_pixels, y_pixels, color, relative_z, dot_radius, sTrackCircleImage);
  1163. }
  1166. // Pass relative Z of 0 to draw at same level.
  1167. // static
  1168. void LLWorldMapView::drawIconName(F32 x_pixels, 
  1169.   F32 y_pixels,
  1170.   const LLColor4& color,
  1171.   const std::string& first_line,
  1172.   const std::string& second_line)
  1173. {
  1174. const S32 VERT_PAD = 8;
  1175. S32 text_x = llround(x_pixels);
  1176. S32 text_y = llround(y_pixels
  1177.  - BIG_DOT_RADIUS
  1178.  - VERT_PAD);
  1180. // render text
  1181. LLFontGL::getFontSansSerif()->renderUTF8(first_line, 0,
  1182. text_x,
  1183. text_y,
  1184. color,
  1185. LLFontGL::HCENTER,
  1186. LLFontGL::TOP,
  1187. LLFontGL::NORMAL, 
  1188. LLFontGL::DROP_SHADOW);
  1190. text_y -= llround(LLFontGL::getFontSansSerif()->getLineHeight());
  1192. // render text
  1193. LLFontGL::getFontSansSerif()->renderUTF8(second_line, 0,
  1194. text_x,
  1195. text_y,
  1196. color,
  1197. LLFontGL::HCENTER,
  1198. LLFontGL::TOP,
  1199. LLFontGL::NORMAL, 
  1200. LLFontGL::DROP_SHADOW);
  1201. }
  1204. //static 
  1205. void LLWorldMapView::drawTrackingCircle( const LLRect& rect, S32 x, S32 y, const LLColor4& color, S32 min_thickness, S32 overlap )
  1206. {
  1207. F32 start_theta = 0.f;
  1208. F32 end_theta = F_TWO_PI;
  1209. F32 x_delta = 0.f;
  1210. F32 y_delta = 0.f;
  1212. if (x < 0)
  1213. {
  1214. x_delta = 0.f - (F32)x;
  1215. start_theta = F_PI + F_PI_BY_TWO;
  1216. end_theta = F_TWO_PI + F_PI_BY_TWO;
  1217. }
  1218. else if (x > rect.getWidth())
  1219. {
  1220. x_delta = (F32)(x - rect.getWidth());
  1221. start_theta = F_PI_BY_TWO;
  1222. end_theta = F_PI + F_PI_BY_TWO;
  1223. }
  1225. if (y < 0)
  1226. {
  1227. y_delta = 0.f - (F32)y;
  1228. if (x < 0)
  1229. {
  1230. start_theta = 0.f;
  1231. end_theta = F_PI_BY_TWO;
  1232. }
  1233. else if (x > rect.getWidth())
  1234. {
  1235. start_theta = F_PI_BY_TWO;
  1236. end_theta = F_PI;
  1237. }
  1238. else
  1239. {
  1240. start_theta = 0.f;
  1241. end_theta = F_PI;
  1242. }
  1243. }
  1244. else if (y > rect.getHeight())
  1245. {
  1246. y_delta = (F32)(y - rect.getHeight());
  1247. if (x < 0)
  1248. {
  1249. start_theta = F_PI + F_PI_BY_TWO;
  1250. end_theta = F_TWO_PI;
  1251. }
  1252. else if (x > rect.getWidth())
  1253. {
  1254. start_theta = F_PI;
  1255. end_theta = F_PI + F_PI_BY_TWO;
  1256. }
  1257. else
  1258. {
  1259. start_theta = F_PI;
  1260. end_theta = F_TWO_PI;
  1261. }
  1262. }
  1264. F32 distance = sqrtf(x_delta * x_delta + y_delta * y_delta);
  1266. distance = llmax(0.1f, distance);
  1268. F32 outer_radius = distance + (1.f + (9.f * sqrtf(x_delta * y_delta) / distance)) * (F32)overlap;
  1269. F32 inner_radius = outer_radius - (F32)min_thickness;
  1271. F32 angle_adjust_x = asin(x_delta / outer_radius);
  1272. F32 angle_adjust_y = asin(y_delta / outer_radius);
  1274. if (angle_adjust_x)
  1275. {
  1276. if (angle_adjust_y)
  1277. {
  1278. F32 angle_adjust = llmin(angle_adjust_x, angle_adjust_y);
  1279. start_theta += angle_adjust;
  1280. end_theta -= angle_adjust;
  1281. }
  1282. else
  1283. {
  1284. start_theta += angle_adjust_x;
  1285. end_theta -= angle_adjust_x;
  1286. }
  1287. }
  1288. else if (angle_adjust_y)
  1289. {
  1290. start_theta += angle_adjust_y;
  1291. end_theta -= angle_adjust_y;
  1292. }
  1294. glMatrixMode(GL_MODELVIEW);
  1295. gGL.pushMatrix();
  1296. gGL.translatef((F32)x, (F32)y, 0.f);
  1297. gl_washer_segment_2d(inner_radius, outer_radius, start_theta, end_theta, 40, color, color);
  1298. gGL.popMatrix();
  1300. }
  1302. // static
  1303. void LLWorldMapView::drawTrackingArrow(const LLRect& rect, S32 x, S32 y, 
  1304.    const LLColor4& color,
  1305.    S32 arrow_size)
  1306. {
  1307. F32 x_center = (F32)rect.getWidth() / 2.f;
  1308. F32 y_center = (F32)rect.getHeight() / 2.f;
  1310. F32 x_clamped = (F32)llclamp( x, 0, rect.getWidth() - arrow_size );
  1311. F32 y_clamped = (F32)llclamp( y, 0, rect.getHeight() - arrow_size );
  1313. F32 slope = (F32)(y - y_center) / (F32)(x - x_center);
  1314. F32 window_ratio = (F32)rect.getHeight() / (F32)rect.getWidth();
  1316. if (llabs(slope) > window_ratio && y_clamped != (F32)y)
  1317. {
  1318. // clamp by y 
  1319. x_clamped = (y_clamped - y_center) / slope + x_center;
  1320. // adjust for arrow size
  1321. x_clamped  = llclamp(x_clamped , 0.f, (F32)(rect.getWidth() - arrow_size) );
  1322. }
  1323. else if (x_clamped != (F32)x)
  1324. {
  1325. // clamp by x
  1326. y_clamped = (x_clamped - x_center) * slope + y_center;
  1327. // adjust for arrow size 
  1328. y_clamped = llclamp( y_clamped, 0.f, (F32)(rect.getHeight() - arrow_size) );
  1329. }
  1331. // *FIX: deal with non-square window properly.
  1332. // I do not understand what this comment means -- is it actually
  1333. // broken or is it correctly dealing with non-square
  1334. // windows. Phoenix 2007-01-03.
  1335. S32 half_arrow_size = (S32) (0.5f * arrow_size);
  1337. F32 angle = atan2( y + half_arrow_size - y_center, x + half_arrow_size - x_center);
  1339. sTrackingArrowX = llfloor(x_clamped);
  1340. sTrackingArrowY = llfloor(y_clamped);
  1342. gl_draw_scaled_rotated_image(
  1343. sTrackingArrowX,
  1344. sTrackingArrowY,
  1345. arrow_size, arrow_size, 
  1346. RAD_TO_DEG * angle, 
  1347. sTrackArrowImage->getImage(), 
  1348. color);
  1349. }
  1351. void LLWorldMapView::setDirectionPos( LLTextBox* text_box, F32 rotation )
  1352. {
  1353. // Rotation is in radians.
  1354. // Rotation of 0 means x = 1, y = 0 on the unit circle.
  1357. F32 map_half_height = getRect().getHeight() * 0.5f;
  1358. F32 map_half_width = getRect().getWidth() * 0.5f;
  1359. F32 text_half_height = text_box->getRect().getHeight() * 0.5f;
  1360. F32 text_half_width = text_box->getRect().getWidth() * 0.5f;
  1361. F32 radius = llmin( map_half_height - text_half_height, map_half_width - text_half_width );
  1363. text_box->setOrigin( 
  1364. llround(map_half_width - text_half_width + radius * cos( rotation )),
  1365. llround(map_half_height - text_half_height + radius * sin( rotation )) );
  1366. }
  1369. void LLWorldMapView::updateDirections()
  1370. {
  1371. S32 width = getRect().getWidth();
  1372. S32 height = getRect().getHeight();
  1374. S32 text_height = mTextBoxNorth->getRect().getHeight();
  1375. S32 text_width = mTextBoxNorth->getRect().getWidth();
  1377. const S32 PAD = 2;
  1378. S32 top = height - text_height - PAD;
  1379. S32 left = PAD*2;
  1380. S32 bottom = PAD;
  1381. S32 right = width - text_width - PAD;
  1382. S32 center_x = width/2 - text_width/2;
  1383. S32 center_y = height/2 - text_height/2;
  1385. mTextBoxNorth->setOrigin( center_x, top );
  1386. mTextBoxEast->setOrigin( right, center_y );
  1387. mTextBoxSouth->setOrigin( center_x, bottom );
  1388. mTextBoxWest->setOrigin( left, center_y );
  1390. // These have wider text boxes
  1391. text_width = mTextBoxNorthWest->getRect().getWidth();
  1392. right = width - text_width - PAD;
  1394. mTextBoxNorthWest->setOrigin(left, top);
  1395. mTextBoxNorthEast->setOrigin(right, top);
  1396. mTextBoxSouthWest->setOrigin(left, bottom);
  1397. mTextBoxSouthEast->setOrigin(right, bottom);
  1399. //  S32 hint_width = mTextBoxScrollHint->getRect().getWidth();
  1400. //  mTextBoxScrollHint->setOrigin( width - hint_width - text_width - 2 * PAD, 
  1401. //  PAD * 2 + text_height );
  1402. }
  1405. void LLWorldMapView::reshape( S32 width, S32 height, BOOL called_from_parent )
  1406. {
  1407. LLView::reshape( width, height, called_from_parent );
  1408. }
  1410. bool LLWorldMapView::checkItemHit(S32 x, S32 y, LLItemInfo& item, LLUUID* id, bool track)
  1411. {
  1412. LLVector3 pos_view = globalPosToView(item.getGlobalPosition());
  1413. S32 item_x = llround(pos_view.mV[VX]);
  1414. S32 item_y = llround(pos_view.mV[VY]);
  1416. if (x < item_x - BIG_DOT_RADIUS) return false;
  1417. if (x > item_x + BIG_DOT_RADIUS) return false;
  1418. if (y < item_y - BIG_DOT_RADIUS) return false;
  1419. if (y > item_y + BIG_DOT_RADIUS) return false;
  1421. LLSimInfo* sim_info = LLWorldMap::getInstance()->simInfoFromHandle(item.getRegionHandle());
  1422. if (sim_info)
  1423. {
  1424. if (track)
  1425. {
  1426. gFloaterWorldMap->trackLocation(item.getGlobalPosition());
  1427. }
  1428. }
  1430. if (track)
  1431. {
  1432. gFloaterWorldMap->trackGenericItem(item);
  1433. }
  1435. // item.setSelected(true);
  1436. *id = item.getUUID();
  1438. return true;
  1439. }
  1441. // Handle a click, which might be on a dot
  1442. void LLWorldMapView::handleClick(S32 x, S32 y, MASK mask,
  1443.  S32* hit_type,
  1444.  LLUUID* id)
  1445. {
  1446. LLVector3d pos_global = viewPosToGlobal(x, y);
  1448. // *HACK: Adjust Z values automatically for liaisons & gods so
  1449. // we swoop down when they click on the map. Sadly, the P2P
  1450. // branch does not pay attention to this value; however, the
  1451. // Distributed Messaging branch honors it.
  1452. if(gAgent.isGodlike())
  1453. {
  1454. pos_global.mdV[VZ] = 200.0;
  1455. }
  1457. *hit_type = 0; // hit nothing
  1459. LLWorldMap::getInstance()->cancelTracking();
  1461. S32 level = LLWorldMipmap::scaleToLevel(sMapScale);
  1462. // If the zoom level is not too far out already, test hits
  1463. if (level <= DRAW_SIMINFO_THRESHOLD)
  1464. {
  1465. bool show_mature = gAgent.canAccessMature() && gSavedSettings.getBOOL("ShowMatureEvents");
  1466. bool show_adult = gAgent.canAccessAdult() && gSavedSettings.getBOOL("ShowAdultEvents");
  1468. // Test hits if trackable data are displayed, otherwise, we don't even bother
  1469. if (gSavedSettings.getBOOL("MapShowEvents") || show_mature || show_adult || gSavedSettings.getBOOL("MapShowLandForSale"))
  1470. {
  1471. // Iterate through the visible regions
  1472. for (handle_list_t::iterator iter = mVisibleRegions.begin(); iter != mVisibleRegions.end(); ++iter)
  1473. {
  1474. U64 handle = *iter;
  1475. LLSimInfo* siminfo = LLWorldMap::getInstance()->simInfoFromHandle(handle);
  1476. if ((siminfo == NULL) || (siminfo->isDown()))
  1477. {
  1478. continue;
  1479. }
  1480. // If on screen check hits with the visible item lists
  1481. if (gSavedSettings.getBOOL("MapShowEvents"))
  1482. {
  1483. LLSimInfo::item_info_list_t::const_iterator it = siminfo->getPGEvent().begin();
  1484. while (it != siminfo->getPGEvent().end())
  1485. {
  1486. LLItemInfo event = *it;
  1487. if (checkItemHit(x, y, event, id, false))
  1488. {
  1489. *hit_type = MAP_ITEM_PG_EVENT;
  1490. mItemPicked = TRUE;
  1491. gFloaterWorldMap->trackEvent(event);
  1492. return;
  1493. }
  1494. ++it;
  1495. }
  1496. }
  1497. if (show_mature)
  1498. {
  1499. LLSimInfo::item_info_list_t::const_iterator it = siminfo->getMatureEvent().begin();
  1500. while (it != siminfo->getMatureEvent().end())
  1501. {
  1502. LLItemInfo event = *it;
  1503. if (checkItemHit(x, y, event, id, false))
  1504. {
  1505. *hit_type = MAP_ITEM_MATURE_EVENT;
  1506. mItemPicked = TRUE;
  1507. gFloaterWorldMap->trackEvent(event);
  1508. return;
  1509. }
  1510. ++it;
  1511. }
  1512. }
  1513. if (show_adult)
  1514. {
  1515. LLSimInfo::item_info_list_t::const_iterator it = siminfo->getAdultEvent().begin();
  1516. while (it != siminfo->getAdultEvent().end())
  1517. {
  1518. LLItemInfo event = *it;
  1519. if (checkItemHit(x, y, event, id, false))
  1520. {
  1521. *hit_type = MAP_ITEM_ADULT_EVENT;
  1522. mItemPicked = TRUE;
  1523. gFloaterWorldMap->trackEvent(event);
  1524. return;
  1525. }
  1526. ++it;
  1527. }
  1528. }
  1529. if (gSavedSettings.getBOOL("MapShowLandForSale"))
  1530. {
  1531. LLSimInfo::item_info_list_t::const_iterator it = siminfo->getLandForSale().begin();
  1532. while (it != siminfo->getLandForSale().end())
  1533. {
  1534. LLItemInfo event = *it;
  1535. if (checkItemHit(x, y, event, id, true))
  1536. {
  1537. *hit_type = MAP_ITEM_LAND_FOR_SALE;
  1538. mItemPicked = TRUE;
  1539. return;
  1540. }
  1541. ++it;
  1542. }
  1543. // for 1.23, we're showing normal land and adult land in the same UI; you don't
  1544. // get a choice about which ones you want. If you're currently asking for adult
  1545. // content and land you'll get the adult land.
  1546. if (gAgent.canAccessAdult())
  1547. {
  1548. LLSimInfo::item_info_list_t::const_iterator it = siminfo->getLandForSaleAdult().begin();
  1549. while (it != siminfo->getLandForSaleAdult().end())
  1550. {
  1551. LLItemInfo event = *it;
  1552. if (checkItemHit(x, y, event, id, true))
  1553. {
  1554. *hit_type = MAP_ITEM_LAND_FOR_SALE_ADULT;
  1555. mItemPicked = TRUE;
  1556. return;
  1557. }
  1558. ++it;
  1559. }
  1560. }
  1561. }
  1562. }
  1563. }
  1564. }
  1566. // If we get here, we haven't clicked on anything
  1567. gFloaterWorldMap->trackLocation(pos_global);
  1568. mItemPicked = FALSE;
  1569. *id = LLUUID::null;
  1570. return;
  1571. }
  1574. BOOL outside_slop(S32 x, S32 y, S32 start_x, S32 start_y)
  1575. {
  1576. S32 dx = x - start_x;
  1577. S32 dy = y - start_y;
  1579. return (dx <= -2 || 2 <= dx || dy <= -2 || 2 <= dy);
  1580. }
  1582. BOOL LLWorldMapView::handleMouseDown( S32 x, S32 y, MASK mask )
  1583. {
  1584. gFocusMgr.setMouseCapture( this );
  1586. mMouseDownPanX = llround(sPanX);
  1587. mMouseDownPanY = llround(sPanY);
  1588. mMouseDownX = x;
  1589. mMouseDownY = y;
  1590. sHandledLastClick = TRUE;
  1591. return TRUE;
  1592. }
  1594. BOOL LLWorldMapView::handleMouseUp( S32 x, S32 y, MASK mask )
  1595. {
  1596. if (hasMouseCapture())
  1597. {
  1598. if (mPanning)
  1599. {
  1600. // restore mouse cursor
  1601. S32 local_x, local_y;
  1602. local_x = mMouseDownX + llfloor(sPanX - mMouseDownPanX);
  1603. local_y = mMouseDownY + llfloor(sPanY - mMouseDownPanY);
  1604. LLRect clip_rect = getRect();
  1605. clip_rect.stretch(-8);
  1606. clip_rect.clipPointToRect(mMouseDownX, mMouseDownY, local_x, local_y);
  1607. LLUI::setMousePositionLocal(this, local_x, local_y);
  1609. // finish the pan
  1610. mPanning = FALSE;
  1612. mMouseDownX = 0;
  1613. mMouseDownY = 0;
  1614. }
  1615. else
  1616. {
  1617. // ignore whether we hit an event or not
  1618. S32 hit_type;
  1619. LLUUID id;
  1620. handleClick(x, y, mask, &hit_type, &id);
  1621. }
  1622. gViewerWindow->showCursor();
  1623. gFocusMgr.setMouseCapture( NULL );
  1624. return TRUE;
  1625. }
  1626. return FALSE;
  1627. }
  1629. void LLWorldMapView::updateVisibleBlocks()
  1630. {
  1631. if (LLWorldMipmap::scaleToLevel(sMapScale) > DRAW_SIMINFO_THRESHOLD)
  1632. {
  1633. // If we're zoomed out too much, we just don't load all those sim info: too much!
  1634. return;
  1635. }
  1637. // Load the blocks visible in the current World Map view
  1639. // Get the World Map view coordinates and boundaries
  1640. LLVector3d camera_global = gAgent.getCameraPositionGlobal();
  1641. const S32 width = getRect().getWidth();
  1642. const S32 height = getRect().getHeight();
  1643. const F32 half_width = F32(width) / 2.0f;
  1644. const F32 half_height = F32(height) / 2.0f;
  1646. // Compute center into sim grid coordinates
  1647. S32 world_center_x = S32((-sPanX / sMapScale) + (camera_global.mdV[0] / REGION_WIDTH_METERS));
  1648. S32 world_center_y = S32((-sPanY / sMapScale) + (camera_global.mdV[1] / REGION_WIDTH_METERS));
  1650. // Compute the boundaries into sim grid coordinates
  1651. S32 world_left   = world_center_x - S32(half_width  / sMapScale) - 1;
  1652. S32 world_right  = world_center_x + S32(half_width  / sMapScale) + 1;
  1653. S32 world_bottom = world_center_y - S32(half_height / sMapScale) - 1;
  1654. S32 world_top    = world_center_y + S32(half_height / sMapScale) + 1;
  1656. //LL_INFOS("World Map") << "LLWorldMapView::updateVisibleBlocks() : sMapScale = " << sMapScale << ", left = " << world_left << ", right = " << world_right << ", bottom  = " << world_bottom << ", top = " << world_top << LL_ENDL;
  1657. LLWorldMap::getInstance()->updateRegions(world_left, world_bottom, world_right, world_top);
  1658. }
  1660. BOOL LLWorldMapView::handleHover( S32 x, S32 y, MASK mask )
  1661. {
  1662. if (hasMouseCapture())
  1663. {
  1664. if (mPanning || outside_slop(x, y, mMouseDownX, mMouseDownY))
  1665. {
  1666. // just started panning, so hide cursor
  1667. if (!mPanning)
  1668. {
  1669. mPanning = TRUE;
  1670. gViewerWindow->hideCursor();
  1671. }
  1673. F32 delta_x = (F32)(gViewerWindow->getCurrentMouseDX());
  1674. F32 delta_y = (F32)(gViewerWindow->getCurrentMouseDY());
  1676. // Set pan to value at start of drag + offset
  1677. sPanX += delta_x;
  1678. sPanY += delta_y;
  1679. sTargetPanX = sPanX;
  1680. sTargetPanY = sPanY;
  1682. gViewerWindow->moveCursorToCenter();
  1683. }
  1685. // doesn't matter, cursor should be hidden
  1686. gViewerWindow->setCursor(UI_CURSOR_CROSS );
  1687. return TRUE;
  1688. }
  1689. else
  1690. {
  1691. // While we're waiting for data from the tracker, we're busy. JC
  1692. LLVector3d pos_global = LLTracker::getTrackedPositionGlobal();
  1693. if (LLTracker::isTracking(NULL)
  1694. && pos_global.isExactlyZero())
  1695. {
  1696. gViewerWindow->setCursor( UI_CURSOR_WAIT );
  1697. }
  1698. else
  1699. {
  1700. gViewerWindow->setCursor( UI_CURSOR_CROSS );
  1701. }
  1702. lldebugst(LLERR_USER_INPUT) << "hover handled by LLWorldMapView" << llendl;
  1703. return TRUE;
  1704. }
  1705. }
  1708. BOOL LLWorldMapView::handleDoubleClick( S32 x, S32 y, MASK mask )
  1709. {
  1710. if( sHandledLastClick )
  1711. {
  1712. S32 hit_type;
  1713. LLUUID id;
  1714. handleClick(x, y, mask, &hit_type, &id);
  1716. switch (hit_type)
  1717. {
  1718. case MAP_ITEM_PG_EVENT:
  1719. case MAP_ITEM_MATURE_EVENT:
  1720. case MAP_ITEM_ADULT_EVENT:
  1721. {
  1722. LLFloaterReg::hideInstance("world_map");
  1723. // This is an ungainly hack
  1724. std::string uuid_str;
  1725. S32 event_id;
  1726. id.toString(uuid_str);
  1727. uuid_str = uuid_str.substr(28);
  1728. sscanf(uuid_str.c_str(), "%X", &event_id);
  1729. LLFloaterReg::showInstance("search", LLSD().with("category", "events").with("id", event_id));
  1730. break;
  1731. }
  1732. case MAP_ITEM_LAND_FOR_SALE:
  1733. case MAP_ITEM_LAND_FOR_SALE_ADULT:
  1734. {
  1735. LLFloaterReg::hideInstance("world_map");
  1736. LLFloaterReg::showInstance("search", LLSD().with("category", "destinations").with("id", id));
  1737. break;
  1738. }
  1739. case MAP_ITEM_CLASSIFIED:
  1740. {
  1741. LLFloaterReg::hideInstance("world_map");
  1742. LLFloaterReg::showInstance("search", LLSD().with("category", "classifieds").with("id", id));
  1743. break;
  1744. }
  1745. default:
  1746. {
  1747. if (LLWorldMap::getInstance()->isTracking())
  1748. {
  1749. LLWorldMap::getInstance()->setTrackingDoubleClick();
  1750. }
  1751. else
  1752. {
  1753. // Teleport if we got a valid location
  1754. LLVector3d pos_global = viewPosToGlobal(x,y);
  1755. LLSimInfo* sim_info = LLWorldMap::getInstance()->simInfoFromPosGlobal(pos_global);
  1756. if (sim_info && !sim_info->isDown())
  1757. {
  1758. gAgent.teleportViaLocation( pos_global );
  1759. }
  1760. }
  1761. }
  1762. };
  1764. return TRUE;
  1765. }
  1766. return FALSE;
  1767. }