llworldmapview.cpp

Go to the documentation of this file.

#include "llviewerprecompiledheaders.h"

#include "llworldmapview.h"

#include "indra_constants.h"
#include "llui.h"
#include "llmath.h"             // clampf()
#include "llregionhandle.h"
#include "lleventflags.h"
#include "llglimmediate.h"

#include "llagent.h"
#include "llcallingcard.h"
#include "llcolorscheme.h"
#include "llviewercontrol.h"
#include "llcylinder.h"
#include "llfloaterdirectory.h"
#include "llfloatermap.h"
#include "llfloaterworldmap.h"
#include "llfocusmgr.h"
#include "lltextbox.h"
#include "lltextureview.h"
#include "lltracker.h"
#include "llviewercamera.h"
#include "llviewerimage.h"
#include "llviewerimagelist.h"
#include "llviewermenu.h"
#include "llviewerparceloverlay.h"
#include "llviewerregion.h"
#include "llviewerwindow.h"
#include "llworldmap.h"
#include "llappviewer.h"                                // Only for constants!

#include "llglheaders.h"

const F32 GODLY_TELEPORT_HEIGHT = 200.f;
const S32 SCROLL_HINT_WIDTH = 65;
const F32 BIG_DOT_RADIUS = 5.f;
BOOL LLWorldMapView::sHandledLastClick = FALSE;

LLUIImagePtr LLWorldMapView::sAvatarYouSmallImage = NULL;
LLUIImagePtr LLWorldMapView::sAvatarSmallImage = NULL;
LLUIImagePtr LLWorldMapView::sAvatarLargeImage = NULL;
LLUIImagePtr LLWorldMapView::sAvatarAboveImage = NULL;
LLUIImagePtr LLWorldMapView::sAvatarBelowImage = NULL;

LLUIImagePtr LLWorldMapView::sTelehubImage = NULL;
LLUIImagePtr LLWorldMapView::sInfohubImage = NULL;
LLUIImagePtr LLWorldMapView::sHomeImage = NULL;
LLUIImagePtr LLWorldMapView::sEventImage = NULL;
LLUIImagePtr LLWorldMapView::sEventMatureImage = NULL;

LLUIImagePtr LLWorldMapView::sTrackCircleImage = NULL;
LLUIImagePtr LLWorldMapView::sTrackArrowImage = NULL;

LLUIImagePtr LLWorldMapView::sClassifiedsImage = NULL;
LLUIImagePtr LLWorldMapView::sForSaleImage = NULL;

F32 LLWorldMapView::sThresholdA = 48.f;
F32 LLWorldMapView::sThresholdB = 96.f;
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;
F32 LLWorldMapView::sPixelsPerMeter = 1.f;
F32 CONE_SIZE = 0.6f;


#define SIM_NULL_MAP_SCALE 1 // width in pixels, where we start drawing "null" sims
#define SIM_MAP_AGENT_SCALE 2 // width in pixels, where we start drawing agents
#define SIM_MAP_SCALE 1 // width in pixels, where we start drawing sim tiles

// Updates for agent locations.
#define AGENTS_UPDATE_TIME 60.0 // in seconds



void LLWorldMapView::initClass()
{
        sAvatarYouSmallImage =  LLUI::getUIImage("map_avatar_you_8.tga");
        sAvatarSmallImage =     LLUI::getUIImage("map_avatar_8.tga");
        sAvatarLargeImage =     LLUI::getUIImage("map_avatar_16.tga");
        sAvatarAboveImage =     LLUI::getUIImage("map_avatar_above_8.tga");
        sAvatarBelowImage =     LLUI::getUIImage("map_avatar_below_8.tga");

        sHomeImage =                    LLUI::getUIImage("map_home.tga");
        sTelehubImage =                 LLUI::getUIImage("map_telehub.tga");
        sInfohubImage =                 LLUI::getUIImage("map_infohub.tga");
        sEventImage =                   LLUI::getUIImage("map_event.tga");
        sEventMatureImage =             LLUI::getUIImage("map_event_mature.tga");

        sTrackCircleImage =             LLUI::getUIImage("map_track_16.tga");
        sTrackArrowImage =              LLUI::getUIImage("direction_arrow.tga");
        sClassifiedsImage =             LLUI::getUIImage("icon_top_pick.tga");
        sForSaleImage =                 LLUI::getUIImage("icon_for_sale.tga");
}

// static
void LLWorldMapView::cleanupClass()
{
        sAvatarYouSmallImage = NULL;
        sAvatarSmallImage = NULL;
        sAvatarLargeImage = NULL;
        sAvatarAboveImage = NULL;
        sAvatarBelowImage = NULL;

        sTelehubImage = NULL;
        sInfohubImage = NULL;
        sHomeImage = NULL;
        sEventImage = NULL;
        sEventMatureImage = NULL;

        sTrackCircleImage = NULL;
        sTrackArrowImage = NULL;
        sClassifiedsImage = NULL;
        sForSaleImage = NULL;
}

LLWorldMapView::LLWorldMapView(const std::string& name, const LLRect& rect )
:       LLPanel(name, rect, BORDER_NO), 
        mBackgroundColor( LLColor4( 4.f/255.f, 4.f/255.f, 75.f/255.f, 1.f ) ),
        mItemPicked(FALSE),
        mPanning( FALSE ),
        mMouseDownPanX( 0 ),
        mMouseDownPanY( 0 ),
        mMouseDownX( 0 ),
        mMouseDownY( 0 ),
        mSelectIDStart(0)
{
        sPixelsPerMeter = gMapScale / REGION_WIDTH_METERS;
        clearLastClick();

        const S32 DIR_WIDTH = 10;
        const S32 DIR_HEIGHT = 10;
        LLRect major_dir_rect(  0, DIR_HEIGHT, DIR_WIDTH, 0 );

        mTextBoxNorth = new LLTextBox( "N", major_dir_rect );
        addChild( mTextBoxNorth );

        LLColor4 minor_color( 1.f, 1.f, 1.f, .7f );
        
        mTextBoxEast =  new LLTextBox( "E", major_dir_rect );
        mTextBoxEast->setColor( minor_color );
        addChild( mTextBoxEast );
        
        major_dir_rect.mRight += 1 ;
        mTextBoxWest =  new LLTextBox( "W", major_dir_rect );
        mTextBoxWest->setColor( minor_color );
        addChild( mTextBoxWest );
        major_dir_rect.mRight -= 1 ;

        mTextBoxSouth = new LLTextBox( "S", major_dir_rect );
        mTextBoxSouth->setColor( minor_color );
        addChild( mTextBoxSouth );

        LLRect minor_dir_rect(  0, DIR_HEIGHT, DIR_WIDTH * 2, 0 );

        mTextBoxSouthEast =     new LLTextBox( "SE", minor_dir_rect );
        mTextBoxSouthEast->setColor( minor_color );
        addChild( mTextBoxSouthEast );
        
        mTextBoxNorthEast = new LLTextBox( "NE", minor_dir_rect );
        mTextBoxNorthEast->setColor( minor_color );
        addChild( mTextBoxNorthEast );
        
        mTextBoxSouthWest =     new LLTextBox( "SW", minor_dir_rect );
        mTextBoxSouthWest->setColor( minor_color );
        addChild( mTextBoxSouthWest );

        mTextBoxNorthWest = new LLTextBox( "NW", minor_dir_rect );
        mTextBoxNorthWest->setColor( minor_color );
        addChild( mTextBoxNorthWest );
}


LLWorldMapView::~LLWorldMapView()
{
        cleanupTextures();
}


// static
void LLWorldMapView::cleanupTextures()
{
}


// static
void LLWorldMapView::setScale( F32 scale )
{
        if (scale != gMapScale)
        {
                F32 old_scale = gMapScale;

                gMapScale = scale;
                if (gMapScale == 0.f)
                {
                        gMapScale = 0.1f;
                }

                F32 ratio = (scale / old_scale);
                sPanX *= ratio;
                sPanY *= ratio;
                sTargetPanX = sPanX;
                sTargetPanY = sPanY;

                sPixelsPerMeter = gMapScale / REGION_WIDTH_METERS;
        }
}


// static
void LLWorldMapView::translatePan( S32 delta_x, S32 delta_y )
{
        sPanX += delta_x;
        sPanY += delta_y;
        sTargetPanX = sPanX;
        sTargetPanY = sPanY;
}


// static
void LLWorldMapView::setPan( S32 x, S32 y, BOOL snap )
{
        sTargetPanX = (F32)x;
        sTargetPanY = (F32)y;
        if (snap)
        {
                sPanX = sTargetPanX;
                sPanY = sTargetPanY;
        }
}


// HELPERS

BOOL is_agent_in_region(LLViewerRegion* region, LLSimInfo* info)
{
        return ((region && info) && (info->mName == region->getName()));
}



void LLWorldMapView::draw()
{
        LLTextureView::clearDebugImages();

        F64 current_time = LLTimer::getElapsedSeconds();

        mVisibleRegions.clear();
        
        // animate pan if necessary
        sPanX = lerp(sPanX, sTargetPanX, LLCriticalDamp::getInterpolant(0.1f));
        sPanY = lerp(sPanY, sTargetPanY, LLCriticalDamp::getInterpolant(0.1f));

        const S32 width = getRect().getWidth();
        const S32 height = getRect().getHeight();
        const S32 half_width = width / 2;
        const S32 half_height = height / 2;
        LLVector3d camera_global = gAgent.getCameraPositionGlobal();

        LLLocalClipRect clip(getLocalRect());
        {
                LLGLSNoTexture no_texture;
        
                glMatrixMode(GL_MODELVIEW);

                // Clear the background alpha to 0
                gGL.flush();
                glColorMask(FALSE, FALSE, FALSE, TRUE);
                glAlphaFunc(GL_GEQUAL, 0.00f);
                gGL.blendFunc(GL_ONE, GL_ZERO);
                gGL.color4f(0.0f, 0.0f, 0.0f, 0.0f);
                gl_rect_2d(0, height, width, 0);
        }

        gGL.flush();
        glAlphaFunc(GL_GEQUAL, 0.01f);
        glColorMask(TRUE, TRUE, TRUE, TRUE);
        gGL.blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        F32 layer_alpha = 1.f;

        // Draw one image per layer
        for (U32 layer_idx=0; layer_idx<LLWorldMap::getInstance()->mMapLayers[LLWorldMap::getInstance()->mCurrentMap].size(); ++layer_idx)
        {
                if (!LLWorldMap::getInstance()->mMapLayers[LLWorldMap::getInstance()->mCurrentMap][layer_idx].LayerDefined)
                {
                        continue;
                }
                LLWorldMapLayer *layer = &LLWorldMap::getInstance()->mMapLayers[LLWorldMap::getInstance()->mCurrentMap][layer_idx];
                LLViewerImage *current_image = layer->LayerImage;
#if 1 || LL_RELEASE_FOR_DOWNLOAD
                if (current_image->isMissingAsset())
                {
                        continue; // better to draw nothing than the missing asset image
                }
#endif
                
                LLVector3d origin_global((F64)layer->LayerExtents.mLeft * REGION_WIDTH_METERS, (F64)layer->LayerExtents.mBottom * REGION_WIDTH_METERS, 0.f);

                // Find x and y position relative to camera's center.
                LLVector3d rel_region_pos = origin_global - camera_global;
                S32 relative_x = lltrunc((rel_region_pos.mdV[0] / REGION_WIDTH_METERS) * gMapScale);
                S32 relative_y = lltrunc((rel_region_pos.mdV[1] / REGION_WIDTH_METERS) * gMapScale);

                F32 pix_width = gMapScale*(layer->LayerExtents.getWidth() + 1);
                F32 pix_height = gMapScale*(layer->LayerExtents.getHeight() + 1);

                // 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 + pix_height;
                F32 right =             left + pix_width;
                F32 pixel_area = pix_width*pix_height;
                // discard layers that are outside the rectangle
                // and discard small layers
                if (top < 0.f ||
                        bottom > height ||
                        right < 0.f ||
                        left > width ||
                        (pixel_area < 4*4))
                {
                        current_image->setBoostLevel(0);
                        continue;
                }
                
                current_image->setBoostLevel(LLViewerImage::BOOST_MAP_LAYER);
                current_image->setKnownDrawSize(llround(pix_width * LLUI::sGLScaleFactor.mV[VX]), llround(pix_height * LLUI::sGLScaleFactor.mV[VY]));
                
                if (!current_image->getHasGLTexture())
                {
                        continue; // better to draw nothing than the default image
                }

//              LLTextureView::addDebugImage(current_image);
                
                // Draw using the texture.  If we don't clamp we get artifact at
                // the edge.
                LLViewerImage::bindTexture(current_image);

                // Draw map image into RGB
                //gGL.blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                gGL.flush();
                glColorMask(TRUE, TRUE, TRUE, FALSE);
                gGL.color4f(1.f, 1.f, 1.f, layer_alpha);

                gGL.begin(LLVertexBuffer::QUADS);
                        gGL.texCoord2f(0.0f, 1.0f);
                        gGL.vertex3f(left, top, -1.0f);
                        gGL.texCoord2f(0.0f, 0.0f);
                        gGL.vertex3f(left, bottom, -1.0f);
                        gGL.texCoord2f(1.0f, 0.0f);
                        gGL.vertex3f(right, bottom, -1.0f);
                        gGL.texCoord2f(1.0f, 1.0f);
                        gGL.vertex3f(right, top, -1.0f);
                gGL.end();

                // draw an alpha of 1 where the sims are visible
                gGL.flush();
                glColorMask(FALSE, FALSE, FALSE, TRUE);
                gGL.color4f(1.f, 1.f, 1.f, 1.f);

                gGL.begin(LLVertexBuffer::QUADS);
                        gGL.texCoord2f(0.0f, 1.0f);
                        gGL.vertex2f(left, top);
                        gGL.texCoord2f(0.0f, 0.0f);
                        gGL.vertex2f(left, bottom);
                        gGL.texCoord2f(1.0f, 0.0f);
                        gGL.vertex2f(right, bottom);
                        gGL.texCoord2f(1.0f, 1.0f);
                        gGL.vertex2f(right, top);
                gGL.end();
        }

        gGL.flush();
        glAlphaFunc(GL_GEQUAL, 0.01f);
        glColorMask(TRUE, TRUE, TRUE, TRUE);

#if 1
        F32 sim_alpha = 1.f;

        // Draw one image per region, centered on the camera position.
        for (LLWorldMap::sim_info_map_t::iterator it = LLWorldMap::getInstance()->mSimInfoMap.begin();
                 it != LLWorldMap::getInstance()->mSimInfoMap.end(); ++it)
        {
                U64 handle = (*it).first;
                LLSimInfo* info = (*it).second;

                if (info->mCurrentImage.isNull())
                {
                        info->mCurrentImage = gImageList.getImage(info->mMapImageID[LLWorldMap::getInstance()->mCurrentMap], MIPMAP_TRUE, FALSE);
                }
                if (info->mOverlayImage.isNull() && info->mMapImageID[2].notNull())
                {
                        info->mOverlayImage = gImageList.getImage(info->mMapImageID[2], MIPMAP_TRUE, FALSE);
                        info->mOverlayImage->bind(0);
                        info->mOverlayImage->setClamp(TRUE, TRUE);
                }
                
                LLViewerImage* simimage = info->mCurrentImage;
                LLViewerImage* overlayimage = info->mOverlayImage;

                if (gMapScale < SIM_MAP_SCALE)
                {
                        simimage->setBoostLevel(0);
                        if (overlayimage) overlayimage->setBoostLevel(0);
                        continue;
                }
                
                LLVector3d origin_global = from_region_handle(handle);
                LLVector3d camera_global = gAgent.getCameraPositionGlobal();

                // Find x and y position relative to camera's center.
                LLVector3d rel_region_pos = origin_global - camera_global;
                S32 relative_x = lltrunc((rel_region_pos.mdV[0] / REGION_WIDTH_METERS) * gMapScale);
                S32 relative_y = lltrunc((rel_region_pos.mdV[1] / REGION_WIDTH_METERS) * gMapScale);

                // 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 + gMapScale ;
                F32 right =             left + gMapScale ;

                // Switch to world map texture (if available for this region) if either:
                // 1. Tiles are zoomed out small enough, or
                // 2. Sim's texture has not been loaded yet
                F32 map_scale_cutoff = SIM_MAP_SCALE;
                if ((info->mRegionFlags & REGION_FLAGS_NULL_LAYER) > 0)
                {
                        map_scale_cutoff = SIM_NULL_MAP_SCALE;
                }

                info->mShowAgentLocations = (gMapScale >= SIM_MAP_AGENT_SCALE);

                bool sim_visible =
                        (gMapScale >= map_scale_cutoff) &&
                        (simimage->getHasGLTexture());

                if (sim_visible)
                {
                        // Fade in
                        if (info->mAlpha < 0.0f)
                                info->mAlpha = 1.f; // don't fade initially
                        else
                                info->mAlpha = lerp(info->mAlpha, 1.f, LLCriticalDamp::getInterpolant(0.15f));
                }
                else
                {
                        // Fade out
                        if (info->mAlpha < 0.0f)
                                info->mAlpha = 0.f; // don't fade initially
                        else
                                info->mAlpha = lerp(info->mAlpha, 0.f, LLCriticalDamp::getInterpolant(0.15f));
                }

                // discard regions that are outside the rectangle
                // and discard small regions
                if (top < 0.f ||
                        bottom > height ||
                        right < 0.f ||
                        left > width )
                {
                        simimage->setBoostLevel(0);
                        if (overlayimage) overlayimage->setBoostLevel(0);
                        continue;
                }

                mVisibleRegions.push_back(handle);
                // See if the agents need updating
                if (current_time - info->mAgentsUpdateTime > AGENTS_UPDATE_TIME)
                {
                        LLWorldMap::getInstance()->sendItemRequest(MAP_ITEM_AGENT_LOCATIONS, info->mHandle);
                        info->mAgentsUpdateTime = current_time;
                }
                
                // Bias the priority escalation for images nearer
                LLVector3d center_global = origin_global;
                center_global.mdV[VX] += 128.0;
                center_global.mdV[VY] += 128.0;

                S32 draw_size = llround(gMapScale);
                simimage->setBoostLevel(LLViewerImage::BOOST_MAP);
                simimage->setKnownDrawSize(llround(draw_size * LLUI::sGLScaleFactor.mV[VX]), llround(draw_size * LLUI::sGLScaleFactor.mV[VY]));

                if (overlayimage)
                {
                        overlayimage->setBoostLevel(LLViewerImage::BOOST_MAP);
                        overlayimage->setKnownDrawSize(llround(draw_size * LLUI::sGLScaleFactor.mV[VX]), llround(draw_size * LLUI::sGLScaleFactor.mV[VY]));
                }
                        
//              LLTextureView::addDebugImage(simimage);

                if (sim_visible && info->mAlpha > 0.001f)
                {
                        // Draw using the texture.  If we don't clamp we get artifact at
                        // the edge.
                        LLGLSUIDefault gls_ui;
                        LLViewerImage::bindTexture(simimage);

                        gGL.blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                        F32 alpha = sim_alpha * info->mAlpha;
                        gGL.color4f(1.f, 1.0f, 1.0f, alpha);

                        gGL.begin(LLVertexBuffer::QUADS);
                                gGL.texCoord2f(0.f, 1.f);
                                gGL.vertex3f(left, top, 0.f);
                                gGL.texCoord2f(0.f, 0.f);
                                gGL.vertex3f(left, bottom, 0.f);
                                gGL.texCoord2f(1.f, 0.f);
                                gGL.vertex3f(right, bottom, 0.f);
                                gGL.texCoord2f(1.f, 1.f);
                                gGL.vertex3f(right, top, 0.f);
                        gGL.end();

                        if (gSavedSettings.getBOOL("MapShowLandForSale") && overlayimage && overlayimage->getHasGLTexture())
                        {
                                LLViewerImage::bindTexture(overlayimage);
                                gGL.color4f(1.f, 1.f, 1.f, alpha);
                                gGL.begin(LLVertexBuffer::QUADS);
                                        gGL.texCoord2f(0.f, 1.f);
                                        gGL.vertex3f(left, top, -0.5f);
                                        gGL.texCoord2f(0.f, 0.f);
                                        gGL.vertex3f(left, bottom, -0.5f);
                                        gGL.texCoord2f(1.f, 0.f);
                                        gGL.vertex3f(right, bottom, -0.5f);
                                        gGL.texCoord2f(1.f, 1.f);
                                        gGL.vertex3f(right, top, -0.5f);
                                gGL.end();
                        }
                        
                        if ((info->mRegionFlags & REGION_FLAGS_NULL_LAYER) == 0)
                        {
                                // draw an alpha of 1 where the sims are visible (except NULL sims)
                                gGL.flush();
                                gGL.blendFunc(GL_ONE, GL_ZERO);
                                glColorMask(FALSE, FALSE, FALSE, TRUE);
                                gGL.color4f(1.f, 1.f, 1.f, 1.f);

                                LLGLSNoTexture gls_no_texture;
                                gGL.begin(LLVertexBuffer::QUADS);
                                        gGL.vertex2f(left, top);
                                        gGL.vertex2f(left, bottom);
                                        gGL.vertex2f(right, bottom);
                                        gGL.vertex2f(right, top);
                                gGL.end();

                                gGL.flush();
                                glColorMask(TRUE, TRUE, TRUE, TRUE);
                        }
                }

                if (info->mAccess == SIM_ACCESS_DOWN)
                {
                        // Draw a transparent red square over down sims
                        gGL.blendFunc(GL_DST_ALPHA, GL_SRC_ALPHA);
                        gGL.color4f(0.2f, 0.0f, 0.0f, 0.4f);

                        LLGLSNoTexture gls_no_texture;
                        gGL.begin(LLVertexBuffer::QUADS);
                                gGL.vertex2f(left, top);
                                gGL.vertex2f(left, bottom);
                                gGL.vertex2f(right, bottom);
                                gGL.vertex2f(right, top);
                        gGL.end();
                }

                // If this is mature, and you are not, draw a line across it
                if (info->mAccess != SIM_ACCESS_DOWN
                        && info->mAccess > SIM_ACCESS_PG
                        && gAgent.isTeen())
                {
                        gGL.blendFunc(GL_DST_ALPHA, GL_ZERO);
                        
                        LLGLSNoTexture gls_no_texture;
                        gGL.color3f(1.f, 0.f, 0.f);
                        gGL.begin(LLVertexBuffer::LINES);
                                gGL.vertex2f(left, top);
                                gGL.vertex2f(right, bottom);
                                gGL.vertex2f(left, bottom);
                                gGL.vertex2f(right, top);
                        gGL.end();
                }

                // Draw the region name in the lower left corner
                LLFontGL* font = LLFontGL::sSansSerifSmall;

                char mesg[MAX_STRING];          /* Flawfinder: ignore */
                if (gMapScale < sThresholdA)
                {
                        mesg[0] = '\0';
                }
                else if (gMapScale < sThresholdB)
                {
                        //sprintf(mesg, "%d", info->mAgents);
                        mesg[0] = '\0';
                }
                else
                {
                        //sprintf(mesg, "%d / %s (%s)",
                        //                      info->mAgents,
                        //                      info->mName.c_str(),
                        //                      LLViewerRegion::accessToShortString(info->mAccess) );
                        if (info->mAccess == SIM_ACCESS_DOWN)
                        {
                                snprintf(mesg, MAX_STRING, "%s (Offline)", info->mName.c_str());                /* Flawfinder: ignore */
                        }
                        else
                        {
                                snprintf(mesg, MAX_STRING, "%s", info->mName.c_str());          /* Flawfinder: ignore */
                        }
                }

                if (mesg[0] != '\0')
                {
                        font->renderUTF8(
                                mesg, 0,
                                llfloor(left + 3), 
                                llfloor(bottom + 2),
                                LLColor4::white,
                                LLFontGL::LEFT,
                                LLFontGL::BASELINE,
                                LLFontGL::DROP_SHADOW);
                }
        }
#endif


#if 1
        // Draw background rectangle
        LLGLSUIDefault gls_ui;
        {
                LLGLSNoTexture gls_no_texture;
                glAlphaFunc(GL_GEQUAL, 0.0f);
                gGL.blendFunc(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA);
                gGL.color4fv( mBackgroundColor.mV );
                gl_rect_2d(0, height, width, 0);
        }
        
        glAlphaFunc(GL_GEQUAL, 0.01f);
        gGL.blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        // Infohubs
        if (gSavedSettings.getBOOL("MapShowInfohubs"))   //(gMapScale >= sThresholdB)
        {
                drawGenericItems(LLWorldMap::getInstance()->mInfohubs, sInfohubImage);
        }

        // Telehubs
        if (gSavedSettings.getBOOL("MapShowTelehubs"))   //(gMapScale >= sThresholdB)
        {
                drawGenericItems(LLWorldMap::getInstance()->mTelehubs, sTelehubImage);
        }

        // Home Sweet Home
        LLVector3d home;
        if (gAgent.getHomePosGlobal(&home))
        {
                drawImage(home, sHomeImage);
        }

        if (gSavedSettings.getBOOL("MapShowLandForSale"))
        {
                drawGenericItems(LLWorldMap::getInstance()->mLandForSale, sForSaleImage);
        }

        if (gSavedSettings.getBOOL("MapShowClassifieds"))
        {
                drawGenericItems(LLWorldMap::getInstance()->mClassifieds, sClassifiedsImage);
        }

        if (gSavedSettings.getBOOL("MapShowEvents"))
        {
                drawEvents();
        }

        // Now draw your avatar after all that other stuff.
        LLVector3d pos_global = gAgent.getPositionGlobal();
        drawImage(pos_global, sAvatarLargeImage);

        LLVector3 pos_map = globalPosToView(pos_global);
        if (!pointInView(llround(pos_map.mV[VX]), llround(pos_map.mV[VY])))
        {
                drawTracking(pos_global, 
                        lerp(LLColor4::yellow, LLColor4::orange, 0.4f), 
                        TRUE, 
                        "You are here", 
                        "", 
                        llround(LLFontGL::sSansSerifSmall->getLineHeight())); // offset vertically by one line, to avoid overlap with target tracking
        }

        // Show your viewing angle
        drawFrustum();

        // Draw icons for the avatars in each region.
        // Drawn after your avatar so you can see nearby people.
        if (gSavedSettings.getBOOL("MapShowPeople"))
        {
                drawAgents();
        }

        // Always draw tracking information
        LLTracker::ETrackingStatus tracking_status = LLTracker::getTrackingStatus();
        if ( LLTracker::TRACKING_AVATAR == tracking_status )
        {
                drawTracking( LLAvatarTracker::instance().getGlobalPos(), gTrackColor, TRUE, LLTracker::getLabel(), "" );
        } 
        else if ( LLTracker::TRACKING_LANDMARK == tracking_status 
                         || LLTracker::TRACKING_LOCATION == tracking_status )
        {
                // While fetching landmarks, will have 0,0,0 location for a while,
                // so don't draw. JC
                LLVector3d pos_global = LLTracker::getTrackedPositionGlobal();
                if (!pos_global.isExactlyZero())
                {
                        drawTracking( pos_global, gTrackColor, TRUE, LLTracker::getLabel(), LLTracker::getToolTip() );
                }
        }
        else if (LLWorldMap::getInstance()->mIsTrackingUnknownLocation)
        {
                if (LLWorldMap::getInstance()->mInvalidLocation)
                {
                        // We know this location to be invalid
                        LLColor4 loading_color(0.0, 0.5, 1.0, 1.0);
                        drawTracking( LLWorldMap::getInstance()->mUnknownLocation, loading_color, TRUE, "Invalid Location", "");
                }
                else
                {
                        double value = fmod(current_time, 2);
                        value = 0.5 + 0.5*cos(value * 3.14159f);
                        LLColor4 loading_color(0.0, F32(value/2), F32(value), 1.0);
                        drawTracking( LLWorldMap::getInstance()->mUnknownLocation, loading_color, TRUE, "Loading...", "");
                }
        }
#endif
        
        // turn off the scissor
        LLGLDisable no_scissor(GL_SCISSOR_TEST);
        
        updateDirections();

        LLView::draw();

        updateVisibleBlocks();
} // end draw()


//virtual
void LLWorldMapView::setVisible(BOOL visible)
{
        LLPanel::setVisible(visible);
        if (!visible)
        {
                for (S32 map = 0; map < MAP_SIM_IMAGE_TYPES; map++)
                {
                        for (U32 layer_idx=0; layer_idx<LLWorldMap::getInstance()->mMapLayers[map].size(); ++layer_idx)
                        {
                                if (LLWorldMap::getInstance()->mMapLayers[map][layer_idx].LayerDefined)
                                {
                                        LLWorldMapLayer *layer = &LLWorldMap::getInstance()->mMapLayers[map][layer_idx];
                                        layer->LayerImage->setBoostLevel(0);
                                }
                        }
                }
                for (LLWorldMap::sim_info_map_t::iterator it = LLWorldMap::getInstance()->mSimInfoMap.begin();
                         it != LLWorldMap::getInstance()->mSimInfoMap.end(); ++it)
                {
                        LLSimInfo* info = (*it).second;
                        if (info->mCurrentImage.notNull())
                        {
                                info->mCurrentImage->setBoostLevel(0);
                        }
                        if (info->mOverlayImage.notNull())
                        {
                                info->mOverlayImage->setBoostLevel(0);
                        }
                }
        }
}

void LLWorldMapView::drawGenericItems(const LLWorldMap::item_info_list_t& items, LLUIImagePtr image)
{
        LLWorldMap::item_info_list_t::const_iterator e;
        for (e = items.begin(); e != items.end(); ++e)
        {
                drawGenericItem(*e, image);
        }
}

void LLWorldMapView::drawGenericItem(const LLItemInfo& item, LLUIImagePtr image)
{
        drawImage(item.mPosGlobal, image);
}


void LLWorldMapView::drawImage(const LLVector3d& global_pos, LLUIImagePtr image, const LLColor4& color)
{
        LLVector3 pos_map = globalPosToView( global_pos );
        image->draw(llround(pos_map.mV[VX] - image->getWidth() /2.f),
                                llround(pos_map.mV[VY] - image->getHeight()/2.f),
                                color);
}

void LLWorldMapView::drawImageStack(const LLVector3d& global_pos, LLUIImagePtr image, U32 count, F32 offset, const LLColor4& color)
{
        LLVector3 pos_map = globalPosToView( global_pos );
        for(U32 i=0; i<count; i++)
        {
                image->draw(llround(pos_map.mV[VX] - image->getWidth() /2.f),
                                        llround(pos_map.mV[VY] - image->getHeight()/2.f + i*offset),
                                        color);
        }
}


void LLWorldMapView::drawAgents()
{
        F32 agents_scale = (gMapScale * 0.9f) / 256.f;

        for (handle_list_t::iterator iter = mVisibleRegions.begin(); iter != mVisibleRegions.end(); ++iter)
        {
                U64 handle = *iter;
                LLSimInfo* siminfo = LLWorldMap::getInstance()->simInfoFromHandle(handle);
                if (siminfo && (siminfo->mAccess == SIM_ACCESS_DOWN))
                {
                        continue;
                }
                LLWorldMap::agent_list_map_t::iterator counts_iter = LLWorldMap::getInstance()->mAgentLocationsMap.find(handle);
                if (siminfo && siminfo->mShowAgentLocations && counts_iter != LLWorldMap::getInstance()->mAgentLocationsMap.end())
                {
                        // Show Individual agents (or little stacks where real agents are)
                        LLWorldMap::item_info_list_t& agentcounts = counts_iter->second;
                        S32 sim_agent_count = 0;
                        for (LLWorldMap::item_info_list_t::iterator iter = agentcounts.begin();
                                 iter != agentcounts.end(); ++iter)
                        {
                                const LLItemInfo& info = *iter;
                                S32 agent_count = info.mExtra;
                                sim_agent_count += info.mExtra;
                                // Here's how we'd choose the color if info.mID were available but it's not being sent:
                                //LLColor4 color = (agent_count == 1 && is_agent_friend(info.mID)) ? gFriendMapColor : gAvatarMapColor;
                                drawImageStack(info.mPosGlobal, sAvatarSmallImage, agent_count, 3.f, gAvatarMapColor);
                        }
                        LLWorldMap::getInstance()->mNumAgents[handle] = sim_agent_count; // override mNumAgents for this sim
                }
                else
                {
                        // Show agent 'stack' at center of sim
                        S32 num_agents = LLWorldMap::getInstance()->mNumAgents[handle];
                        if (num_agents > 0)
                        {
                                LLVector3d region_center = from_region_handle(handle);
                                region_center[VX] += REGION_WIDTH_METERS / 2;
                                region_center[VY] += REGION_WIDTH_METERS / 2;
                                // Reduce the stack size as you zoom out - always display at lease one agent where there is one or more
                                S32 agent_count = (S32)(((num_agents-1) * agents_scale + (num_agents-1) * 0.1f)+.1f) + 1;
                                drawImageStack(region_center, sAvatarSmallImage, agent_count, 3.f, gAvatarMapColor);
                        }
                }
        }
}


void LLWorldMapView::drawEvents()
{
    BOOL show_mature = gSavedSettings.getBOOL("ShowMatureEvents");

    // First the non-selected events
    LLWorldMap::item_info_list_t::const_iterator e;
    for (e = LLWorldMap::getInstance()->mPGEvents.begin(); e != LLWorldMap::getInstance()->mPGEvents.end(); ++e)
    {
        if (!e->mSelected)
        {
            drawGenericItem(*e, sEventImage);   
        }
    }
    if (show_mature)
    {
        for (e = LLWorldMap::getInstance()->mMatureEvents.begin(); e != LLWorldMap::getInstance()->mMatureEvents.end(); ++e)
        {
            if (!e->mSelected)
            {
                drawGenericItem(*e, sEventMatureImage);       
            }
        }
    }

    // Then the selected events
    for (e = LLWorldMap::getInstance()->mPGEvents.begin(); e != LLWorldMap::getInstance()->mPGEvents.end(); ++e)
    {
        if (e->mSelected)
        {
            drawGenericItem(*e, sEventImage);
        }
    }
    if (show_mature)
    {
        for (e = LLWorldMap::getInstance()->mMatureEvents.begin(); e != LLWorldMap::getInstance()->mMatureEvents.end(); ++e)
        {
            if (e->mSelected)
            {
                drawGenericItem(*e, sEventMatureImage);       
            }
        }
    }
}


void LLWorldMapView::drawFrustum()
{
        // Draw frustum
        F32 meters_to_pixels = gMapScale/ REGION_WIDTH_METERS;

        F32 horiz_fov = LLViewerCamera::getInstance()->getView() * LLViewerCamera::getInstance()->getAspect();
        F32 far_clip_meters = LLViewerCamera::getInstance()->getFar();
        F32 far_clip_pixels = far_clip_meters * meters_to_pixels;

        F32 half_width_meters = far_clip_meters * tan( horiz_fov / 2 );
        F32 half_width_pixels = half_width_meters * meters_to_pixels;
        
        F32 ctr_x = getRect().getWidth() * 0.5f + sPanX;
        F32 ctr_y = getRect().getHeight() * 0.5f + sPanY;

        LLGLSNoTexture gls_no_texture;

        // Since we don't rotate the map, we have to rotate the frustum.
        gGL.pushMatrix();
                gGL.translatef( ctr_x, ctr_y, 0 );
                glRotatef( atan2( LLViewerCamera::getInstance()->getAtAxis().mV[VX], LLViewerCamera::getInstance()->getAtAxis().mV[VY] ) * RAD_TO_DEG, 0.f, 0.f, -1.f);

                // Draw triangle with more alpha in far pixels to make it 
                // fade out in distance.
                gGL.begin( LLVertexBuffer::TRIANGLES  );
                        gGL.color4f(1.f, 1.f, 1.f, 0.25f);
                        gGL.vertex2f( 0, 0 );

                        gGL.color4f(1.f, 1.f, 1.f, 0.02f);
                        gGL.vertex2f( -half_width_pixels, far_clip_pixels );

                        gGL.color4f(1.f, 1.f, 1.f, 0.02f);
                        gGL.vertex2f(  half_width_pixels, far_clip_pixels );
                gGL.end();
        gGL.popMatrix();
}


LLVector3 LLWorldMapView::globalPosToView( const LLVector3d& global_pos )
{
        LLVector3d relative_pos_global = global_pos - gAgent.getCameraPositionGlobal();
        LLVector3 pos_local;
        pos_local.setVec(relative_pos_global);  // convert to floats from doubles

        pos_local.mV[VX] *= sPixelsPerMeter;
        pos_local.mV[VY] *= sPixelsPerMeter;
        // leave Z component in meters


        pos_local.mV[VX] += getRect().getWidth() / 2 + sPanX;
        pos_local.mV[VY] += getRect().getHeight() / 2 + sPanY;

        return pos_local;
}


void LLWorldMapView::drawTracking(const LLVector3d& pos_global, const LLColor4& color, 
                                                        BOOL draw_arrow, LLString label, LLString tooltip, S32 vert_offset )
{
        LLVector3 pos_local = globalPosToView( pos_global );
        S32 x = llround( pos_local.mV[VX] );
        S32 y = llround( pos_local.mV[VY] );
        LLFontGL* font = LLFontGL::sSansSerifSmall;
        S32 text_x = x;
        S32 text_y = (S32)(y - sTrackCircleImage->getHeight()/2 - font->getLineHeight());

        BOOL is_in_window = true;

        if(    x < 0 
                || y < 0 
                || x >= getRect().getWidth() 
                || y >= getRect().getHeight() )
        {
                if (draw_arrow)
                {
                        drawTrackingCircle( getRect(), x, y, color, 3, 15 );
                        drawTrackingArrow( getRect(), x, y, color );
                        text_x = sTrackingArrowX;
                        text_y = sTrackingArrowY;
                }
                is_in_window = false;
        }
        else if (LLTracker::getTrackingStatus() == LLTracker::TRACKING_LOCATION &&
                LLTracker::getTrackedLocationType() != LLTracker::LOCATION_NOTHING)
        {
                drawTrackingCircle( getRect(), x, y, color, 3, 15 );
        }
        else
        {
                drawImage(pos_global, sTrackCircleImage, color);
        }

        // clamp text position to on-screen
        const S32 TEXT_PADDING = DEFAULT_TRACKING_ARROW_SIZE + 2;
        S32 half_text_width = llfloor(font->getWidthF32(label) * 0.5f);
        text_x = llclamp(text_x, half_text_width + TEXT_PADDING, getRect().getWidth() - half_text_width - TEXT_PADDING);
        text_y = llclamp(text_y + vert_offset, TEXT_PADDING + vert_offset, getRect().getHeight() - llround(font->getLineHeight()) - TEXT_PADDING - vert_offset);

        if (label != "")
        {
                font->renderUTF8(
                        label, 0,
                        text_x, 
                        text_y,
                        LLColor4::white, LLFontGL::HCENTER,
                        LLFontGL::BASELINE, LLFontGL::DROP_SHADOW);

                if (tooltip != "")
                {
                        text_y -= (S32)font->getLineHeight();

                        font->renderUTF8(
                                tooltip, 0,
                                text_x, 
                                text_y,
                                LLColor4::white, LLFontGL::HCENTER,
                                LLFontGL::BASELINE, LLFontGL::DROP_SHADOW);
                }
        }
}

// 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));

        LLVector3 pos_local( (F32)x, (F32)y, 0.f );

        pos_local *= ( REGION_WIDTH_METERS / gMapScale );
        
        LLVector3d pos_global;
        pos_global.setVec( pos_local );
        pos_global += gAgent.getCameraPositionGlobal();
        if(gAgent.isGodlike())
        {
                pos_global.mdV[VZ] = GODLY_TELEPORT_HEIGHT; // Godly height should always be 200.
        }
        else
        {
                pos_global.mdV[VZ] = gAgent.getPositionAgent().mV[VZ]; // Want agent's height, not camera's
        }

        return pos_global;
}


BOOL LLWorldMapView::handleToolTip( S32 x, S32 y, LLString& msg, LLRect* sticky_rect_screen )
{
        LLVector3d pos_global = viewPosToGlobal(x, y);

        LLSimInfo* info = LLWorldMap::getInstance()->simInfoFromPosGlobal(pos_global);
        if (info)
        {
                LLViewerRegion *region = gAgent.getRegion();

                std::string message = 
                        llformat("%s (%s)",
                                         info->mName.c_str(),
                                         LLViewerRegion::accessToString(info->mAccess));

                if (info->mAccess != SIM_ACCESS_DOWN)
                {
                        S32 agent_count = LLWorldMap::getInstance()->mNumAgents[info->mHandle];                 
                        if (region && region->getHandle() == info->mHandle)
                        {
                                ++agent_count; // Bump by 1 if we're here
                        }

                        // We may not have an agent count when the map is really
                        // zoomed out, so don't display anything about the count. JC
                        if (agent_count > 0)
                        {
                                message += llformat("\n%d ", agent_count);

                                if (agent_count == 1)
                                {
                                        message += "person";
                                }
                                else
                                {
                                        message += "people";
                                }
                        }
                }
                msg.assign( message );

                // Optionally show region flags
                std::string region_flags = LLViewerRegion::regionFlagsToString(info->mRegionFlags);

                if (!region_flags.empty())
                {
                        msg += '\n';
                        msg += region_flags;
                }
                                        
                S32 SLOP = 4;
                localPointToScreen( 
                        x - SLOP, y - SLOP, 
                        &(sticky_rect_screen->mLeft), &(sticky_rect_screen->mBottom) );
                sticky_rect_screen->mRight = sticky_rect_screen->mLeft + 2 * SLOP;
                sticky_rect_screen->mTop = sticky_rect_screen->mBottom + 2 * SLOP;
        }
        return TRUE;
}

// Pass relative Z of 0 to draw at same level.
// static
static void drawDot(F32 x_pixels, F32 y_pixels,
                         const LLColor4& color,
                         F32 relative_z,
                         F32 dot_radius,
                         LLUIImagePtr dot_image)
{
        const F32 HEIGHT_THRESHOLD = 7.f;

        if(-HEIGHT_THRESHOLD <= relative_z && relative_z <= HEIGHT_THRESHOLD)
        {
                dot_image->draw(llround(x_pixels) - dot_image->getWidth()/2,
                                                llround(y_pixels) - dot_image->getHeight()/2, 
                                                color);
        }
        else
        {
                F32 left =              x_pixels - dot_radius;
                F32 right =             x_pixels + dot_radius;
                F32 center = (left + right) * 0.5f;
                F32 top =               y_pixels + dot_radius;
                F32 bottom =    y_pixels - dot_radius;

                LLGLSNoTexture gls_no_texture;
                gGL.color4fv( color.mV );
                LLUI::setLineWidth(1.5f);
                F32 h_bar = relative_z > HEIGHT_THRESHOLD ? top : bottom; // horizontal bar Y
                gGL.begin( LLVertexBuffer::LINES );
                        gGL.vertex2f(center, top);
                        gGL.vertex2f(left, h_bar);
                        gGL.vertex2f(right, h_bar);
                        gGL.vertex2f(right, bottom);
                gGL.end();
                LLUI::setLineWidth(1.0f);
        }
}

// Pass relative Z of 0 to draw at same level.
// static
void LLWorldMapView::drawAvatar(F32 x_pixels, 
                                                                F32 y_pixels,
                                                                const LLColor4& color,
                                                                F32 relative_z,
                                                                F32 dot_radius)
{
        const F32 HEIGHT_THRESHOLD = 7.f;
        LLUIImagePtr dot_image = sAvatarSmallImage;
        if(relative_z < -HEIGHT_THRESHOLD) 
        {
                dot_image = sAvatarBelowImage; 
        }
        else if(relative_z > HEIGHT_THRESHOLD) 
        { 
                dot_image = sAvatarAboveImage;
        }
        dot_image->draw(
                llround(x_pixels) - dot_image->getWidth()/2,
                llround(y_pixels) - dot_image->getHeight()/2, 
                color);
}

// Pass relative Z of 0 to draw at same level.
// static
void LLWorldMapView::drawTrackingDot( F32 x_pixels, 
                                                                          F32 y_pixels,
                                                                          const LLColor4& color,
                                                                          F32 relative_z,
                                                                          F32 dot_radius)
{
        drawDot(x_pixels, y_pixels, color, relative_z, dot_radius, sTrackCircleImage);
}


// Pass relative Z of 0 to draw at same level.
// static
void LLWorldMapView::drawIconName(F32 x_pixels, 
                                                                  F32 y_pixels,
                                                                  const LLColor4& color,
                                                                  const std::string& first_line,
                                                                  const std::string& second_line)
{
        const S32 VERT_PAD = 8;
        S32 text_x = llround(x_pixels);
        S32 text_y = llround(y_pixels
                                                 - BIG_DOT_RADIUS
                                                 - VERT_PAD);

        // render text
        LLFontGL::sSansSerif->renderUTF8(first_line, 0,
                text_x,
                text_y,
                color,
                LLFontGL::HCENTER,
                LLFontGL::TOP,
                LLFontGL::DROP_SHADOW);

        text_y -= llround(LLFontGL::sSansSerif->getLineHeight());

        // render text
        LLFontGL::sSansSerif->renderUTF8(second_line, 0,
                text_x,
                text_y,
                color,
                LLFontGL::HCENTER,
                LLFontGL::TOP,
                LLFontGL::DROP_SHADOW);
}


//static 
void LLWorldMapView::drawTrackingCircle( const LLRect& rect, S32 x, S32 y, const LLColor4& color, S32 min_thickness, S32 overlap )
{
        F32 start_theta = 0.f;
        F32 end_theta = F_TWO_PI;
        F32 x_delta = 0.f;
        F32 y_delta = 0.f;

        if (x < 0)
        {
                x_delta = 0.f - (F32)x;
                start_theta = F_PI + F_PI_BY_TWO;
                end_theta = F_TWO_PI + F_PI_BY_TWO;
        }
        else if (x > rect.getWidth())
        {
                x_delta = (F32)(x - rect.getWidth());
                start_theta = F_PI_BY_TWO;
                end_theta = F_PI + F_PI_BY_TWO;
        }

        if (y < 0)
        {
                y_delta = 0.f - (F32)y;
                if (x < 0)
                {
                        start_theta = 0.f;
                        end_theta = F_PI_BY_TWO;
                }
                else if (x > rect.getWidth())
                {
                        start_theta = F_PI_BY_TWO;
                        end_theta = F_PI;
                }
                else
                {
                        start_theta = 0.f;
                        end_theta = F_PI;
                }
        }
        else if (y > rect.getHeight())
        {
                y_delta = (F32)(y - rect.getHeight());
                if (x < 0)
                {
                        start_theta = F_PI + F_PI_BY_TWO;
                        end_theta = F_TWO_PI;
                }
                else if (x > rect.getWidth())
                {
                        start_theta = F_PI;
                        end_theta = F_PI + F_PI_BY_TWO;
                }
                else
                {
                        start_theta = F_PI;
                        end_theta = F_TWO_PI;
                }
        }

        F32 distance = sqrtf(x_delta * x_delta + y_delta * y_delta);

        distance = llmax(0.1f, distance);

        F32 outer_radius = distance + (1.f + (9.f * sqrtf(x_delta * y_delta) / distance)) * (F32)overlap;
        F32 inner_radius = outer_radius - (F32)min_thickness;
        
        F32 angle_adjust_x = asin(x_delta / outer_radius);
        F32 angle_adjust_y = asin(y_delta / outer_radius);

        if (angle_adjust_x)
        {
                if (angle_adjust_y)
                {
                        F32 angle_adjust = llmin(angle_adjust_x, angle_adjust_y);
                        start_theta += angle_adjust;
                        end_theta -= angle_adjust;
                }
                else
                {
                        start_theta += angle_adjust_x;
                        end_theta -= angle_adjust_x;
                }
        }
        else if (angle_adjust_y)
        {
                start_theta += angle_adjust_y;
                end_theta -= angle_adjust_y;
        }

        glMatrixMode(GL_MODELVIEW);
        gGL.pushMatrix();
        gGL.translatef((F32)x, (F32)y, 0.f);
        gl_washer_segment_2d(inner_radius, outer_radius, start_theta, end_theta, 40, color, color);
        gGL.popMatrix();

}

// static
void LLWorldMapView::drawTrackingArrow(const LLRect& rect, S32 x, S32 y, 
                                                                           const LLColor4& color,
                                                                           S32 arrow_size)
{
        F32 x_center = (F32)rect.getWidth() / 2.f;
        F32 y_center = (F32)rect.getHeight() / 2.f;

        F32 x_clamped = (F32)llclamp( x, 0, rect.getWidth() - arrow_size );
        F32 y_clamped = (F32)llclamp( y, 0, rect.getHeight() - arrow_size );

        F32 slope = (F32)(y - y_center) / (F32)(x - x_center);
        F32 window_ratio = (F32)rect.getHeight() / (F32)rect.getWidth();

        if (llabs(slope) > window_ratio && y_clamped != (F32)y)
        {
                // clamp by y 
                x_clamped = (y_clamped - y_center) / slope + x_center;
                // adjust for arrow size
                x_clamped  = llclamp(x_clamped , 0.f, (F32)(rect.getWidth() - arrow_size) );
        }
        else if (x_clamped != (F32)x)
        {
                // clamp by x
                y_clamped = (x_clamped - x_center) * slope + y_center;
                // adjust for arrow size 
                y_clamped = llclamp( y_clamped, 0.f, (F32)(rect.getHeight() - arrow_size) );
        }

        // *FIX: deal with non-square window properly.
        // I do not understand what this comment means -- is it actually
        // broken or is it correctly dealing with non-square
        // windows. Phoenix 2007-01-03.
        S32 half_arrow_size = (S32) (0.5f * arrow_size);

        F32 angle = atan2( y + half_arrow_size - y_center, x + half_arrow_size - x_center);

        sTrackingArrowX = llfloor(x_clamped);
        sTrackingArrowY = llfloor(y_clamped);

        gl_draw_scaled_rotated_image(
                sTrackingArrowX,
                sTrackingArrowY,
                arrow_size, arrow_size, 
                RAD_TO_DEG * angle, 
                sTrackArrowImage->getImage(), 
                color);
}

void LLWorldMapView::setDirectionPos( LLTextBox* text_box, F32 rotation )
{
        // Rotation is in radians.
        // Rotation of 0 means x = 1, y = 0 on the unit circle.


        F32 map_half_height = getRect().getHeight() * 0.5f;
        F32 map_half_width = getRect().getWidth() * 0.5f;
        F32 text_half_height = text_box->getRect().getHeight() * 0.5f;
        F32 text_half_width = text_box->getRect().getWidth() * 0.5f;
        F32 radius = llmin( map_half_height - text_half_height, map_half_width - text_half_width );

        text_box->setOrigin( 
                llround(map_half_width - text_half_width + radius * cos( rotation )),
                llround(map_half_height - text_half_height + radius * sin( rotation )) );
}


void LLWorldMapView::updateDirections()
{
        S32 width = getRect().getWidth();
        S32 height = getRect().getHeight();

        S32 text_height = mTextBoxNorth->getRect().getHeight();
        S32 text_width = mTextBoxNorth->getRect().getWidth();

        const S32 PAD = 2;
        S32 top = height - text_height - PAD;
        S32 left = PAD*2;
        S32 bottom = PAD;
        S32 right = width - text_width - PAD;
        S32 center_x = width/2 - text_width/2;
        S32 center_y = height/2 - text_height/2;

        mTextBoxNorth->setOrigin( center_x, top );
        mTextBoxEast->setOrigin( right, center_y );
        mTextBoxSouth->setOrigin( center_x, bottom );
        mTextBoxWest->setOrigin( left, center_y );

        // These have wider text boxes
        text_width = mTextBoxNorthWest->getRect().getWidth();
        right = width - text_width - PAD;

        mTextBoxNorthWest->setOrigin(left, top);
        mTextBoxNorthEast->setOrigin(right, top);
        mTextBoxSouthWest->setOrigin(left, bottom);
        mTextBoxSouthEast->setOrigin(right, bottom);

//      S32 hint_width = mTextBoxScrollHint->getRect().getWidth();
//      mTextBoxScrollHint->setOrigin( width - hint_width - text_width - 2 * PAD, 
//                      PAD * 2 + text_height );
}


void LLWorldMapView::reshape( S32 width, S32 height, BOOL called_from_parent )
{
        LLView::reshape( width, height, called_from_parent );
}

bool LLWorldMapView::checkItemHit(S32 x, S32 y, LLItemInfo& item, LLUUID* id, bool track)
{
        LLVector3 pos_view = globalPosToView(item.mPosGlobal);
        S32 item_x = llround(pos_view.mV[VX]);
        S32 item_y = llround(pos_view.mV[VY]);

        if (x < item_x - BIG_DOT_RADIUS) return false;
        if (x > item_x + BIG_DOT_RADIUS) return false;
        if (y < item_y - BIG_DOT_RADIUS) return false;
        if (y > item_y + BIG_DOT_RADIUS) return false;

        LLSimInfo* sim_info = LLWorldMap::getInstance()->simInfoFromHandle(item.mRegionHandle);
        if (sim_info)
        {
                if (track)
                {
                        gFloaterWorldMap->trackLocation(item.mPosGlobal);
                }
        }

        if (track)
        {
                gFloaterWorldMap->trackGenericItem(item);
        }

        item.mSelected = TRUE;
        *id = item.mID;

        return true;
}

// Handle a click, which might be on a dot
void LLWorldMapView::handleClick(S32 x, S32 y, MASK mask,
                                                                 S32* hit_type,
                                                                 LLUUID* id)
{
        LLVector3d pos_global = viewPosToGlobal(x, y);

        // *HACK: Adjust Z values automatically for liaisons & gods so
        // we swoop down when they click on the map. Sadly, the P2P
        // branch does not pay attention to this value; however, the
        // Distributed Messaging branch honors it.
        if(gAgent.isGodlike())
        {
                pos_global.mdV[VZ] = 200.0;
        }

        *hit_type = 0; // hit nothing

        LLWorldMap::getInstance()->mIsTrackingUnknownLocation = FALSE;
        LLWorldMap::getInstance()->mIsTrackingDoubleClick = FALSE;
        LLWorldMap::getInstance()->mIsTrackingCommit = FALSE;

        LLWorldMap::item_info_list_t::iterator it;

        // clear old selected stuff
        for (it = LLWorldMap::getInstance()->mPGEvents.begin(); it != LLWorldMap::getInstance()->mPGEvents.end(); ++it)
        {
                (*it).mSelected = FALSE;
        }
        for (it = LLWorldMap::getInstance()->mMatureEvents.begin(); it != LLWorldMap::getInstance()->mMatureEvents.end(); ++it)
        {
                (*it).mSelected = FALSE;
        }
        for (it = LLWorldMap::getInstance()->mLandForSale.begin(); it != LLWorldMap::getInstance()->mLandForSale.end(); ++it)
        {
                (*it).mSelected = FALSE;
        }
        for (it = LLWorldMap::getInstance()->mClassifieds.begin(); it != LLWorldMap::getInstance()->mClassifieds.end(); ++it)
        {
                (*it).mSelected = FALSE;
        }

        // Select event you clicked on
        if (gSavedSettings.getBOOL("MapShowEvents"))
        {
                for (it = LLWorldMap::getInstance()->mPGEvents.begin(); it != LLWorldMap::getInstance()->mPGEvents.end(); ++it)
                {
                        LLItemInfo& event = *it;

                        if (checkItemHit(x, y, event, id, false))
                        {
                                *hit_type = MAP_ITEM_PG_EVENT;
                                mItemPicked = TRUE;
                                gFloaterWorldMap->trackEvent(event);
                                return;
                        }
                }
                if (gSavedSettings.getBOOL("ShowMatureEvents"))
                {
                        for (it = LLWorldMap::getInstance()->mMatureEvents.begin(); it != LLWorldMap::getInstance()->mMatureEvents.end(); ++it)
                        {
                                LLItemInfo& event = *it;

                                if (checkItemHit(x, y, event, id, false))
                                {
                                        *hit_type = MAP_ITEM_MATURE_EVENT;
                                        mItemPicked = TRUE;
                                        gFloaterWorldMap->trackEvent(event);
                                        return;
                                }
                        }
                }
        }

        if (gSavedSettings.getBOOL("MapShowLandForSale"))
        {
                for (it = LLWorldMap::getInstance()->mLandForSale.begin(); it != LLWorldMap::getInstance()->mLandForSale.end(); ++it)
                {
                        LLItemInfo& land = *it;

                        if (checkItemHit(x, y, land, id, true))
                        {
                                *hit_type = MAP_ITEM_LAND_FOR_SALE;
                                mItemPicked = TRUE;
                                return;
                        }
                }
        }

        if (gSavedSettings.getBOOL("MapShowClassifieds"))
        {
                for (it = LLWorldMap::getInstance()->mClassifieds.begin(); it != LLWorldMap::getInstance()->mClassifieds.end(); ++it)
                {
                        LLItemInfo& classified = *it;

                        if (checkItemHit(x, y, classified, id, true))
                        {
                                *hit_type = MAP_ITEM_CLASSIFIED;
                                mItemPicked = TRUE;
                                return;
                        }
                }
        }

        // If we get here, we haven't clicked on an icon

        gFloaterWorldMap->trackLocation(pos_global);
        mItemPicked = FALSE;

        *id = LLUUID::null;
        return;
}


BOOL outside_slop(S32 x, S32 y, S32 start_x, S32 start_y)
{
        S32 dx = x - start_x;
        S32 dy = y - start_y;

        return (dx <= -2 || 2 <= dx || dy <= -2 || 2 <= dy);
}

BOOL LLWorldMapView::handleMouseDown( S32 x, S32 y, MASK mask )
{
        gFocusMgr.setMouseCapture( this );

        mMouseDownPanX = llround(sPanX);
        mMouseDownPanY = llround(sPanY);
        mMouseDownX = x;
        mMouseDownY = y;
        sHandledLastClick = TRUE;
        return TRUE;
}

BOOL LLWorldMapView::handleMouseUp( S32 x, S32 y, MASK mask )
{
        if (hasMouseCapture())
        {
                if (mPanning)
                {
                        // restore mouse cursor
                        S32 local_x, local_y;
                        local_x = mMouseDownX + llfloor(sPanX - mMouseDownPanX);
                        local_y = mMouseDownY + llfloor(sPanY - mMouseDownPanY);
                        LLRect clip_rect = getRect();
                        clip_rect.stretch(-8);
                        clip_rect.clipPointToRect(mMouseDownX, mMouseDownY, local_x, local_y);
                        LLUI::setCursorPositionLocal(this, local_x, local_y);

                        // finish the pan
                        mPanning = FALSE;
                        
                        mMouseDownX = 0;
                        mMouseDownY = 0;
                }
                else
                {
                        // ignore whether we hit an event or not
                        S32 hit_type;
                        LLUUID id;
                        handleClick(x, y, mask, &hit_type, &id);
                }
                gViewerWindow->showCursor();
                gFocusMgr.setMouseCapture( NULL );
                return TRUE;
        }
        return FALSE;
}

void LLWorldMapView::updateBlock(S32 block_x, S32 block_y)
{
        S32 offset = block_x | (block_y * MAP_BLOCK_RES);
        if (!LLWorldMap::getInstance()->mMapBlockLoaded[LLWorldMap::getInstance()->mCurrentMap][offset])
        {
//              llinfos << "Loading Block (" << block_x << "," << block_y << ")" << llendl;
                LLWorldMap::getInstance()->sendMapBlockRequest(block_x << 3, block_y << 3, (block_x << 3) + 7, (block_y << 3) + 7);
                LLWorldMap::getInstance()->mMapBlockLoaded[LLWorldMap::getInstance()->mCurrentMap][offset] = TRUE;
        }
}

void LLWorldMapView::updateVisibleBlocks()
{
        if (gMapScale < SIM_MAP_SCALE)
        {
                // We don't care what is loaded if we're zoomed out
                return;
        }
        // check if we've loaded the 9 potentially visible zones
        LLVector3d camera_global = gAgent.getCameraPositionGlobal();

        // Convert pan to sim coordinates
        S32 world_center_x = S32((-sPanX / gMapScale) + (camera_global.mdV[0] / REGION_WIDTH_METERS));
        S32 world_center_y = S32((-sPanY / gMapScale) + (camera_global.mdV[1] / REGION_WIDTH_METERS));

        // Find the corresponding 8x8 block
        S32 world_block_x = world_center_x >> 3;
        S32 world_block_y = world_center_y >> 3;

        for (S32 block_x = llmax(world_block_x-1, 0); block_x <= llmin(world_block_x+1, MAP_BLOCK_RES-1); ++block_x)
        {
                for (S32 block_y = llmax(world_block_y-1, 0); block_y <= llmin(world_block_y+1, MAP_BLOCK_RES-1); ++block_y)
                {
                        updateBlock(block_x, block_y);
                }
        }
}

BOOL LLWorldMapView::handleHover( S32 x, S32 y, MASK mask )
{
        if (hasMouseCapture())
        {
                if (mPanning || outside_slop(x, y, mMouseDownX, mMouseDownY))
                {
                        // just started panning, so hide cursor
                        if (!mPanning)
                        {
                                mPanning = TRUE;
                                gViewerWindow->hideCursor();
                        }

                        F32 delta_x = (F32)(gViewerWindow->getCurrentMouseDX());
                        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;

                        gViewerWindow->moveCursorToCenter();
                }

                // doesn't matter, cursor should be hidden
                gViewerWindow->setCursor(UI_CURSOR_CROSS );
                return TRUE;
        }
        else
        {
                // While we're waiting for data from the tracker, we're busy. JC
                LLVector3d pos_global = LLTracker::getTrackedPositionGlobal();
                if (LLTracker::isTracking(NULL)
                        && pos_global.isExactlyZero())
                {
                        gViewerWindow->setCursor( UI_CURSOR_WAIT );
                }
                else
                {
                        gViewerWindow->setCursor( UI_CURSOR_CROSS );
                }
                lldebugst(LLERR_USER_INPUT) << "hover handled by LLWorldMapView" << llendl;             
                return TRUE;
        }
}


BOOL LLWorldMapView::handleDoubleClick( S32 x, S32 y, MASK mask )
{
        if( sHandledLastClick )
        {
                S32 hit_type;
                LLUUID id;
                handleClick(x, y, mask, &hit_type, &id);

                switch (hit_type)
                {
                case MAP_ITEM_PG_EVENT:
                case MAP_ITEM_MATURE_EVENT:
                        {
                                gFloaterWorldMap->close();
                                // This is an ungainly hack
                                char uuid_str[38];              /* Flawfinder: ignore */
                                S32 event_id;
                                id.toString(uuid_str);
                                sscanf(&uuid_str[28], "%X", &event_id);
                                LLFloaterDirectory::showEvents(event_id);
                                break;
                        }
                case MAP_ITEM_LAND_FOR_SALE:
                        {
                                gFloaterWorldMap->close();
                                LLFloaterDirectory::showLandForSale(id);
                                break;
                        }
                case MAP_ITEM_CLASSIFIED:
                        {
                                gFloaterWorldMap->close();
                                LLFloaterDirectory::showClassified(id);
                                break;
                        }
                default:
                        {
                                if (LLWorldMap::getInstance()->mIsTrackingUnknownLocation)
                                {
                                        LLWorldMap::getInstance()->mIsTrackingDoubleClick = TRUE;
                                }
                                else
                                {
                                        // Teleport if we got a valid location
                                        LLVector3d pos_global = viewPosToGlobal(x,y);
                                        LLSimInfo* sim_info = LLWorldMap::getInstance()->simInfoFromPosGlobal(pos_global);
                                        if (sim_info && sim_info->mAccess != SIM_ACCESS_DOWN)
                                        {
                                                gAgent.teleportViaLocation( pos_global );
                                        }
                                }
                        }
                };

                return TRUE;
        }
        return FALSE;
}

---