Merge branch 'master' into DRTVWR-570-maint-Q

# Conflicts:
# indra/newview/llnetmap.cpp
# indra/newview/llnetmap.h

1 files changed, 183 insertions, 94 deletions

diff --git a/indra/newview/llworldmapview.cpp b/indra/newview/llworldmapview.cpp
index 59ac4554d7..6e994b4e68 100644..100755
--- a/indra/newview/llworldmapview.cpp
+++ b/indra/newview/llworldmapview.cpp
@@ -58,9 +58,15 @@
 
 #include "llglheaders.h"
 
+// # Constants
+static const F32 MAP_DEFAULT_SCALE = 128.f;
+static const F32 MAP_ITERP_TIME_CONSTANT = 0.75f;
+static const F32 MAP_ZOOM_ACCELERATION_TIME = 0.3f;
+static const F32 MAP_ZOOM_MAX_INTERP = 0.5f;
+static const F32 MAP_SCALE_SNAP_THRESHOLD = 0.005f;
+
 // Basically a C++ implementation of the OCEAN_COLOR defined in mapstitcher.py 
 // Please ensure consistency between those 2 files (TODO: would be better to get that color from an asset source...)
-// # Constants
 // OCEAN_COLOR = "#1D475F"
 const F32 OCEAN_RED   = (F32)(0x1D)/255.f;
 const F32 OCEAN_GREEN = (F32)(0x47)/255.f;
@@ -92,14 +98,12 @@ LLUIImagePtr LLWorldMapView::sClassifiedsImage = NULL;
 LLUIImagePtr LLWorldMapView::sForSaleImage = NULL;
 LLUIImagePtr LLWorldMapView::sForSaleAdultImage = NULL;
 
-F32 LLWorldMapView::sPanX = 0.f;
-F32 LLWorldMapView::sPanY = 0.f;
-F32 LLWorldMapView::sTargetPanX = 0.f;
-F32 LLWorldMapView::sTargetPanY = 0.f;
 S32 LLWorldMapView::sTrackingArrowX = 0;
 S32 LLWorldMapView::sTrackingArrowY = 0;
 bool LLWorldMapView::sVisibleTilesLoaded = false;
-F32 LLWorldMapView::sMapScale = 128.f;
+F32 LLWorldMapView::sMapScaleSetting = MAP_DEFAULT_SCALE;
+LLVector2 LLWorldMapView::sZoomPivot = LLVector2(0.0f, 0.0f);
+LLFrameTimer LLWorldMapView::sZoomTimer = LLFrameTimer();
 
 std::map<std::string,std::string> LLWorldMapView::sStringsMap;
 
@@ -166,20 +170,27 @@ void LLWorldMapView::cleanupClass()
 	sForSaleAdultImage = NULL;
 }
 
-LLWorldMapView::LLWorldMapView()
-:	LLPanel(),
-	mBackgroundColor( LLColor4( OCEAN_RED, OCEAN_GREEN, OCEAN_BLUE, 1.f ) ),
-	mItemPicked(FALSE),
-	mPanning( FALSE ),
-	mMouseDownPanX( 0 ),
-	mMouseDownPanY( 0 ),
-	mMouseDownX( 0 ),
-	mMouseDownY( 0 ),
-	mSelectIDStart(0)
+LLWorldMapView::LLWorldMapView() :
+    LLPanel(),
+    mBackgroundColor(LLColor4(OCEAN_RED, OCEAN_GREEN, OCEAN_BLUE, 1.f)),
+    mItemPicked(FALSE),
+    mPanX(0.f),
+    mPanY(0.f),
+    mTargetPanX(0.f),
+    mTargetPanY(0.f),
+    mPanning(FALSE),
+    mMouseDownPanX(0),
+    mMouseDownPanY(0),
+    mMouseDownX(0),
+    mMouseDownY(0),
+    mSelectIDStart(0),
+    mMapScale(0.f),
+    mTargetMapScale(0.f),
+    mMapIterpTime(MAP_ITERP_TIME_CONSTANT)
 {
-	//LL_INFOS("WorldMap") << "Creating the Map -> LLWorldMapView::LLWorldMapView()" << LL_ENDL;
+    // LL_INFOS("WorldMap") << "Creating the Map -> LLWorldMapView::LLWorldMapView()" << LL_ENDL;
 
-	clearLastClick();
+    clearLastClick();
 }
 
 BOOL LLWorldMapView::postBuild()
@@ -210,6 +221,9 @@ BOOL LLWorldMapView::postBuild()
 	mTextBoxNorthEast ->reshapeToFitText();
 	mTextBoxSouthWest->reshapeToFitText();
 	mTextBoxNorthWest ->reshapeToFitText();
+    
+    sZoomTimer.stop();
+    setScale(sMapScaleSetting, true);
 
 	return true;
 }
@@ -227,59 +241,111 @@ void LLWorldMapView::cleanupTextures()
 {
 }
 
+void LLWorldMapView::zoom(F32 zoom)
+{
+    mTargetMapScale = scaleFromZoom(zoom);
+    if (!sZoomTimer.getStarted() && mMapScale != mTargetMapScale)
+    {
+        sZoomPivot = LLVector2(0, 0);
+        sZoomTimer.start();
+    }
+}
 
-// static
-void LLWorldMapView::setScale( F32 scale )
+void LLWorldMapView::zoomWithPivot(F32 zoom, S32 x, S32 y)
 {
-	if (scale != sMapScale)
-	{
-		F32 old_scale = sMapScale;
+    mTargetMapScale = scaleFromZoom(zoom);
+    sZoomPivot      = LLVector2(x, y);
+    if (!sZoomTimer.getStarted() && mMapScale != mTargetMapScale)
+    {
+        sZoomTimer.start();
+    }
+}
 
-		sMapScale = scale;
-		if (sMapScale <= 0.f)
-		{
-			sMapScale = 0.1f;
-		}
+F32 LLWorldMapView::getZoom() { return LLWorldMapView::zoomFromScale(mMapScale); }
 
-		F32 ratio = (scale / old_scale);
-		sPanX *= ratio;
-		sPanY *= ratio;
-		sTargetPanX = sPanX;
-		sTargetPanY = sPanY;
-		sVisibleTilesLoaded = false;
-	}
-}
+F32 LLWorldMapView::getScale() { return mMapScale; }
 
+// static
+void LLWorldMapView::setScaleSetting(F32 scaleSetting) { sMapScaleSetting = scaleSetting; }
+
+// static
+F32 LLWorldMapView::getScaleSetting() { return sMapScaleSetting; }
+
+void LLWorldMapView::setScale(F32 scale, bool snap)
+{
+    if (scale != mMapScale)
+    {
+        F32 old_scale = mMapScale;
+
+        mMapScale = scale;
+        // Set the scale used when saving the setting
+        sMapScaleSetting = scale;
+        if (mMapScale <= 0.f)
+        {
+            mMapScale = 0.1f;
+        }
+        mMapIterpTime = MAP_ITERP_TIME_CONSTANT;
+        F32 ratio = (scale / old_scale);
+        mPanX *= ratio;
+        mPanY *= ratio;
+        mTargetPanX         = mPanX;
+        mTargetPanY         = mPanY;
+        sVisibleTilesLoaded = false;
+
+        // If we are zooming relative to somewhere else rather than the center of the map, compensate for the difference in panning here
+        if (!sZoomPivot.isExactlyZero())
+        {
+            LLVector2 relative_pivot;
+            relative_pivot.mV[VX]     = sZoomPivot.mV[VX] - (getRect().getWidth() / 2.0);
+            relative_pivot.mV[VY]     = sZoomPivot.mV[VY] - (getRect().getHeight() / 2.0);
+            LLVector2 zoom_pan_offset = relative_pivot - (relative_pivot * scale / old_scale);
+            mPanX += zoom_pan_offset.mV[VX];
+            mPanY += zoom_pan_offset.mV[VY];
+            mTargetPanX += zoom_pan_offset.mV[VX];
+            mTargetPanY += zoom_pan_offset.mV[VY];
+        }
+    }
+
+    if (snap)
+    {
+        mTargetMapScale = scale;
+    }
+}
 
 // static
-void LLWorldMapView::translatePan( S32 delta_x, S32 delta_y )
+void LLWorldMapView::translatePan(S32 delta_x, S32 delta_y)
 {
-	sPanX += delta_x;
-	sPanY += delta_y;
-	sTargetPanX = sPanX;
-	sTargetPanY = sPanY;
-	sVisibleTilesLoaded = false;
+    mPanX += delta_x;
+    mPanY += delta_y;
+    mTargetPanX         = mPanX;
+    mTargetPanY         = mPanY;
+    sVisibleTilesLoaded = false;
 }
 
 
 // static
-void LLWorldMapView::setPan( S32 x, S32 y, BOOL snap )
+void LLWorldMapView::setPan(S32 x, S32 y, BOOL snap)
 {
-	sTargetPanX = (F32)x;
-	sTargetPanY = (F32)y;
-	if (snap)
-	{
-		sPanX = sTargetPanX;
-		sPanY = sTargetPanY;
-	}
-	sVisibleTilesLoaded = false;
+    mMapIterpTime = MAP_ITERP_TIME_CONSTANT;
+    mTargetPanX = (F32) x;
+    mTargetPanY = (F32) y;
+    if (snap)
+    {
+        mPanX = mTargetPanX;
+        mPanY = mTargetPanY;
+    }
+    sVisibleTilesLoaded = false;
 }
 
-bool LLWorldMapView::showRegionInfo()
+// static
+void LLWorldMapView::setPanWithInterpTime(S32 x, S32 y, BOOL snap, F32 interp_time)
 {
-	return (LLWorldMipmap::scaleToLevel(sMapScale) <= DRAW_SIMINFO_THRESHOLD ? true : false);
+    setPan(x, y, snap);
+    mMapIterpTime = interp_time;
 }
 
+bool LLWorldMapView::showRegionInfo() { return (LLWorldMipmap::scaleToLevel(mMapScale) <= DRAW_SIMINFO_THRESHOLD ? true : false); }
+
 ///////////////////////////////////////////////////////////////////////////////////
 // HELPERS
 
@@ -300,9 +366,28 @@ void LLWorldMapView::draw()
 
 	mVisibleRegions.clear();
 
-	// animate pan if necessary
-	sPanX = lerp(sPanX, sTargetPanX, LLSmoothInterpolation::getInterpolant(0.1f));
-	sPanY = lerp(sPanY, sTargetPanY, LLSmoothInterpolation::getInterpolant(0.1f));
+    // animate pan if necessary
+    mPanX = lerp(mPanX, mTargetPanX, LLSmoothInterpolation::getInterpolant(mMapIterpTime));
+    mPanY = lerp(mPanY, mTargetPanY, LLSmoothInterpolation::getInterpolant(mMapIterpTime));
+    
+    //RN: snaps to zoom value because interpolation caused jitter in the text rendering
+    if (!sZoomTimer.getStarted() && mMapScale != mTargetMapScale)
+    {
+        sZoomTimer.start();
+    }
+    bool snap_scale = false;
+    F32 interp = llmin(MAP_ZOOM_MAX_INTERP, sZoomTimer.getElapsedTimeF32() / MAP_ZOOM_ACCELERATION_TIME);
+    F32 current_zoom_val = zoomFromScale(mMapScale);
+    F32 target_zoom_val = zoomFromScale(mTargetMapScale);
+    F32 new_zoom_val = lerp(current_zoom_val, target_zoom_val, interp);
+    if (abs(new_zoom_val - current_zoom_val) < MAP_SCALE_SNAP_THRESHOLD)
+    {
+        sZoomTimer.stop();
+        snap_scale = true;
+        new_zoom_val = target_zoom_val;
+    }
+    F32 map_scale = scaleFromZoom(new_zoom_val);
+    setScale(map_scale, snap_scale);
 
 	const S32 width = getRect().getWidth();
 	const S32 height = getRect().getHeight();
@@ -310,7 +395,7 @@ void LLWorldMapView::draw()
 	const F32 half_height = F32(height) / 2.0f;
 	LLVector3d camera_global = gAgentCamera.getCameraPositionGlobal();
 
-	S32 level = LLWorldMipmap::scaleToLevel(sMapScale);
+	S32 level = LLWorldMipmap::scaleToLevel(mMapScale);
 
 	LLLocalClipRect clip(getLocalRect());
 	{
@@ -347,15 +432,15 @@ void LLWorldMapView::draw()
 
 		// Find x and y position relative to camera's center.
 		LLVector3d rel_region_pos = origin_global - camera_global;
-		F32 relative_x = (rel_region_pos.mdV[0] / REGION_WIDTH_METERS) * sMapScale;
-		F32 relative_y = (rel_region_pos.mdV[1] / REGION_WIDTH_METERS) * sMapScale;
+		F32 relative_x = (rel_region_pos.mdV[0] / REGION_WIDTH_METERS) * mMapScale;
+		F32 relative_y = (rel_region_pos.mdV[1] / REGION_WIDTH_METERS) * mMapScale;
 
 		// Coordinates of the sim in pixels in the UI panel
 		// When the view isn't panned, 0,0 = center of rectangle
-		F32 bottom =    sPanY + half_height + relative_y;
-		F32 left =      sPanX + half_width + relative_x;
-		F32 top =       bottom + sMapScale ;
-		F32 right =     left + sMapScale ;
+		F32 bottom =    mPanY + half_height + relative_y;
+		F32 left =      mPanX + half_width + relative_x;
+		F32 top =       bottom + mMapScale ;
+		F32 right =     left + mMapScale ;
 
 		// Discard if region is outside the screen rectangle (not visible on screen)
 		if ((top < 0.f)   || (bottom > height) ||
@@ -416,7 +501,7 @@ void LLWorldMapView::draw()
 			if (overlayimage)
 			{
 				// Inform the fetch mechanism of the size we need
-				S32 draw_size = ll_round(sMapScale);
+				S32 draw_size = ll_round(mMapScale);
 				overlayimage->setKnownDrawSize(ll_round(draw_size * LLUI::getScaleFactor().mV[VX]), ll_round(draw_size * LLUI::getScaleFactor().mV[VY]));
 				// Draw something whenever we have enough info
 				if (overlayimage->hasGLTexture())
@@ -444,7 +529,7 @@ void LLWorldMapView::draw()
 		}
 
 		// Draw the region name in the lower left corner
-		if (sMapScale >= DRAW_TEXT_THRESHOLD)
+		if (mMapScale >= DRAW_TEXT_THRESHOLD)
 		{
 			LLFontGL* font = LLFontGL::getFont(LLFontDescriptor("SansSerif", "Small", LLFontGL::BOLD));
 			std::string mesg;
@@ -464,7 +549,7 @@ void LLWorldMapView::draw()
 					LLColor4::white,
 					LLFontGL::LEFT, LLFontGL::BASELINE, LLFontGL::NORMAL, LLFontGL::DROP_SHADOW,
 					S32_MAX, //max_chars
-					sMapScale, //max_pixels
+					mMapScale, //max_pixels
 					NULL,
 					TRUE); //use ellipses
 			}
@@ -591,7 +676,7 @@ void LLWorldMapView::setVisible(BOOL visible)
 void LLWorldMapView::drawMipmap(S32 width, S32 height)
 {
 	// Compute the level of the mipmap to use for the current scale level
-	S32 level = LLWorldMipmap::scaleToLevel(sMapScale);
+	S32 level = LLWorldMipmap::scaleToLevel(mMapScale);
 	// Set the tile boost level so that unused tiles get to 0
 	LLWorldMap::getInstance()->equalizeBoostLevels();
 
@@ -874,7 +959,7 @@ void LLWorldMapView::drawAgents()
 void LLWorldMapView::drawFrustum()
 {
 	// Draw frustum
-	F32 meters_to_pixels = sMapScale/ REGION_WIDTH_METERS;
+	F32 meters_to_pixels = mMapScale/ REGION_WIDTH_METERS;
 
 	F32 horiz_fov = LLViewerCamera::getInstance()->getView() * LLViewerCamera::getInstance()->getAspect();
 	F32 far_clip_meters = LLViewerCamera::getInstance()->getFar();
@@ -884,8 +969,8 @@ void LLWorldMapView::drawFrustum()
 	F32 half_width_pixels = half_width_meters * meters_to_pixels;
 	
 	// Compute the frustum coordinates. Take the UI scale into account.
-    F32 ctr_x = ((getLocalRect().getWidth() * 0.5f + sPanX)  * LLUI::getScaleFactor().mV[VX]);
-    F32 ctr_y = ((getLocalRect().getHeight() * 0.5f + sPanY) * LLUI::getScaleFactor().mV[VY]);
+    F32 ctr_x = ((getLocalRect().getWidth() * 0.5f + mPanX)  * LLUI::getScaleFactor().mV[VX]);
+    F32 ctr_y = ((getLocalRect().getHeight() * 0.5f + mPanY) * LLUI::getScaleFactor().mV[VY]);
 
 	gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
 
@@ -942,13 +1027,13 @@ LLVector3 LLWorldMapView::globalPosToView( const LLVector3d& global_pos )
 	LLVector3 pos_local;
 	pos_local.setVec(relative_pos_global);  // convert to floats from doubles
 
-	pos_local.mV[VX] *= sMapScale / REGION_WIDTH_METERS;
-	pos_local.mV[VY] *= sMapScale / REGION_WIDTH_METERS;
+	pos_local.mV[VX] *= mMapScale / REGION_WIDTH_METERS;
+	pos_local.mV[VY] *= mMapScale / REGION_WIDTH_METERS;
 	// leave Z component in meters
 
 
-	pos_local.mV[VX] += getRect().getWidth() / 2 + sPanX;
-	pos_local.mV[VY] += getRect().getHeight() / 2 + sPanY;
+	pos_local.mV[VX] += getRect().getWidth() / 2 + mPanX;
+	pos_local.mV[VY] += getRect().getHeight() / 2 + mPanY;
 
 	return pos_local;
 }
@@ -1019,12 +1104,12 @@ void LLWorldMapView::drawTracking(const LLVector3d& pos_global, const LLColor4&
 // If you change this, then you need to change LLTracker::getTrackedPositionGlobal() as well
 LLVector3d LLWorldMapView::viewPosToGlobal( S32 x, S32 y )
 {
-	x -= llfloor((getRect().getWidth() / 2 + sPanX));
-	y -= llfloor((getRect().getHeight() / 2 + sPanY));
+	x -= llfloor((getRect().getWidth() / 2 + mPanX));
+	y -= llfloor((getRect().getHeight() / 2 + mPanY));
 
 	LLVector3 pos_local( (F32)x, (F32)y, 0.f );
 
-	pos_local *= ( REGION_WIDTH_METERS / sMapScale );
+	pos_local *= ( REGION_WIDTH_METERS / mMapScale );
 	
 	LLVector3d pos_global;
 	pos_global.setVec( pos_local );
@@ -1481,7 +1566,7 @@ void LLWorldMapView::handleClick(S32 x, S32 y, MASK mask,
 
 	LLWorldMap::getInstance()->cancelTracking();
 
-	S32 level = LLWorldMipmap::scaleToLevel(sMapScale);
+	S32 level = LLWorldMipmap::scaleToLevel(mMapScale);
 	// If the zoom level is not too far out already, test hits
 	if (level <= DRAW_SIMINFO_THRESHOLD)
 	{
@@ -1598,8 +1683,8 @@ BOOL LLWorldMapView::handleMouseDown( S32 x, S32 y, MASK mask )
 {
 	gFocusMgr.setMouseCapture( this );
 
-	mMouseDownPanX = ll_round(sPanX);
-	mMouseDownPanY = ll_round(sPanY);
+	mMouseDownPanX = ll_round(mPanX);
+	mMouseDownPanY = ll_round(mPanY);
 	mMouseDownX = x;
 	mMouseDownY = y;
 	sHandledLastClick = TRUE;
@@ -1614,8 +1699,8 @@ BOOL LLWorldMapView::handleMouseUp( S32 x, S32 y, MASK mask )
 		{
 			// restore mouse cursor
 			S32 local_x, local_y;
-			local_x = mMouseDownX + llfloor(sPanX - mMouseDownPanX);
-			local_y = mMouseDownY + llfloor(sPanY - mMouseDownPanY);
+			local_x = mMouseDownX + llfloor(mPanX - mMouseDownPanX);
+			local_y = mMouseDownY + llfloor(mPanY - mMouseDownPanY);
 			LLRect clip_rect = getRect();
 			clip_rect.stretch(-8);
 			clip_rect.clipPointToRect(mMouseDownX, mMouseDownY, local_x, local_y);
@@ -1643,7 +1728,7 @@ BOOL LLWorldMapView::handleMouseUp( S32 x, S32 y, MASK mask )
 
 void LLWorldMapView::updateVisibleBlocks()
 {
-	if (LLWorldMipmap::scaleToLevel(sMapScale) > DRAW_SIMINFO_THRESHOLD)
+	if (LLWorldMipmap::scaleToLevel(mMapScale) > DRAW_SIMINFO_THRESHOLD)
 	{
 		// If we're zoomed out too much, we just don't load all those sim info: too much!
 		return;
@@ -1659,16 +1744,16 @@ void LLWorldMapView::updateVisibleBlocks()
 	const F32 half_height = F32(height) / 2.0f;
 
 	// Compute center into sim grid coordinates
-	S32 world_center_x = S32((-sPanX / sMapScale) + (camera_global.mdV[0] / REGION_WIDTH_METERS));
-	S32 world_center_y = S32((-sPanY / sMapScale) + (camera_global.mdV[1] / REGION_WIDTH_METERS));
+	S32 world_center_x = S32((-mPanX / mMapScale) + (camera_global.mdV[0] / REGION_WIDTH_METERS));
+	S32 world_center_y = S32((-mPanY / mMapScale) + (camera_global.mdV[1] / REGION_WIDTH_METERS));
 
 	// Compute the boundaries into sim grid coordinates
-	S32 world_left   = world_center_x - S32(half_width  / sMapScale) - 1;
-	S32 world_right  = world_center_x + S32(half_width  / sMapScale) + 1;
-	S32 world_bottom = world_center_y - S32(half_height / sMapScale) - 1;
-	S32 world_top    = world_center_y + S32(half_height / sMapScale) + 1;
+	S32 world_left   = world_center_x - S32(half_width  / mMapScale) - 1;
+	S32 world_right  = world_center_x + S32(half_width  / mMapScale) + 1;
+	S32 world_bottom = world_center_y - S32(half_height / mMapScale) - 1;
+	S32 world_top    = world_center_y + S32(half_height / mMapScale) + 1;
 
-	//LL_INFOS("WorldMap") << "LLWorldMapView::updateVisibleBlocks() : sMapScale = " << sMapScale << ", left = " << world_left << ", right = " << world_right << ", bottom  = " << world_bottom << ", top = " << world_top << LL_ENDL;
+	//LL_INFOS("WorldMap") << "LLWorldMapView::updateVisibleBlocks() : mMapScale = " << mMapScale << ", left = " << world_left << ", right = " << world_right << ", bottom  = " << world_bottom << ", top = " << world_top << LL_ENDL;
 	LLWorldMap::getInstance()->updateRegions(world_left, world_bottom, world_right, world_top);
 }
 
@@ -1689,10 +1774,10 @@ BOOL LLWorldMapView::handleHover( S32 x, S32 y, MASK mask )
 			F32 delta_y = (F32)(gViewerWindow->getCurrentMouseDY());
 
 			// Set pan to value at start of drag + offset
-			sPanX += delta_x;
-			sPanY += delta_y;
-			sTargetPanX = sPanX;
-			sTargetPanY = sPanY;
+			mPanX += delta_x;
+			mPanY += delta_y;
+			mTargetPanX = mPanX;
+			mTargetPanY = mPanY;
 
 			gViewerWindow->moveCursorToCenter();
 		}
@@ -1789,4 +1874,8 @@ BOOL LLWorldMapView::handleDoubleClick( S32 x, S32 y, MASK mask )
 	return FALSE;
 }
 
+// static
+F32 LLWorldMapView::scaleFromZoom(F32 zoom) { return exp2(zoom) * 256.0f; }
 
+// static
+F32 LLWorldMapView::zoomFromScale(F32 scale) { return log2(scale / 256.f); }