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

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

游戏引擎

开发平台：

C++ Builder

llnetmap.cpp：源码内容
  1. /** 
  2.  * @file llnetmap.cpp
  3.  * @author James Cook
  4.  * @brief Display of surrounding regions, objects, and agents. 
  5.  *
  6.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2001-2010, Linden Research, Inc.
  9.  * 
  10.  * Second Life Viewer Source Code
  11.  * The source code in this file ("Source Code") is provided by Linden Lab
  12.  * to you under the terms of the GNU General Public License, version 2.0
  13.  * ("GPL"), unless you have obtained a separate licensing agreement
  14.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  15.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  16.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  17.  * 
  18.  * There are special exceptions to the terms and conditions of the GPL as
  19.  * it is applied to this Source Code. View the full text of the exception
  20.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  21.  * online at
  22.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  23.  * 
  24.  * By copying, modifying or distributing this software, you acknowledge
  25.  * that you have read and understood your obligations described above,
  26.  * and agree to abide by those obligations.
  27.  * 
  28.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  29.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  30.  * COMPLETENESS OR PERFORMANCE.
  31.  * $/LicenseInfo$
  32.  */
  34. #include "llviewerprecompiledheaders.h"
  36. #include "llnetmap.h"
  38. // Library includes (should move below)
  39. #include "indra_constants.h"
  40. #include "llmath.h"
  41. #include "llfloaterreg.h"
  42. #include "llfocusmgr.h"
  43. #include "lllocalcliprect.h"
  44. #include "llrender.h"
  45. #include "llui.h"
  46. #include "lltooltip.h"
  48. #include "llglheaders.h"
  50. // Viewer includes
  51. #include "llagent.h"
  52. #include "llappviewer.h" // for gDisconnected
  53. #include "llcallingcard.h" // LLAvatarTracker
  54. #include "lltracker.h"
  55. #include "llsurface.h"
  56. #include "llviewercamera.h"
  57. #include "llviewercontrol.h"
  58. #include "llviewertexture.h"
  59. #include "llviewertexturelist.h"
  60. #include "llviewermenu.h"
  61. #include "llviewerobjectlist.h"
  62. #include "llviewerregion.h"
  63. #include "llworld.h"
  64. #include "llworldmapview.h" // shared draw code
  66. static LLDefaultChildRegistry::Register<LLNetMap> r1("net_map");
  68. const F32 LLNetMap::MAP_SCALE_MIN = 32;
  69. const F32 LLNetMap::MAP_SCALE_MID = 1024;
  70. const F32 LLNetMap::MAP_SCALE_MAX = 4096;
  72. const F32 MAP_SCALE_INCREMENT = 16;
  73. const F32 MAP_SCALE_ZOOM_FACTOR = 1.04f; // Zoom in factor per click of scroll wheel (4%)
  74. const F32 MIN_DOT_RADIUS = 3.5f;
  75. const F32 DOT_SCALE = 0.75f;
  76. const F32 MIN_PICK_SCALE = 2.f;
  78. LLNetMap::LLNetMap (const Params & p)
  79. : LLUICtrl (p),
  80. mBackgroundColor (p.bg_color()),
  81. mScale( MAP_SCALE_MID ),
  82. mPixelsPerMeter( MAP_SCALE_MID / REGION_WIDTH_METERS ),
  83. mObjectMapTPM(0.f),
  84. mObjectMapPixels(0.f),
  85. mTargetPanX(0.f),
  86. mTargetPanY(0.f),
  87. mCurPanX(0.f),
  88. mCurPanY(0.f),
  89. mUpdateNow(FALSE),
  90. mObjectImageCenterGlobal( gAgent.getCameraPositionGlobal() ),
  91. mObjectRawImagep(),
  92. mObjectImagep(),
  93. mClosestAgentToCursor(),
  94. mClosestAgentAtLastRightClick(),
  95. mToolTipMsg()
  96. {
  97. mDotRadius = llmax(DOT_SCALE * mPixelsPerMeter, MIN_DOT_RADIUS);
  98. }
  100. LLNetMap::~LLNetMap()
  101. {
  102. }
  104. void LLNetMap::setScale( F32 scale )
  105. {
  106. mScale = llclamp(scale, 0.1f, 16.f*1024.f); // [reasonably small , unreasonably large]
  108. if (mObjectImagep.notNull())
  109. {
  110. F32 width = (F32)(getRect().getWidth());
  111. F32 height = (F32)(getRect().getHeight());
  112. F32 diameter = sqrt(width * width + height * height);
  113. F32 region_widths = diameter / mScale;
  114. F32 meters = region_widths * LLWorld::getInstance()->getRegionWidthInMeters();
  115. F32 num_pixels = (F32)mObjectImagep->getWidth();
  116. mObjectMapTPM = num_pixels / meters;
  117. mObjectMapPixels = diameter;
  118. }
  120. mPixelsPerMeter = mScale / REGION_WIDTH_METERS;
  121. mDotRadius = llmax(DOT_SCALE * mPixelsPerMeter, MIN_DOT_RADIUS);
  123. mUpdateNow = TRUE;
  124. }
  126. void LLNetMap::translatePan( F32 delta_x, F32 delta_y )
  127. {
  128. mTargetPanX += delta_x;
  129. mTargetPanY += delta_y;
  130. }
  133. ///////////////////////////////////////////////////////////////////////////////////
  135. void LLNetMap::draw()
  136. {
  137.   static LLFrameTimer map_timer;
  138. static LLUIColor map_avatar_color = LLUIColorTable::instance().getColor("MapAvatarColor", LLColor4::white);
  139. static LLUIColor map_avatar_friend_color = LLUIColorTable::instance().getColor("MapAvatarFriendColor", LLColor4::white);
  140. static LLUIColor map_track_color = LLUIColorTable::instance().getColor("MapTrackColor", LLColor4::white);
  141. static LLUIColor map_track_disabled_color = LLUIColorTable::instance().getColor("MapTrackDisabledColor", LLColor4::white);
  142. static LLUIColor map_frustum_color = LLUIColorTable::instance().getColor("MapFrustumColor", LLColor4::white);
  143. static LLUIColor map_frustum_rotating_color = LLUIColorTable::instance().getColor("MapFrustumRotatingColor", LLColor4::white);
  145. if (mObjectImagep.isNull())
  146. {
  147. createObjectImage();
  148. }
  150. mCurPanX = lerp(mCurPanX, mTargetPanX, LLCriticalDamp::getInterpolant(0.1f));
  151. mCurPanY = lerp(mCurPanY, mTargetPanY, LLCriticalDamp::getInterpolant(0.1f));
  153. // Prepare a scissor region
  154. F32 rotation = 0;
  156. {
  157. LLLocalClipRect clip(getLocalRect());
  158. {
  159. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  161. glMatrixMode(GL_MODELVIEW);
  163. // Draw background rectangle
  164. LLColor4 background_color = mBackgroundColor.get();
  165. gGL.color4fv( background_color.mV );
  166. gl_rect_2d(0, getRect().getHeight(), getRect().getWidth(), 0);
  167. }
  169. // region 0,0 is in the middle
  170. S32 center_sw_left = getRect().getWidth() / 2 + llfloor(mCurPanX);
  171. S32 center_sw_bottom = getRect().getHeight() / 2 + llfloor(mCurPanY);
  173. gGL.pushMatrix();
  175. gGL.translatef( (F32) center_sw_left, (F32) center_sw_bottom, 0.f);
  177. static LLUICachedControl<bool> rotate_map("MiniMapRotate", true);
  178. if( rotate_map )
  179. {
  180. // rotate subsequent draws to agent rotation
  181. rotation = atan2( LLViewerCamera::getInstance()->getAtAxis().mV[VX], LLViewerCamera::getInstance()->getAtAxis().mV[VY] );
  182. glRotatef( rotation * RAD_TO_DEG, 0.f, 0.f, 1.f);
  183. }
  185. // figure out where agent is
  186. S32 region_width = llround(LLWorld::getInstance()->getRegionWidthInMeters());
  188. for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin();
  189.  iter != LLWorld::getInstance()->getRegionList().end(); ++iter)
  190. {
  191. LLViewerRegion* regionp = *iter;
  192. // Find x and y position relative to camera's center.
  193. LLVector3 origin_agent = regionp->getOriginAgent();
  194. LLVector3 rel_region_pos = origin_agent - gAgent.getCameraPositionAgent();
  195. F32 relative_x = (rel_region_pos.mV[0] / region_width) * mScale;
  196. F32 relative_y = (rel_region_pos.mV[1] / region_width) * mScale;
  198. // background region rectangle
  199. F32 bottom = relative_y;
  200. F32 left = relative_x;
  201. F32 top = bottom + mScale ;
  202. F32 right = left + mScale ;
  204. if (regionp == gAgent.getRegion())
  205. {
  206. gGL.color4f(1.f, 1.f, 1.f, 1.f);
  207. }
  208. else
  209. {
  210. gGL.color4f(0.8f, 0.8f, 0.8f, 1.f);
  211. }
  213. if (!regionp->isAlive())
  214. {
  215. gGL.color4f(1.f, 0.5f, 0.5f, 1.f);
  216. }
  219. // Draw using texture.
  220. gGL.getTexUnit(0)->bind(regionp->getLand().getSTexture());
  221. gGL.begin(LLRender::QUADS);
  222. gGL.texCoord2f(0.f, 1.f);
  223. gGL.vertex2f(left, top);
  224. gGL.texCoord2f(0.f, 0.f);
  225. gGL.vertex2f(left, bottom);
  226. gGL.texCoord2f(1.f, 0.f);
  227. gGL.vertex2f(right, bottom);
  228. gGL.texCoord2f(1.f, 1.f);
  229. gGL.vertex2f(right, top);
  230. gGL.end();
  232. // Draw water
  233. gGL.setAlphaRejectSettings(LLRender::CF_GREATER, ABOVE_WATERLINE_ALPHA / 255.f);
  234. {
  235. if (regionp->getLand().getWaterTexture())
  236. {
  237. gGL.getTexUnit(0)->bind(regionp->getLand().getWaterTexture());
  238. gGL.begin(LLRender::QUADS);
  239. gGL.texCoord2f(0.f, 1.f);
  240. gGL.vertex2f(left, top);
  241. gGL.texCoord2f(0.f, 0.f);
  242. gGL.vertex2f(left, bottom);
  243. gGL.texCoord2f(1.f, 0.f);
  244. gGL.vertex2f(right, bottom);
  245. gGL.texCoord2f(1.f, 1.f);
  246. gGL.vertex2f(right, top);
  247. gGL.end();
  248. }
  249. }
  250. gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
  251. }
  254. LLVector3d old_center = mObjectImageCenterGlobal;
  255. LLVector3d new_center = gAgent.getCameraPositionGlobal();
  257. new_center.mdV[0] = (5.f/mObjectMapTPM)*floor(0.2f*mObjectMapTPM*new_center.mdV[0]);
  258. new_center.mdV[1] = (5.f/mObjectMapTPM)*floor(0.2f*mObjectMapTPM*new_center.mdV[1]);
  259. new_center.mdV[2] = 0.f;
  261. if (mUpdateNow || (map_timer.getElapsedTimeF32() > 0.5f))
  262. {
  263. mUpdateNow = FALSE;
  264. mObjectImageCenterGlobal = new_center;
  266. // Center moved enough.
  267. // Create the base texture.
  268. U8 *default_texture = mObjectRawImagep->getData();
  269. memset( default_texture, 0, mObjectImagep->getWidth() * mObjectImagep->getHeight() * mObjectImagep->getComponents() );
  271. // Draw buildings
  272. gObjectList.renderObjectsForMap(*this);
  274. mObjectImagep->setSubImage(mObjectRawImagep, 0, 0, mObjectImagep->getWidth(), mObjectImagep->getHeight());
  276. map_timer.reset();
  277. }
  279. LLVector3 map_center_agent = gAgent.getPosAgentFromGlobal(mObjectImageCenterGlobal);
  280. map_center_agent -= gAgent.getCameraPositionAgent();
  281. map_center_agent.mV[VX] *= mScale/region_width;
  282. map_center_agent.mV[VY] *= mScale/region_width;
  284. gGL.getTexUnit(0)->bind(mObjectImagep);
  285. F32 image_half_width = 0.5f*mObjectMapPixels;
  286. F32 image_half_height = 0.5f*mObjectMapPixels;
  288. gGL.begin(LLRender::QUADS);
  289. gGL.texCoord2f(0.f, 1.f);
  290. gGL.vertex2f(map_center_agent.mV[VX] - image_half_width, image_half_height + map_center_agent.mV[VY]);
  291. gGL.texCoord2f(0.f, 0.f);
  292. gGL.vertex2f(map_center_agent.mV[VX] - image_half_width, map_center_agent.mV[VY] - image_half_height);
  293. gGL.texCoord2f(1.f, 0.f);
  294. gGL.vertex2f(image_half_width + map_center_agent.mV[VX], map_center_agent.mV[VY] - image_half_height);
  295. gGL.texCoord2f(1.f, 1.f);
  296. gGL.vertex2f(image_half_width + map_center_agent.mV[VX], image_half_height + map_center_agent.mV[VY]);
  297. gGL.end();
  299. gGL.popMatrix();
  301. LLVector3d pos_global;
  302. LLVector3 pos_map;
  304. // Mouse pointer in local coordinates
  305. S32 local_mouse_x;
  306. S32 local_mouse_y;
  307. //localMouse(&local_mouse_x, &local_mouse_y);
  308. LLUI::getMousePositionLocal(this, &local_mouse_x, &local_mouse_y);
  309. mClosestAgentToCursor.setNull();
  310. F32 closest_dist = F32_MAX;
  311. F32 min_pick_dist = mDotRadius * MIN_PICK_SCALE; 
  313. // Draw avatars
  314. for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin();
  315.  iter != LLWorld::getInstance()->getRegionList().end(); ++iter)
  316. {
  317. LLViewerRegion* regionp = *iter;
  318. const LLVector3d& origin_global = regionp->getOriginGlobal();
  320. S32 count = regionp->mMapAvatars.count();
  321. S32 i;
  322. LLVector3 pos_local;
  323. U32 compact_local;
  324. U8 bits;
  325. // TODO: it'd be very cool to draw these in sorted order from lowest Z to highest.
  326. // just be careful to sort the avatar IDs along with the positions. -MG
  327. for (i = 0; i < count; i++)
  328. {
  329. compact_local = regionp->mMapAvatars.get(i);
  331. bits = compact_local & 0xFF;
  332. pos_local.mV[VZ] = F32(bits) * 4.f;
  333. compact_local >>= 8;
  335. bits = compact_local & 0xFF;
  336. pos_local.mV[VY] = (F32)bits;
  337. compact_local >>= 8;
  339. bits = compact_local & 0xFF;
  340. pos_local.mV[VX] = (F32)bits;
  342. pos_global.setVec( pos_local );
  343. pos_global += origin_global;
  345. pos_map = globalPosToView(pos_global);
  347. BOOL show_as_friend = FALSE;
  348. if( i < regionp->mMapAvatarIDs.count())
  349. {
  350. show_as_friend = (LLAvatarTracker::instance().getBuddyInfo(regionp->mMapAvatarIDs.get(i)) != NULL);
  351. }
  352. LLWorldMapView::drawAvatar(
  353. pos_map.mV[VX], pos_map.mV[VY], 
  354. show_as_friend ? map_avatar_friend_color : map_avatar_color, 
  355. pos_map.mV[VZ], mDotRadius);
  357. F32 dist_to_cursor = dist_vec(LLVector2(pos_map.mV[VX], pos_map.mV[VY]), LLVector2(local_mouse_x,local_mouse_y));
  358. if(dist_to_cursor < min_pick_dist && dist_to_cursor < closest_dist)
  359. {
  360. closest_dist = dist_to_cursor;
  361. mClosestAgentToCursor = regionp->mMapAvatarIDs.get(i);
  362. }
  363. }
  364. }
  366. // Draw dot for autopilot target
  367. if (gAgent.getAutoPilot())
  368. {
  369. drawTracking( gAgent.getAutoPilotTargetGlobal(), map_track_color );
  370. }
  371. else
  372. {
  373. LLTracker::ETrackingStatus tracking_status = LLTracker::getTrackingStatus();
  374. if (  LLTracker::TRACKING_AVATAR == tracking_status )
  375. {
  376. drawTracking( LLAvatarTracker::instance().getGlobalPos(), map_track_color );
  377. } 
  378. else if ( LLTracker::TRACKING_LANDMARK == tracking_status 
  379. || LLTracker::TRACKING_LOCATION == tracking_status )
  380. {
  381. drawTracking( LLTracker::getTrackedPositionGlobal(), map_track_color );
  382. }
  383. }
  385. // Draw dot for self avatar position
  386. pos_global = gAgent.getPositionGlobal();
  387. pos_map = globalPosToView(pos_global);
  388. LLUIImagePtr you = LLWorldMapView::sAvatarYouLargeImage;
  389. S32 dot_width = llround(mDotRadius * 2.f);
  390. you->draw(llround(pos_map.mV[VX] - mDotRadius),
  391.   llround(pos_map.mV[VY] - mDotRadius),
  392.   dot_width,
  393.   dot_width);
  395. // Draw frustum
  396. F32 meters_to_pixels = mScale/ LLWorld::getInstance()->getRegionWidthInMeters();
  398. F32 horiz_fov = LLViewerCamera::getInstance()->getView() * LLViewerCamera::getInstance()->getAspect();
  399. F32 far_clip_meters = LLViewerCamera::getInstance()->getFar();
  400. F32 far_clip_pixels = far_clip_meters * meters_to_pixels;
  402. F32 half_width_meters = far_clip_meters * tan( horiz_fov / 2 );
  403. F32 half_width_pixels = half_width_meters * meters_to_pixels;
  405. F32 ctr_x = (F32)center_sw_left;
  406. F32 ctr_y = (F32)center_sw_bottom;
  409. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  411. if( rotate_map )
  412. {
  413. gGL.color4fv((map_frustum_color()).mV);
  415. gGL.begin( LLRender::TRIANGLES  );
  416. gGL.vertex2f( ctr_x, ctr_y );
  417. gGL.vertex2f( ctr_x - half_width_pixels, ctr_y + far_clip_pixels );
  418. gGL.vertex2f( ctr_x + half_width_pixels, ctr_y + far_clip_pixels );
  419. gGL.end();
  420. }
  421. else
  422. {
  423. gGL.color4fv((map_frustum_rotating_color()).mV);
  425. // If we don't rotate the map, we have to rotate the frustum.
  426. gGL.pushMatrix();
  427. gGL.translatef( ctr_x, ctr_y, 0 );
  428. glRotatef( atan2( LLViewerCamera::getInstance()->getAtAxis().mV[VX], LLViewerCamera::getInstance()->getAtAxis().mV[VY] ) * RAD_TO_DEG, 0.f, 0.f, -1.f);
  429. gGL.begin( LLRender::TRIANGLES  );
  430. gGL.vertex2f( 0, 0 );
  431. gGL.vertex2f( -half_width_pixels, far_clip_pixels );
  432. gGL.vertex2f(  half_width_pixels, far_clip_pixels );
  433. gGL.end();
  434. gGL.popMatrix();
  435. }
  436. }
  438. LLUICtrl::draw();
  439. }
  441. void LLNetMap::reshape(S32 width, S32 height, BOOL called_from_parent)
  442. {
  443. LLUICtrl::reshape(width, height, called_from_parent);
  444. createObjectImage();
  445. }
  447. LLVector3 LLNetMap::globalPosToView( const LLVector3d& global_pos )
  448. {
  449. LLVector3d relative_pos_global = global_pos - gAgent.getCameraPositionGlobal();
  450. LLVector3 pos_local;
  451. pos_local.setVec(relative_pos_global);  // convert to floats from doubles
  453. pos_local.mV[VX] *= mPixelsPerMeter;
  454. pos_local.mV[VY] *= mPixelsPerMeter;
  455. // leave Z component in meters
  457. static LLUICachedControl<bool> rotate_map("MiniMapRotate", true);
  458. if( rotate_map )
  459. {
  460. F32 radians = atan2( LLViewerCamera::getInstance()->getAtAxis().mV[VX], LLViewerCamera::getInstance()->getAtAxis().mV[VY] );
  461. LLQuaternion rot(radians, LLVector3(0.f, 0.f, 1.f));
  462. pos_local.rotVec( rot );
  463. }
  465. pos_local.mV[VX] += getRect().getWidth() / 2 + mCurPanX;
  466. pos_local.mV[VY] += getRect().getHeight() / 2 + mCurPanY;
  468. return pos_local;
  469. }
  471. void LLNetMap::drawTracking(const LLVector3d& pos_global, const LLColor4& color, 
  472. BOOL draw_arrow )
  473. {
  474. LLVector3 pos_local = globalPosToView( pos_global );
  475. if( (pos_local.mV[VX] < 0) ||
  476. (pos_local.mV[VY] < 0) ||
  477. (pos_local.mV[VX] >= getRect().getWidth()) ||
  478. (pos_local.mV[VY] >= getRect().getHeight()) )
  479. {
  480. if (draw_arrow)
  481. {
  482. S32 x = llround( pos_local.mV[VX] );
  483. S32 y = llround( pos_local.mV[VY] );
  484. LLWorldMapView::drawTrackingCircle( getRect(), x, y, color, 1, 10 );
  485. LLWorldMapView::drawTrackingArrow( getRect(), x, y, color );
  486. }
  487. }
  488. else
  489. {
  490. LLWorldMapView::drawTrackingDot(pos_local.mV[VX], 
  491. pos_local.mV[VY], 
  492. color,
  493. pos_local.mV[VZ]);
  494. }
  495. }
  497. LLVector3d LLNetMap::viewPosToGlobal( S32 x, S32 y )
  498. {
  499. x -= llround(getRect().getWidth() / 2 + mCurPanX);
  500. y -= llround(getRect().getHeight() / 2 + mCurPanY);
  502. LLVector3 pos_local( (F32)x, (F32)y, 0 );
  504. F32 radians = - atan2( LLViewerCamera::getInstance()->getAtAxis().mV[VX], LLViewerCamera::getInstance()->getAtAxis().mV[VY] );
  506. static LLUICachedControl<bool> rotate_map("MiniMapRotate", true);
  507. if( rotate_map )
  508. {
  509. LLQuaternion rot(radians, LLVector3(0.f, 0.f, 1.f));
  510. pos_local.rotVec( rot );
  511. }
  513. pos_local *= ( LLWorld::getInstance()->getRegionWidthInMeters() / mScale );
  515. LLVector3d pos_global;
  516. pos_global.setVec( pos_local );
  517. pos_global += gAgent.getCameraPositionGlobal();
  519. return pos_global;
  520. }
  522. BOOL LLNetMap::handleScrollWheel(S32 x, S32 y, S32 clicks)
  523. {
  524. // note that clicks are reversed from what you'd think: i.e. > 0  means zoom out, < 0 means zoom in
  525. F32 scale = mScale;
  526.         
  527. scale *= pow(MAP_SCALE_ZOOM_FACTOR, -clicks);
  528. setScale(llclamp(scale, MAP_SCALE_MIN, MAP_SCALE_MAX));
  530. return TRUE;
  531. }
  533. BOOL LLNetMap::handleToolTip( S32 x, S32 y, MASK mask )
  534. {
  535. if (gDisconnected)
  536. {
  537. return FALSE;
  538. }
  540. // mToolTipMsg = "[AGENT][REGION](Double-click to open Map)"
  542. LLStringUtil::format_map_t args;
  543. std::string fullname;
  544. if(mClosestAgentToCursor.notNull() && gCacheName->getFullName(mClosestAgentToCursor, fullname))
  545. {
  546. args["[AGENT]"] = fullname + "n";
  547. }
  548. else
  549. {
  550. args["[AGENT]"] = "";
  551. }
  553. LLViewerRegion* region = LLWorld::getInstance()->getRegionFromPosGlobal( viewPosToGlobal( x, y ) );
  554. if( region )
  555. {
  556. args["[REGION]"] = region->getName() + "n";
  557. }
  558. else
  559. {
  560. args["[REGION]"] = "";
  561. }
  563. std::string msg = mToolTipMsg;
  564. LLStringUtil::format(msg, args);
  566. LLRect sticky_rect;
  567. // set sticky_rect
  568. if (region)
  569. {
  570. S32 SLOP = 4;
  571. localPointToScreen( 
  572. x - SLOP, y - SLOP, 
  573. &(sticky_rect.mLeft), &(sticky_rect.mBottom) );
  574. sticky_rect.mRight = sticky_rect.mLeft + 2 * SLOP;
  575. sticky_rect.mTop = sticky_rect.mBottom + 2 * SLOP;
  576. }
  578. LLToolTipMgr::instance().show(LLToolTip::Params()
  579. .message(msg)
  580. .sticky_rect(sticky_rect));
  582. return TRUE;
  583. }
  586. void LLNetMap::renderScaledPointGlobal( const LLVector3d& pos, const LLColor4U &color, F32 radius_meters )
  587. {
  588. LLVector3 local_pos;
  589. local_pos.setVec( pos - mObjectImageCenterGlobal );
  591. S32 diameter_pixels = llround(2 * radius_meters * mObjectMapTPM);
  592. renderPoint( local_pos, color, diameter_pixels );
  593. }
  596. void LLNetMap::renderPoint(const LLVector3 &pos_local, const LLColor4U &color, 
  597.    S32 diameter, S32 relative_height)
  598. {
  599. if (diameter <= 0)
  600. {
  601. return;
  602. }
  604. const S32 image_width = (S32)mObjectImagep->getWidth();
  605. const S32 image_height = (S32)mObjectImagep->getHeight();
  607. S32 x_offset = llround(pos_local.mV[VX] * mObjectMapTPM + image_width / 2);
  608. S32 y_offset = llround(pos_local.mV[VY] * mObjectMapTPM + image_height / 2);
  610. if ((x_offset < 0) || (x_offset >= image_width))
  611. {
  612. return;
  613. }
  614. if ((y_offset < 0) || (y_offset >= image_height))
  615. {
  616. return;
  617. }
  619. U8 *datap = mObjectRawImagep->getData();
  621. S32 neg_radius = diameter / 2;
  622. S32 pos_radius = diameter - neg_radius;
  623. S32 x, y;
  625. if (relative_height > 0)
  626. {
  627. // ...point above agent
  628. S32 px, py;
  630. // vertical line
  631. px = x_offset;
  632. for (y = -neg_radius; y < pos_radius; y++)
  633. {
  634. py = y_offset + y;
  635. if ((py < 0) || (py >= image_height))
  636. {
  637. continue;
  638. }
  639. S32 offset = px + py * image_width;
  640. ((U32*)datap)[offset] = color.mAll;
  641. }
  643. // top line
  644. py = y_offset + pos_radius - 1;
  645. for (x = -neg_radius; x < pos_radius; x++)
  646. {
  647. px = x_offset + x;
  648. if ((px < 0) || (px >= image_width))
  649. {
  650. continue;
  651. }
  652. S32 offset = px + py * image_width;
  653. ((U32*)datap)[offset] = color.mAll;
  654. }
  655. }
  656. else
  657. {
  658. // ...point level with agent
  659. for (x = -neg_radius; x < pos_radius; x++)
  660. {
  661. S32 p_x = x_offset + x;
  662. if ((p_x < 0) || (p_x >= image_width))
  663. {
  664. continue;
  665. }
  667. for (y = -neg_radius; y < pos_radius; y++)
  668. {
  669. S32 p_y = y_offset + y;
  670. if ((p_y < 0) || (p_y >= image_height))
  671. {
  672. continue;
  673. }
  674. S32 offset = p_x + p_y * image_width;
  675. ((U32*)datap)[offset] = color.mAll;
  676. }
  677. }
  678. }
  679. }
  681. void LLNetMap::createObjectImage()
  682. {
  683. // Find the size of the side of a square that surrounds the circle that surrounds getRect().
  684. // ... which is, the diagonal of the rect.
  685. F32 width = (F32)getRect().getWidth();
  686. F32 height = (F32)getRect().getHeight();
  687. S32 square_size = llround( sqrt(width*width + height*height) );
  689. // Find the least power of two >= the minimum size.
  690. const S32 MIN_SIZE = 64;
  691. const S32 MAX_SIZE = 256;
  692. S32 img_size = MIN_SIZE;
  693. while( (img_size*2 < square_size ) && (img_size < MAX_SIZE) )
  694. {
  695. img_size <<= 1;
  696. }
  698. if( mObjectImagep.isNull() ||
  699. (mObjectImagep->getWidth() != img_size) ||
  700. (mObjectImagep->getHeight() != img_size) )
  701. {
  702. mObjectRawImagep = new LLImageRaw(img_size, img_size, 4);
  703. U8* data = mObjectRawImagep->getData();
  704. memset( data, 0, img_size * img_size * 4 );
  705. mObjectImagep = LLViewerTextureManager::getLocalTexture( mObjectRawImagep.get(), FALSE);
  706. }
  707. setScale(mScale);
  708. mUpdateNow = TRUE;
  709. }