diff options
Diffstat (limited to 'indra/newview/llworldmapview.cpp')
| -rw-r--r-- | indra/newview/llworldmapview.cpp | 1940 |
1 files changed, 1940 insertions, 0 deletions
diff --git a/indra/newview/llworldmapview.cpp b/indra/newview/llworldmapview.cpp new file mode 100644 index 0000000000..56e496e303 --- /dev/null +++ b/indra/newview/llworldmapview.cpp @@ -0,0 +1,1940 @@ +/** + * @file llworldmapview.cpp + * @brief LLWorldMapView class implementation + * + * Copyright (c) 2001-$CurrentYear$, Linden Research, Inc. + * $License$ + */ + +#include "llviewerprecompiledheaders.h" + +#include "llworldmapview.h" + +#include "indra_constants.h" +#include "llui.h" +#include "linked_lists.h" +#include "llmath.h" // clampf() +#include "llregionhandle.h" +#include "lleventflags.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 "llviewerparceloverlay.h" +#include "llviewerregion.h" +#include "llviewerwindow.h" +#include "llworld.h" +#include "llworldmap.h" +#include "viewer.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; + +LLPointer<LLViewerImage> LLWorldMapView::sAvatarYouSmallImage = NULL; +LLPointer<LLViewerImage> LLWorldMapView::sAvatarSmallImage = NULL; +LLPointer<LLViewerImage> LLWorldMapView::sAvatarLargeImage = NULL; + +LLPointer<LLViewerImage> LLWorldMapView::sTelehubImage = NULL; +LLPointer<LLViewerImage> LLWorldMapView::sInfohubImage = NULL; +LLPointer<LLViewerImage> LLWorldMapView::sHomeImage = NULL; +LLPointer<LLViewerImage> LLWorldMapView::sEventImage = NULL; +LLPointer<LLViewerImage> LLWorldMapView::sEventMatureImage = NULL; + +LLPointer<LLViewerImage> LLWorldMapView::sTrackCircleImage = NULL; +LLPointer<LLViewerImage> LLWorldMapView::sTrackArrowImage = NULL; + +LLPointer<LLViewerImage> LLWorldMapView::sClassifiedsImage = NULL; +LLPointer<LLViewerImage> LLWorldMapView::sPopularImage = NULL; +LLPointer<LLViewerImage> 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; + +void LLWorldMapView::initClass() +{ + LLUUID image_id; + + image_id.set( gViewerArt.getString("map_avatar_you_8.tga") ); + sAvatarYouSmallImage = gImageList.getImage( image_id, MIPMAP_FALSE, TRUE); + + image_id.set( gViewerArt.getString("map_avatar_8.tga") ); + sAvatarSmallImage = gImageList.getImage( image_id, MIPMAP_FALSE, TRUE); + + image_id.set( gViewerArt.getString("map_avatar_16.tga") ); + sAvatarLargeImage = gImageList.getImage( image_id, MIPMAP_FALSE, TRUE); + + image_id.set( gViewerArt.getString("map_home.tga") ); + sHomeImage = gImageList.getImage(image_id, MIPMAP_FALSE, TRUE); + + image_id.set( gViewerArt.getString("map_telehub.tga") ); + sTelehubImage = gImageList.getImage(image_id, MIPMAP_FALSE, TRUE); + + image_id.set( gViewerArt.getString("map_infohub.tga") ); + sInfohubImage = gImageList.getImage(image_id, MIPMAP_FALSE, TRUE); + + image_id.set( gViewerArt.getString("map_event.tga") ); + sEventImage = gImageList.getImage(image_id, MIPMAP_FALSE, TRUE); + + image_id.set( gViewerArt.getString("map_event_mature.tga") ); + sEventMatureImage = gImageList.getImage(image_id, MIPMAP_FALSE, TRUE); + + image_id.set( gViewerArt.getString("map_track_16.tga") ); + sTrackCircleImage = gImageList.getImage(image_id, MIPMAP_FALSE, TRUE); + + image_id.set( gViewerArt.getString("direction_arrow.tga") ); + sTrackArrowImage = gImageList.getImage(image_id, MIPMAP_FALSE, TRUE); + // Make sure tracker arrow doesn't wrap + sTrackArrowImage->bindTexture(0); + sTrackArrowImage->setClamp(TRUE, TRUE); + + image_id.set( gViewerArt.getString("icon_top_pick.tga") ); + sClassifiedsImage = gImageList.getImage(image_id, MIPMAP_FALSE, TRUE); + + image_id.set( gViewerArt.getString("icon_popular.tga") ); + sPopularImage = gImageList.getImage(image_id, MIPMAP_FALSE, TRUE); + + image_id.set( gViewerArt.getString("icon_for_sale.tga") ); + sForSaleImage = gImageList.getImage(image_id, MIPMAP_FALSE, TRUE); +} + +// static +void LLWorldMapView::cleanupClass() +{ + sAvatarYouSmallImage = NULL; + sAvatarSmallImage = NULL; + sAvatarLargeImage = NULL; + sTelehubImage = NULL; + sInfohubImage = NULL; + sHomeImage = NULL; + sEventImage = NULL; + sEventMatureImage = NULL; + sTrackCircleImage = NULL; + sTrackArrowImage = NULL; + sClassifiedsImage = NULL; + sPopularImage = 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), + mAgentCountsUpdateTime(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 ); + mTextBoxNorth->setDropshadowVisible( TRUE ); + 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 ); + + mTextBoxWest = new LLTextBox( "W", major_dir_rect ); + mTextBoxWest->setColor( minor_color ); + addChild( mTextBoxWest ); + + 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; + } +} + + +/////////////////////////////////////////////////////////////////////////////////// + +// dumb helper function +BOOL is_agent_in_region(LLViewerRegion* region, LLSimInfo* info) +{ + if((region && info) + && (info->mName == region->getName())) + { + return TRUE; + } + return FALSE; +} + +void LLWorldMapView::draw() +{ + if (!getVisible() || !gWorldPointer) + { + return; + } + + LLTextureView::clearDebugImages(); + + F64 current_time = LLTimer::getElapsedSeconds(); + + if (current_time - mAgentCountsUpdateTime > AGENT_COUNTS_UPDATE_TIME) + { + gWorldMap->sendItemRequest(MAP_ITEM_AGENT_COUNT); + mAgentCountsUpdateTime = current_time; + } + + mVisibleRegions.clear(); + + // animate pan if necessary + sPanX = lerp(sPanX, sTargetPanX, LLCriticalDamp::getInterpolant(0.1f)); + sPanY = lerp(sPanY, sTargetPanY, LLCriticalDamp::getInterpolant(0.1f)); + + LLVector3d pos_global; + LLVector3 pos_map; + + const S32 width = mRect.getWidth(); + const S32 height = mRect.getHeight(); + const S32 half_width = width / 2; + const S32 half_height = height / 2; + LLVector3d camera_global = gAgent.getCameraPositionGlobal(); + + LLGLEnable scissor_test(GL_SCISSOR_TEST); + LLUI::setScissorRegionLocal(LLRect(0, height, width, 0)); + { + LLGLSNoTexture no_texture; + + + glMatrixMode(GL_MODELVIEW); + + // Clear the background alpha to 0 + glColorMask(FALSE, FALSE, FALSE, TRUE); + glAlphaFunc(GL_GEQUAL, 0.00f); + glBlendFunc(GL_ONE, GL_ZERO); + glColor4f(0.0f, 0.0f, 0.0f, 0.0f); + gl_rect_2d(0, height, width, 0); + } + + glAlphaFunc(GL_GEQUAL, 0.01f); + glColorMask(TRUE, TRUE, TRUE, TRUE); + glBlendFunc(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<gWorldMap->mMapLayers[gWorldMap->mCurrentMap].size(); ++layer_idx) + { + if (!gWorldMap->mMapLayers[gWorldMap->mCurrentMap][layer_idx].LayerDefined) + { + continue; + } + LLWorldMapLayer *layer = &gWorldMap->mMapLayers[gWorldMap->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), llround(pix_height)); + +#if 1 || LL_RELEASE_FOR_DOWNLOAD + if (!current_image->getHasGLTexture()) + { + continue; // better to draw nothing than the default image + } +#endif + + 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 + //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glColorMask(TRUE, TRUE, TRUE, FALSE); + glColor4f(1.f, 1.f, 1.f, layer_alpha); + + glBegin(GL_QUADS); + glTexCoord2f(0.0f, 1.0f); + glVertex3f(left, top, -1.0f); + glTexCoord2f(0.0f, 0.0f); + glVertex3f(left, bottom, -1.0f); + glTexCoord2f(1.0f, 0.0f); + glVertex3f(right, bottom, -1.0f); + glTexCoord2f(1.0f, 1.0f); + glVertex3f(right, top, -1.0f); + glEnd(); + + // draw an alpha of 1 where the sims are visible + glColorMask(FALSE, FALSE, FALSE, TRUE); + glColor4f(1.f, 1.f, 1.f, 1.f); + + glBegin(GL_QUADS); + glTexCoord2f(0.0f, 1.0f); + glVertex2f(left, top); + glTexCoord2f(0.0f, 0.0f); + glVertex2f(left, bottom); + glTexCoord2f(1.0f, 0.0f); + glVertex2f(right, bottom); + glTexCoord2f(1.0f, 1.0f); + glVertex2f(right, top); + glEnd(); + } + + 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 = gWorldMap->mSimInfoMap.begin(); + it != gWorldMap->mSimInfoMap.end(); ++it) + { + U64 handle = (*it).first; + LLSimInfo* info = (*it).second; + + if (info->mCurrentImage.isNull()) + { + info->mCurrentImage = gImageList.getImage(info->mMapImageID[gWorldMap->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 < 8.f) + { + 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) + { + gWorldMap->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(draw_size, draw_size); + + if (overlayimage) + { + overlayimage->setBoostLevel(LLViewerImage::BOOST_MAP); + overlayimage->setKnownDrawSize(draw_size, draw_size); + } + + 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); + + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + F32 alpha = sim_alpha * info->mAlpha; + glColor4f(1.f, 1.0f, 1.0f, alpha); + + glBegin(GL_QUADS); + glTexCoord2f(0.f, 1.f); + glVertex3f(left, top, 0.f); + glTexCoord2f(0.f, 0.f); + glVertex3f(left, bottom, 0.f); + glTexCoord2f(1.f, 0.f); + glVertex3f(right, bottom, 0.f); + glTexCoord2f(1.f, 1.f); + glVertex3f(right, top, 0.f); + glEnd(); + + if (gSavedSettings.getBOOL("MapShowLandForSale") && overlayimage && overlayimage->getHasGLTexture()) + { + LLViewerImage::bindTexture(overlayimage); + glColor4f(1.f, 1.f, 1.f, alpha); + glBegin(GL_QUADS); + glTexCoord2f(0.f, 1.f); + glVertex3f(left, top, -0.5f); + glTexCoord2f(0.f, 0.f); + glVertex3f(left, bottom, -0.5f); + glTexCoord2f(1.f, 0.f); + glVertex3f(right, bottom, -0.5f); + glTexCoord2f(1.f, 1.f); + glVertex3f(right, top, -0.5f); + glEnd(); + } + + if ((info->mRegionFlags & REGION_FLAGS_NULL_LAYER) == 0) + { + // draw an alpha of 1 where the sims are visible (except NULL sims) + glBlendFunc(GL_ONE, GL_ZERO); + glColorMask(FALSE, FALSE, FALSE, TRUE); + glColor4f(1.f, 1.f, 1.f, 1.f); + + LLGLSNoTexture gls_no_texture; + glBegin(GL_QUADS); + glVertex2f(left, top); + glVertex2f(left, bottom); + glVertex2f(right, bottom); + glVertex2f(right, top); + glEnd(); + + glColorMask(TRUE, TRUE, TRUE, TRUE); + } + } + + if (info->mAccess == SIM_ACCESS_DOWN) + { + // Draw a transparent red square over down sims + glBlendFunc(GL_DST_ALPHA, GL_SRC_ALPHA); + glColor4f(0.2f, 0.0f, 0.0f, 0.4f); + + LLGLSNoTexture gls_no_texture; + glBegin(GL_QUADS); + glVertex2f(left, top); + glVertex2f(left, bottom); + glVertex2f(right, bottom); + glVertex2f(right, top); + glEnd(); + } + + // If this is mature, and you are not, draw a line across it + if (info->mAccess != SIM_ACCESS_DOWN && info->mAccess > gAgent.mAccess) + { + glBlendFunc(GL_DST_ALPHA, GL_ZERO); + + LLGLSNoTexture gls_no_texture; + glColor3f(1.f, 0.f, 0.f); + glBegin(GL_LINES); + glVertex2f(left, top); + glVertex2f(right, bottom); + glVertex2f(left, bottom); + glVertex2f(right, top); + glEnd(); + } + + // Draw the region name in the lower left corner + LLFontGL* font = LLFontGL::sSansSerifSmall; + + char mesg[MAX_STRING]; + 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) + { + sprintf(mesg, "%s (Offline)", info->mName.c_str()); + } + else + { + sprintf(mesg, "%s", info->mName.c_str()); + } + } + + 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); + glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA); + glColor4fv( mBackgroundColor.mV ); + gl_rect_2d(0, height, width, 0); + } + + glAlphaFunc(GL_GEQUAL, 0.01f); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + + // Infohubs + // Draw under avatar so you can find yourself. + if (gSavedSettings.getBOOL("MapShowInfohubs")) //(gMapScale >= sThresholdB) + { + S32 infohub_icon_size = (S32)sInfohubImage->getWidth(); + for (U32 infohub=0; infohub<gWorldMap->mInfohubs.size(); ++infohub) + { + LLItemInfo *infohub_info = &gWorldMap->mInfohubs[infohub]; + + pos_map = globalPosToView(infohub_info->mPosGlobal); + gl_draw_image(llround(pos_map.mV[VX])-infohub_icon_size/2, + llround(pos_map.mV[VY])-infohub_icon_size/2, + sInfohubImage, + LLColor4::white); + } + } + + // Telehubs + // Draw under avatar so you can find yourself. + if (gSavedSettings.getBOOL("MapShowTelehubs")) //(gMapScale >= sThresholdB) + { + S32 telehub_icon_size = (S32)sTelehubImage->getWidth(); + for (U32 telehub=0; telehub<gWorldMap->mTelehubs.size(); ++telehub) + { + LLItemInfo *telehub_info = &gWorldMap->mTelehubs[telehub]; + + pos_map = globalPosToView(telehub_info->mPosGlobal); + gl_draw_image(llround(pos_map.mV[VX])-telehub_icon_size/2, + llround(pos_map.mV[VY])-telehub_icon_size/2, + sTelehubImage, + LLColor4::white); + } + } + + // Home + // Always Draw + if (1) //(gMapScale >= sThresholdB) + { + S32 home_icon_size = (S32)sHomeImage->getWidth(); + if (gAgent.getHomePosGlobal(&pos_global)) + { + pos_map = globalPosToView(pos_global); + gl_draw_image(llround(pos_map.mV[VX])-home_icon_size/2, + llround(pos_map.mV[VY])-home_icon_size/2, + sHomeImage, + LLColor4::white); + } + } + + // Draw all these under the avatar, so you can find yourself + + if (gSavedSettings.getBOOL("MapShowLandForSale")) + { + drawGenericItems(gWorldMap->mLandForSale, sForSaleImage); + } + + if (gSavedSettings.getBOOL("MapShowClassifieds")) + { + drawGenericItems(gWorldMap->mClassifieds, sClassifiedsImage); + } + + if (gSavedSettings.getBOOL("MapShowPopular")) + { + drawGenericItems(gWorldMap->mPopular, sPopularImage); + } + + if (gSavedSettings.getBOOL("MapShowEvents")) + { + drawEvents(); + } + + // Your avatar. + // Draw avatar position, always, and underneath other avatars + pos_global = gAgent.getPositionGlobal(); + pos_map = globalPosToView(pos_global); + gl_draw_image(llround(pos_map.mV[VX])-8, + llround(pos_map.mV[VY])-8, + sAvatarLargeImage, + LLColor4::white); + + 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 + } + + drawFrustum(); + + // Draw icons for the avatars in each region. + // Draw after 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 (gWorldMap->mIsTrackingUnknownLocation) + { + if (gWorldMap->mInvalidLocation) + { + // We know this location to be invalid + LLColor4 loading_color(0.0, 0.5, 1.0, 1.0); + drawTracking( gWorldMap->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( gWorldMap->mUnknownLocation, loading_color, TRUE, "Loading...", ""); + } + } +#endif + + // turn off the scissor + LLGLDisable no_scissor(GL_SCISSOR_TEST); + + updateDirections(); + + LLView::draw(); + + updateVisibleBlocks(); +} + +void LLWorldMapView::drawGenericItems(const LLWorldMap::item_info_list_t& items, LLPointer<LLViewerImage> image) +{ + LLWorldMap::item_info_list_t::const_iterator e; + for (e = items.begin(); e != items.end(); ++e) + { + const LLItemInfo& info = *e; + + drawGenericItem(info, image); + } +} + +void LLWorldMapView::drawGenericItem(const LLItemInfo& item, LLPointer<LLViewerImage> image) +{ + S32 half_width = image->getWidth()/2; + S32 half_height = image->getHeight()/2; + + LLVector3 pos_map = globalPosToView( item.mPosGlobal ); + gl_draw_image(llround(pos_map.mV[VX]) - half_width, + llround(pos_map.mV[VY]) - half_height, + image, + LLColor4::white); +} + +void LLWorldMapView::drawAgents() +{ + //S32 half_width = sPopularImage->getWidth()/2; + //S32 half_height = sPopularImage->getHeight()/2; + + 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 = gWorldMap->simInfoFromHandle(handle); + if (siminfo && (siminfo->mAccess == SIM_ACCESS_DOWN)) + { + continue; + } + LLWorldMap::agent_list_map_t::iterator countsiter = gWorldMap->mAgentLocationsMap.find(handle); + if (siminfo && siminfo->mShowAgentLocations && countsiter != gWorldMap->mAgentLocationsMap.end()) + { + // Show Individual agents + LLWorldMap::item_info_list_t& agentcounts = countsiter->second; + S32 sim_agent_count = 0; + for (LLWorldMap::item_info_list_t::iterator iter = agentcounts.begin(); + iter != agentcounts.end(); ++iter) + { + const LLItemInfo& info = *iter; + LLVector3 pos_map = globalPosToView( info.mPosGlobal ); + S32 agent_count = info.mExtra; + if (agent_count > 0) + { + sim_agent_count += agent_count; + F32 y = 0; + for (S32 cur_agent = 0; cur_agent < agent_count; cur_agent++) + { + gl_draw_image(llround(pos_map.mV[VX]) - 4, + llround(pos_map.mV[VY] + y) - 4, + sAvatarSmallImage, + LLColor4::white ); + // move up a bit + y += 3.f; + } + } + } + gWorldMap->mNumAgents[handle] = sim_agent_count; // override mNumAgents for this sim + } + else + { + // Show agent 'stack' at center of sim + S32 num_agents = gWorldMap->mNumAgents[handle]; + if (num_agents > 0) + { + LLVector3d region_pos = from_region_handle(handle); + region_pos[VX] += REGION_WIDTH_METERS * .5f; + region_pos[VY] += REGION_WIDTH_METERS * .5f; + LLVector3 pos_map = globalPosToView(region_pos); + // 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; + S32 y = 0; + S32 cur_agent; + for (cur_agent = 0; cur_agent < agent_count; cur_agent++) + { + gl_draw_image( + llround(pos_map.mV[VX]) - 4, + llround(pos_map.mV[VY]) + y - 4, + sAvatarSmallImage, + LLColor4::white ); + // move up a bit + y += 3; + } + } + } + } +} + + +void LLWorldMapView::drawEvents() +{ + BOOL show_mature = gSavedSettings.getBOOL("ShowMatureEvents"); + + // Non-selected events + // Draw under avatar so you can find yourself. + LLWorldMap::item_info_list_t::const_iterator e; + for (e = gWorldMap->mPGEvents.begin(); e != gWorldMap->mPGEvents.end(); ++e) + { + const LLItemInfo& event = *e; + + // Draw, but without relative-Z icons + if (!event.mSelected) + { + LLVector3 pos_map = globalPosToView( event.mPosGlobal ); + gl_draw_image(llround(pos_map.mV[VX]) - sEventImage->getWidth()/2, + llround(pos_map.mV[VY]) - sEventImage->getHeight()/2, + sEventImage, + LLColor4::white); + } + } + if (show_mature) + { + for (e = gWorldMap->mMatureEvents.begin(); e != gWorldMap->mMatureEvents.end(); ++e) + { + const LLItemInfo& event = *e; + + // Draw, but without relative-Z icons + if (!event.mSelected) + { + LLVector3 pos_map = globalPosToView( event.mPosGlobal ); + gl_draw_image(llround(pos_map.mV[VX]) - sEventMatureImage->getWidth()/2, + llround(pos_map.mV[VY]) - sEventMatureImage->getHeight()/2, + sEventMatureImage, + LLColor4::white); + } + } + } + + // Selected events + // Draw under avatar so you can find yourself. + for (e = gWorldMap->mPGEvents.begin(); e != gWorldMap->mPGEvents.end(); ++e) + { + const LLItemInfo& event = *e; + + // Draw, but without relative-Z icons + if (event.mSelected) + { + LLVector3 pos_map = globalPosToView( event.mPosGlobal ); + gl_draw_image(llround(pos_map.mV[VX]) - sEventImage->getWidth()/2, + llround(pos_map.mV[VY]) - sEventImage->getHeight()/2, + sEventImage, + LLColor4::white); + + //drawIconName( + // pos_map.mV[VX], + // pos_map.mV[VY], + // gEventColor, + // event.mToolTip.c_str(), + // event.mName.c_str() ); + } + } + if (show_mature) + { + for (e = gWorldMap->mMatureEvents.begin(); e != gWorldMap->mMatureEvents.end(); ++e) + { + const LLItemInfo& event = *e; + + // Draw, but without relative-Z icons + if (event.mSelected) + { + LLVector3 pos_map = globalPosToView( event.mPosGlobal ); + gl_draw_image(llround(pos_map.mV[VX]) - sEventMatureImage->getWidth()/2, + llround(pos_map.mV[VY]) - sEventMatureImage->getHeight()/2, + sEventMatureImage, + LLColor4::white); + + //drawIconName( + // pos_map.mV[VX], + // pos_map.mV[VY], + // gEventColor, + // event.mToolTip.c_str(), + // event.mName.c_str() ); + } + } + } +} + +void LLWorldMapView::drawDots() +{ + +} + + +void LLWorldMapView::drawFrustum() +{ + // Draw frustum + F32 meters_to_pixels = gMapScale/ REGION_WIDTH_METERS; + + F32 horiz_fov = gCamera->getView() * gCamera->getAspect(); + F32 far_clip_meters = gCamera->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 = mRect.getWidth() * 0.5f + sPanX; + F32 ctr_y = mRect.getHeight() * 0.5f + sPanY; + + LLGLSNoTexture gls_no_texture; + + // Since we don't rotate the map, we have to rotate the frustum. + glPushMatrix(); + glTranslatef( ctr_x, ctr_y, 0 ); + glRotatef( atan2( gCamera->getAtAxis().mV[VX], gCamera->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. + glBegin( GL_TRIANGLES ); + glColor4f(1.f, 1.f, 1.f, 0.25f); + glVertex2f( 0, 0 ); + + glColor4f(1.f, 1.f, 1.f, 0.02f); + glVertex2f( -half_width_pixels, far_clip_pixels ); + + glColor4f(1.f, 1.f, 1.f, 0.02f); + glVertex2f( half_width_pixels, far_clip_pixels ); + glEnd(); + glPopMatrix(); +} + + +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] += mRect.getWidth() / 2 + sPanX; + pos_local.mV[VY] += mRect.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 >= mRect.getWidth() + || y >= mRect.getHeight() ) + { + if (draw_arrow) + { + drawTrackingCircle( mRect, x, y, color, 3, 15 ); + drawTrackingArrow( mRect, 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( mRect, x, y, color, 3, 15 ); + } + else + { + // Draw, but without relative Z + gl_draw_image(x - sTrackCircleImage->getWidth()/2, + y - sTrackCircleImage->getHeight()/2, + 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, mRect.getWidth() - half_text_width - TEXT_PADDING); + text_y = llclamp(text_y + vert_offset, TEXT_PADDING + vert_offset, mRect.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((mRect.getWidth() / 2 + sPanX)); + y -= llfloor((mRect.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 ) +{ + if( !getVisible() || !pointInView( x, y ) ) + { + return FALSE; + } + + LLVector3d pos_global = viewPosToGlobal(x, y); + + LLSimInfo* info = gWorldMap->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 = gWorldMap->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 +void LLWorldMapView::drawAvatar(F32 x_pixels, + F32 y_pixels, + const LLColor4& color, + F32 relative_z, + F32 dot_radius) +{ + 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; + + const F32 HEIGHT_THRESHOLD = 7.f; + + if (relative_z > HEIGHT_THRESHOLD) + { + LLGLSNoTexture gls_no_texture; + glColor4fv( color.mV ); + LLUI::setLineWidth(1.5f); + glBegin( GL_LINES ); + glVertex2f(left, top); + glVertex2f(right, top); + glVertex2f(center, top); + glVertex2f(center, bottom); + glEnd(); + LLUI::setLineWidth(1.0f); + } + else if (relative_z > -HEIGHT_THRESHOLD) + { + gl_draw_image( llround(x_pixels) - sAvatarSmallImage->getWidth()/2, + llround(y_pixels) - sAvatarSmallImage->getHeight()/2, + sAvatarSmallImage, + color); + } + else + { + LLGLSNoTexture gls_no_texture; + glColor4fv( color.mV ); + LLUI::setLineWidth(1.5f); + glBegin( GL_LINES ); + glVertex2f(center, top); + glVertex2f(center, bottom); + glVertex2f(left, bottom); + glVertex2f(right, bottom); + glEnd(); + LLUI::setLineWidth(1.0f); + } +} + +// 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) +{ + 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; + + const F32 HEIGHT_THRESHOLD = 7.f; + + if (relative_z > HEIGHT_THRESHOLD) + { + LLGLSNoTexture gls_no_texture; + glColor4fv( color.mV ); + LLUI::setLineWidth(1.5f); + glBegin( GL_LINES ); + glVertex2f(left, top); + glVertex2f(right, top); + glVertex2f(center, top); + glVertex2f(center, bottom); + glEnd(); + LLUI::setLineWidth(1.0f); + } + else if (relative_z > -HEIGHT_THRESHOLD) + { + gl_draw_image( llround(x_pixels) - sAvatarSmallImage->getWidth()/2, + llround(y_pixels) - sAvatarSmallImage->getHeight()/2, + sTrackCircleImage, + color); + } + else + { + LLGLSNoTexture gls_no_texture; + glColor4fv( color.mV ); + LLUI::setLineWidth(1.5f); + glBegin( GL_LINES ); + glVertex2f(center, top); + glVertex2f(center, bottom); + glVertex2f(left, bottom); + glVertex2f(right, bottom); + glEnd(); + LLUI::setLineWidth(1.0f); + } +} + + +// 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); + glPushMatrix(); + glTranslatef((F32)x, (F32)y, 0.f); + gl_washer_segment_2d(inner_radius, outer_radius, start_theta, end_theta, 40, color, color); + glPopMatrix(); + +} + +// 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) ); + } + + //FIXME: deal with non-square window properly + 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, + 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 = mRect.getHeight() * 0.5f; + F32 map_half_width = mRect.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 = mRect.getWidth(); + S32 height = mRect.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 = gWorldMap->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 kt. + if(gAgent.isGodlike()) + { + pos_global.mdV[VZ] = 200.0; + } + + *hit_type = 0; // hit nothing + + gWorldMap->mIsTrackingUnknownLocation = FALSE; + gWorldMap->mIsTrackingDoubleClick = FALSE; + gWorldMap->mIsTrackingCommit = FALSE; + + LLWorldMap::item_info_list_t::iterator it; + + // clear old selected stuff + for (it = gWorldMap->mPGEvents.begin(); it != gWorldMap->mPGEvents.end(); ++it) + { + (*it).mSelected = FALSE; + } + for (it = gWorldMap->mMatureEvents.begin(); it != gWorldMap->mMatureEvents.end(); ++it) + { + (*it).mSelected = FALSE; + } + for (it = gWorldMap->mPopular.begin(); it != gWorldMap->mPopular.end(); ++it) + { + (*it).mSelected = FALSE; + } + for (it = gWorldMap->mLandForSale.begin(); it != gWorldMap->mLandForSale.end(); ++it) + { + (*it).mSelected = FALSE; + } + for (it = gWorldMap->mClassifieds.begin(); it != gWorldMap->mClassifieds.end(); ++it) + { + (*it).mSelected = FALSE; + } + + // Select event you clicked on + if (gSavedSettings.getBOOL("MapShowEvents")) + { + for (it = gWorldMap->mPGEvents.begin(); it != gWorldMap->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 = gWorldMap->mMatureEvents.begin(); it != gWorldMap->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("MapShowPopular")) + { + for (it = gWorldMap->mPopular.begin(); it != gWorldMap->mPopular.end(); ++it) + { + LLItemInfo& popular = *it; + + if (checkItemHit(x, y, popular, id, true)) + { + *hit_type = MAP_ITEM_POPULAR; + mItemPicked = TRUE; + return; + } + } + } + + if (gSavedSettings.getBOOL("MapShowLandForSale")) + { + for (it = gWorldMap->mLandForSale.begin(); it != gWorldMap->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 = gWorldMap->mClassifieds.begin(); it != gWorldMap->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, NULL ); + + mMouseDownPanX = llround(sPanX); + mMouseDownPanY = llround(sPanY); + mMouseDownX = x; + mMouseDownY = y; + sHandledLastClick = TRUE; + return TRUE; +} + +BOOL LLWorldMapView::handleMouseUp( S32 x, S32 y, MASK mask ) +{ + if (this == gFocusMgr.getMouseCapture()) + { + 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 = mRect; + 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, NULL ); + return TRUE; + } + return FALSE; +} + +void LLWorldMapView::updateBlock(S32 block_x, S32 block_y) +{ + S32 offset = block_x | (block_y * MAP_BLOCK_RES); + if (!gWorldMap->mMapBlockLoaded[gWorldMap->mCurrentMap][offset]) + { +// llinfos << "Loading Block (" << block_x << "," << block_y << ")" << llendl; + gWorldMap->sendMapBlockRequest(block_x << 3, block_y << 3, (block_x << 3) + 7, (block_y << 3) + 7); + gWorldMap->mMapBlockLoaded[gWorldMap->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 (this == gFocusMgr.getMouseCapture()) + { + 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]; + S32 event_id; + id.toString(uuid_str); + sscanf(&uuid_str[28], "%X", &event_id); + LLFloaterDirectory::showEvents(event_id); + break; + } + case MAP_ITEM_POPULAR: + { + gFloaterWorldMap->close(); + LLFloaterDirectory::showPopular(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 (gWorldMap->mIsTrackingUnknownLocation) + { + gWorldMap->mIsTrackingDoubleClick = TRUE; + } + else + { + // Teleport if we got a valid location + LLVector3d pos_global = viewPosToGlobal(x,y); + LLSimInfo* sim_info = gWorldMap->simInfoFromPosGlobal(pos_global); + if (sim_info && sim_info->mAccess != SIM_ACCESS_DOWN) + { + gAgent.teleportViaLocation( pos_global ); + } + } + } + }; + + return TRUE; + } + return FALSE; +} |