1 files changed, 241 insertions, 122 deletions

diff --git a/linden/indra/newview/llviewerwindow.cpp b/linden/indra/newview/llviewerwindow.cpp
index 854d757..017c225 100644
--- a/linden/indra/newview/llviewerwindow.cpp
+++ b/linden/indra/newview/llviewerwindow.cpp
@@ -4,7 +4,7 @@
  *
  * $LicenseInfo:firstyear=2001&license=viewergpl$
  * 
- * Copyright (c) 2001-2008, Linden Research, Inc.
+ * Copyright (c) 2001-2009, Linden Research, Inc.
  * 
  * Second Life Viewer Source Code
  * The source code in this file ("Source Code") is provided by Linden Lab
@@ -29,13 +29,13 @@
  * $/LicenseInfo$
  */
 
+#include "llviewerprecompiledheaders.h"
+
 // system library includes
 #include <stdio.h>
 #include <iostream>
 #include <fstream>
 
-#include "llviewerprecompiledheaders.h"
-
 #include "llpanellogin.h"
 #include "llviewerkeyboard.h"
 #include "llviewerwindow.h"
@@ -168,6 +168,7 @@
 #include "llviewerobjectlist.h"
 #include "llviewerparcelmgr.h"
 #include "llviewerregion.h"
+#include "llviewershadermgr.h"
 #include "llviewerstats.h"
 #include "llvoavatar.h"
 #include "llvovolume.h"
@@ -180,9 +181,9 @@
 #include "llspatialpartition.h"
 #include "llviewerjoystick.h"
 #include "llviewernetwork.h"
+#include "llpostprocess.h"
 
 #if LL_WINDOWS
-#include "llwindebug.h"
 #include <tchar.h> // For Unicode conversion methods
 #endif
 
@@ -218,6 +219,7 @@ LLVector3       gDebugRaycastIntersection;
 LLVector2       gDebugRaycastTexCoord;
 LLVector3       gDebugRaycastNormal;
 LLVector3       gDebugRaycastBinormal;
+S32                             gDebugRaycastFaceHit;
 
 // HUD display lines in lower right
 BOOL                            gDisplayWindInfo = FALSE;
@@ -916,7 +918,7 @@ BOOL LLViewerWindow::handleRightMouseDown(LLWindow *window,  LLCoordGL pos, MASK
 
         // *HACK: this should be rolled into the composite tool logic, not
         // hardcoded at the top level.
-        if (CAMERA_MODE_CUSTOMIZE_AVATAR != gAgent.getCameraMode())
+        if (CAMERA_MODE_CUSTOMIZE_AVATAR != gAgent.getCameraMode() && LLToolMgr::getInstance()->getCurrentTool() != LLToolPie::getInstance())
         {
                 // If the current tool didn't process the click, we should show
                 // the pie menu.  This can be done by passing the event to the pie
@@ -1102,6 +1104,7 @@ void LLViewerWindow::handleQuit(LLWindow *window)
 void LLViewerWindow::handleResize(LLWindow *window,  S32 width,  S32 height)
 {
         reshape(width, height);
+        mResDirty = true;
 }
 
 // The top-level window has gained focus (e.g. via ALT-TAB)
@@ -1258,6 +1261,8 @@ BOOL LLViewerWindow::handleActivate(LLWindow *window, BOOL activated)
 
 BOOL LLViewerWindow::handleActivateApp(LLWindow *window, BOOL activating)
 {
+        //if (!activating) gAgent.changeCameraToDefault();
+
         LLViewerJoystick::getInstance()->setNeedsReset(true);
         return FALSE;
 }
@@ -1410,7 +1415,11 @@ LLViewerWindow::LLViewerWindow(
         mHideCursorPermanent( FALSE ),
         mCursorHidden(FALSE),
         mIgnoreActivate( FALSE ),
-        mHoverPick()
+        mHoverPick(),
+        mResDirty(false),
+        mStatesDirty(false),
+        mIsFullscreenChecked(false),
+        mCurrResolutionIndex(0)
 {
         // Default to application directory.
         LLViewerWindow::sSnapshotBaseName = "Snapshot";
@@ -1426,12 +1435,12 @@ LLViewerWindow::LLViewerWindow(
                 !gNoRender,
                 ignore_pixel_depth,
                 gSavedSettings.getU32("RenderFSAASamples"));
-#if LL_WINDOWS
-        if (!LLWinDebug::checkExceptionHandler())
+
+        if (!LLAppViewer::instance()->restoreErrorTrap())
         {
-                LL_WARNS("Window") << " Someone took over my exception handler (post createWindow)!" << LL_ENDL;
+                LL_WARNS("Window") << " Someone took over my signal/exception handler (post createWindow)!" << LL_ENDL;
         }
-#endif
+
 
         if (NULL == mWindow)
         {
@@ -1545,7 +1554,7 @@ void LLViewerWindow::initGLDefaults()
         glPixelStorei(GL_PACK_ALIGNMENT,1);
         glPixelStorei(GL_UNPACK_ALIGNMENT,1);
 
-        glEnable(GL_TEXTURE_2D);
+        gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
 
         // lights for objects
         glShadeModel( GL_SMOOTH );
@@ -2089,12 +2098,7 @@ void LLViewerWindow::reshape(S32 width, S32 height)
                 gSavedSettings.setBOOL("FullScreen", mWantFullscreen);
 
                 // store new settings for the mode we are in, regardless
-                if (mWindow->getFullscreen())
-                {
-                        gSavedSettings.setS32("FullScreenWidth", width);
-                        gSavedSettings.setS32("FullScreenHeight", height);
-                }
-                else
+                if (!mWindow->getFullscreen())
                 {
                         // Only save size if not maximized
                         BOOL maximized = mWindow->getMaximized();
@@ -3042,8 +3046,9 @@ BOOL LLViewerWindow::handlePerFrameHover()
 
         if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_RAYCAST))
         {
-                gDebugRaycastObject = cursorIntersect(-1, -1, 512.f, NULL, -1,
-                                                                                          NULL,
+                gDebugRaycastFaceHit = -1;
+                gDebugRaycastObject = cursorIntersect(-1, -1, 512.f, NULL, -1, FALSE,
+                                                                                          &gDebugRaycastFaceHit,
                                                                                           &gDebugRaycastIntersection,
                                                                                           &gDebugRaycastTexCoord,
                                                                                           &gDebugRaycastNormal,
@@ -3184,7 +3189,7 @@ void LLViewerWindow::renderSelections( BOOL for_gl_pick, BOOL pick_parcel_walls,
                 // Render light for editing
                 if (LLSelectMgr::sRenderLightRadius && LLToolMgr::getInstance()->inEdit())
                 {
-                        LLImageGL::unbindTexture(0);
+                        gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
                         LLGLEnable gls_blend(GL_BLEND);
                         LLGLEnable gls_cull(GL_CULL_FACE);
                         LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
@@ -3398,7 +3403,7 @@ void LLViewerWindow::schedulePick(LLPickInfo& pick_info)
         llassert_always(pick_info.mScreenRegion.notNull());
         mPicks.push_back(pick_info);
         
-        S32 scaled_x = llround((F32)pick_info.mMousePt.mX * mDisplayScale.mV[VX]);
+        /*S32 scaled_x = llround((F32)pick_info.mMousePt.mX * mDisplayScale.mV[VX]);
         S32 scaled_y = llround((F32)pick_info.mMousePt.mY * mDisplayScale.mV[VY]);
 
         // Default to not hitting anything
@@ -3467,7 +3472,7 @@ void LLViewerWindow::schedulePick(LLPickInfo& pick_info)
 
         setup3DRender();
         setup2DRender();
-        setupViewport();
+        setupViewport();*/
 
         // delay further event processing until we receive results of pick
         mWindow->delayInputProcessing();
@@ -3526,9 +3531,33 @@ LLPickInfo LLViewerWindow::pickImmediate(S32 x, S32 y_from_bot,  BOOL pick_trans
         return mLastPick;
 }
 
+LLHUDIcon* LLViewerWindow::cursorIntersectIcon(S32 mouse_x, S32 mouse_y, F32 depth,
+                                                                                   LLVector3* intersection)
+{
+        S32 x = mouse_x;
+        S32 y = mouse_y;
+
+        if ((mouse_x == -1) && (mouse_y == -1)) // use current mouse position
+        {
+                x = getCurrentMouseX();
+                y = getCurrentMouseY();
+        }
+
+        // world coordinates of mouse
+        LLVector3 mouse_direction_global = mouseDirectionGlobal(x,y);
+        LLVector3 mouse_point_global = LLViewerCamera::getInstance()->getOrigin();
+        LLVector3 mouse_world_start = mouse_point_global;
+        LLVector3 mouse_world_end   = mouse_point_global + mouse_direction_global * depth;
+
+        return LLHUDIcon::lineSegmentIntersectAll(mouse_world_start, mouse_world_end, intersection);
+
+        
+}
+
 LLViewerObject* LLViewerWindow::cursorIntersect(S32 mouse_x, S32 mouse_y, F32 depth,
                                                                                                 LLViewerObject *this_object,
                                                                                                 S32 this_face,
+                                                                                                BOOL pick_transparent,
                                                                                                 S32* face_hit,
                                                                                                 LLVector3 *intersection,
                                                                                                 LLVector2 *uv,
@@ -3550,8 +3579,18 @@ LLViewerObject* LLViewerWindow::cursorIntersect(S32 mouse_x, S32 mouse_y, F32 de
         LLVector3 mouse_hud_end   = mouse_point_hud + LLVector3(depth, 0, 0);
         
         // world coordinates of mouse
-        LLVector3               mouse_direction_global = mouseDirectionGlobal(x,y);
+        LLVector3 mouse_direction_global = mouseDirectionGlobal(x,y);
         LLVector3 mouse_point_global = LLViewerCamera::getInstance()->getOrigin();
+        
+        //get near clip plane
+        LLVector3 n = LLViewerCamera::getInstance()->getAtAxis();
+        LLVector3 p = mouse_point_global + n * LLViewerCamera::getInstance()->getNear();
+
+        //project mouse point onto plane
+        LLVector3 pos;
+        line_plane(mouse_point_global, mouse_direction_global, p, n, pos);
+        mouse_point_global = pos;
+
         LLVector3 mouse_world_start = mouse_point_global;
         LLVector3 mouse_world_end   = mouse_point_global + mouse_direction_global * depth;
 
@@ -3562,7 +3601,7 @@ LLViewerObject* LLViewerWindow::cursorIntersect(S32 mouse_x, S32 mouse_y, F32 de
         {
                 if (this_object->isHUDAttachment()) // is a HUD object?
                 {
-                        if (this_object->lineSegmentIntersect(mouse_hud_start, mouse_hud_end, this_face,
+                        if (this_object->lineSegmentIntersect(mouse_hud_start, mouse_hud_end, this_face, pick_transparent,
                                                                                                   face_hit, intersection, uv, normal, binormal))
                         {
                                 found = this_object;
@@ -3571,7 +3610,7 @@ LLViewerObject* LLViewerWindow::cursorIntersect(S32 mouse_x, S32 mouse_y, F32 de
                 
                 else // is a world object
                 {
-                        if (this_object->lineSegmentIntersect(mouse_world_start, mouse_world_end, this_face,
+                        if (this_object->lineSegmentIntersect(mouse_world_start, mouse_world_end, this_face, pick_transparent,
                                                                                                   face_hit, intersection, uv, normal, binormal))
                         {
                                 found = this_object;
@@ -3581,13 +3620,13 @@ LLViewerObject* LLViewerWindow::cursorIntersect(S32 mouse_x, S32 mouse_y, F32 de
 
         else // check ALL objects
                         {
-                found = gPipeline.lineSegmentIntersectInHUD(mouse_hud_start, mouse_hud_end,
+                found = gPipeline.lineSegmentIntersectInHUD(mouse_hud_start, mouse_hud_end, pick_transparent,
                                                                                                         face_hit, intersection, uv, normal, binormal);
 
                 if (!found) // if not found in HUD, look in world:
 
                         {
-                        found = gPipeline.lineSegmentIntersectInWorld(mouse_world_start, mouse_world_end,
+                        found = gPipeline.lineSegmentIntersectInWorld(mouse_world_start, mouse_world_end, pick_transparent,
                                                                                                                   face_hit, intersection, uv, normal, binormal);
                         }
 
@@ -3634,7 +3673,7 @@ LLVector3 LLViewerWindow::mousePointHUD(const S32 x, const S32 y) const
         F32 hud_x = -((F32)x - (F32)width/2.f)  / height;
         F32 hud_y = ((F32)y - (F32)height/2.f) / height;
 
-        return LLVector3(0.f, hud_x, hud_y);
+        return LLVector3(0.f, hud_x/gAgent.mHUDCurZoom, hud_y/gAgent.mHUDCurZoom);
 }
 
 // Returns unit vector relative to camera in camera space
@@ -3811,9 +3850,8 @@ BOOL LLViewerWindow::saveImageNumbered(LLImageFormatted *image)
                 return FALSE;
         }
 
-        std::string extension("." + image->getExtension());
-
         LLFilePicker::ESaveFilter pick_type;
+        std::string extension("." + image->getExtension());
         if (extension == ".j2c")
                 pick_type = LLFilePicker::FFSAVE_J2C;
         else if (extension == ".bmp")
@@ -3831,7 +3869,8 @@ BOOL LLViewerWindow::saveImageNumbered(LLImageFormatted *image)
         if ( ! isSnapshotLocSet())              
         {
                 std::string proposed_name( sSnapshotBaseName );
-                proposed_name.append( extension );
+
+                // getSaveFile will append an appropriate extension to the proposed name, based on the ESaveFilter constant passed in.
 
                 // pick a directory in which to save
                 LLFilePicker& picker = LLFilePicker::instance();
@@ -4148,7 +4187,7 @@ BOOL LLViewerWindow::rawSnapshot(LLImageRaw *raw, S32 image_width, S32 image_hei
                                         
                                         snapshot_width = image_width;
                                         snapshot_height = image_height;
-                                        target.allocate(snapshot_width, snapshot_height, GL_RGBA, TRUE, GL_TEXTURE_RECTANGLE_ARB, TRUE);
+                                        target.allocate(snapshot_width, snapshot_height, GL_RGBA, TRUE, LLTexUnit::TT_RECT_TEXTURE, TRUE);
                                         window_width = snapshot_width;
                                         window_height = snapshot_height;
                                         scale_factor = 1.f;
@@ -4376,7 +4415,7 @@ void LLViewerWindow::drawMouselookInstructions()
                 llround(font->getLineHeight() + 2 * INSTRUCTIONS_PAD));
 
         {
-                LLGLSNoTexture gls_no_texture;
+                gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
                 gGL.color4f( 0.9f, 0.9f, 0.9f, 1.0f );
                 gl_rect_2d( instructions_rect );
         }
@@ -4502,6 +4541,10 @@ void LLViewerWindow::dumpState()
 
 void LLViewerWindow::stopGL(BOOL save_state)
 {
+        //Note: --bao
+        //if not necessary, do not change the order of the function calls in this function.
+        //if change something, make sure it will not break anything.
+        //especially be careful to put anything behind gImageList.destroyGL(save_state);
         if (!gGLManager.mIsDisabled)
         {
                 llinfos << "Shutting down GL..." << llendl;
@@ -4510,12 +4553,12 @@ void LLViewerWindow::stopGL(BOOL save_state)
                 LLAppViewer::getTextureCache()->pause();
                 LLAppViewer::getImageDecodeThread()->pause();
                 LLAppViewer::getTextureFetch()->pause();
-                
+                                
                 gSky.destroyGL();
-                stop_glerror();
-        
-                gImageList.destroyGL(save_state);
-                stop_glerror();
+                stop_glerror();         
+
+                LLManipTranslate::destroyGL() ;
+                stop_glerror();         
 
                 gBumpImageList.destroyGL();
                 stop_glerror();
@@ -4539,6 +4582,14 @@ void LLViewerWindow::stopGL(BOOL save_state)
                 gSphere.cleanupGL();
                 gCylinder.cleanupGL();
                 
+                if(gPostProcess)
+                {
+                        gPostProcess->invalidate();
+                }
+
+                gImageList.destroyGL(save_state);
+                stop_glerror();
+
                 gGLManager.mIsDisabled = TRUE;
                 stop_glerror();
                 
@@ -4548,25 +4599,32 @@ void LLViewerWindow::stopGL(BOOL save_state)
 
 void LLViewerWindow::restoreGL(const std::string& progress_message)
 {
+        //Note: --bao
+        //if not necessary, do not change the order of the function calls in this function.
+        //if change something, make sure it will not break anything. 
+        //especially, be careful to put something before gImageList.restoreGL();
         if (gGLManager.mIsDisabled)
         {
                 llinfos << "Restoring GL..." << llendl;
                 gGLManager.mIsDisabled = FALSE;
+                
+                initGLDefaults();
+                LLGLState::restoreGL();
+                gImageList.restoreGL();
 
                 // for future support of non-square pixels, and fonts that are properly stretched
                 //LLFontGL::destroyDefaultFonts();
                 initFonts();
-                initGLDefaults();
-                LLGLState::restoreGL();
+                                
                 gSky.restoreGL();
                 gPipeline.restoreGL();
                 LLDrawPoolWater::restoreGL();
                 LLManipTranslate::restoreGL();
-                gImageList.restoreGL();
+                
                 gBumpImageList.restoreGL();
                 LLDynamicTexture::restoreGL();
                 LLVOAvatar::restoreGL();
-
+                
                 gResizeScreenTexture = TRUE;
 
                 if (gFloaterCustomize && gFloaterCustomize->getVisible())
@@ -4582,12 +4640,10 @@ void LLViewerWindow::restoreGL(const std::string& progress_message)
                         setProgressString(progress_message);
                 }
                 llinfos << "...Restoring GL done" << llendl;
-#if LL_WINDOWS
-                if(!LLWinDebug::checkExceptionHandler())
+                if(!LLAppViewer::instance()->restoreErrorTrap())
                 {
-                        llwarns << " Someone took over my exception handler (post restoreGL)!" << llendl;
+                        llwarns << " Someone took over my signal/exception handler (post restoreGL)!" << llendl;
                 }
-#endif
 
         }
 }
@@ -4617,6 +4673,7 @@ void LLViewerWindow::toggleFullscreen(BOOL show_progress)
         if (mWindow)
         {
                 mWantFullscreen = mWindow->getFullscreen() ? FALSE : TRUE;
+                mIsFullscreenChecked =  mWindow->getFullscreen() ? FALSE : TRUE;
                 mShowFullscreenProgress = show_progress;
         }
 }
@@ -4643,37 +4700,89 @@ void LLViewerWindow::getTargetWindow(BOOL& fullscreen, S32& width, S32& height)
         }
 }
 
+void LLViewerWindow::requestResolutionUpdate(bool fullscreen_checked)
+{
+        mResDirty = true;
+        mWantFullscreen = fullscreen_checked;
+        mIsFullscreenChecked = fullscreen_checked;
+}
 
 BOOL LLViewerWindow::checkSettings()
 {
-        BOOL is_fullscreen = mWindow->getFullscreen();
-        if (is_fullscreen && !mWantFullscreen)
+        if (mStatesDirty)
         {
-                changeDisplaySettings(FALSE, 
-                                                          LLCoordScreen(gSavedSettings.getS32("WindowWidth"),
-                                                                                        gSavedSettings.getS32("WindowHeight")),
-                                                          TRUE,
-                                                          mShowFullscreenProgress);
-                return TRUE;
+                gGL.refreshState();
+                LLViewerShaderMgr::instance()->setShaders();
+                mStatesDirty = false;
         }
-        else if (!is_fullscreen && mWantFullscreen)
+        
+        // We want to update the resolution AFTER the states getting refreshed not before.
+        if (mResDirty)
         {
-                if (!LLStartUp::canGoFullscreen())
+                if (gSavedSettings.getBOOL("FullScreenAutoDetectAspectRatio"))
                 {
-                        return FALSE;
+                        getWindow()->setNativeAspectRatio(0.f);
+                }
+                else
+                {
+                        getWindow()->setNativeAspectRatio(gSavedSettings.getF32("FullScreenAspectRatio"));
                 }
                 
-                LLGLState::checkStates();
-                LLGLState::checkTextureChannels();
-                changeDisplaySettings(TRUE, 
-                                                          LLCoordScreen(gSavedSettings.getS32("FullScreenWidth"),
-                                                                                        gSavedSettings.getS32("FullScreenHeight")),
-                                                          gSavedSettings.getBOOL("DisableVerticalSync"),
-                                                          mShowFullscreenProgress);
-
-                LLGLState::checkStates();
-                LLGLState::checkTextureChannels();
-                return TRUE;
+                reshape(getWindowDisplayWidth(), getWindowDisplayHeight());
+
+                // force aspect ratio
+                if (mIsFullscreenChecked)
+                {
+                        LLViewerCamera::getInstance()->setAspect( getDisplayAspectRatio() );
+                }
+
+                mResDirty = false;
+                // This will force a state update the next frame.
+                mStatesDirty = true;
+        }
+                
+        BOOL is_fullscreen = mWindow->getFullscreen();
+        if(mWantFullscreen)
+        {
+                LLCoordScreen screen_size;
+                LLCoordScreen desired_screen_size(gSavedSettings.getS32("FullScreenWidth"),
+                                                                   gSavedSettings.getS32("FullScreenHeight"));
+                getWindow()->getSize(&screen_size);
+                if(!is_fullscreen || 
+                    screen_size.mX != desired_screen_size.mX 
+                        || screen_size.mY != desired_screen_size.mY)
+                {
+                        if (!LLStartUp::canGoFullscreen())
+                        {
+                                return FALSE;
+                        }
+                        
+                        LLGLState::checkStates();
+                        LLGLState::checkTextureChannels();
+                        changeDisplaySettings(TRUE, 
+                                                                  desired_screen_size,
+                                                                  gSavedSettings.getBOOL("DisableVerticalSync"),
+                                                                  mShowFullscreenProgress);
+
+                        LLGLState::checkStates();
+                        LLGLState::checkTextureChannels();
+                        mStatesDirty = true;
+                        return TRUE;
+                }
+        }
+        else
+        {
+                if(is_fullscreen)
+                {
+                        // Changing to windowed mode.
+                        changeDisplaySettings(FALSE, 
+                                                                  LLCoordScreen(gSavedSettings.getS32("WindowWidth"),
+                                                                                                gSavedSettings.getS32("WindowHeight")),
+                                                                  TRUE,
+                                                                  mShowFullscreenProgress);
+                        mStatesDirty = true;
+                        return TRUE;
+                }
         }
         return FALSE;
 }
@@ -4704,13 +4813,9 @@ BOOL LLViewerWindow::changeDisplaySettings(BOOL fullscreen, LLCoordScreen size,
         BOOL old_fullscreen = mWindow->getFullscreen();
         if (!old_fullscreen && fullscreen && !LLStartUp::canGoFullscreen())
         {
-                // we can't do this now, so do it later
-                
-                gSavedSettings.setS32("FullScreenWidth", size.mX);
-                gSavedSettings.setS32("FullScreenHeight", size.mY);
-                //gSavedSettings.setBOOL("DisableVerticalSync", disable_vsync);
-                
-                return TRUE;    // a lie..., because we'll get to it later
+                // Not allowed to switch to fullscreen now, so exit early.
+                // *NOTE: This case should never be reached, but just-in-case.
+                return TRUE;
         }
 
         U32 fsaa = gSavedSettings.getU32("RenderFSAASamples");
@@ -4797,7 +4902,7 @@ BOOL LLViewerWindow::changeDisplaySettings(BOOL fullscreen, LLCoordScreen size,
 #if LL_WINDOWS
                 // Only trigger a reshape after switching to fullscreen; otherwise rely on the windows callback
                 // (otherwise size is wrong; this is the entire window size, reshape wants the visible window size)
-                if (fullscreen)
+                if (fullscreen && result_first_try)
 #endif
                 {
                         reshape(size.mX, size.mY);
@@ -5099,25 +5204,41 @@ LLPickInfo::~LLPickInfo()
 
 void LLPickInfo::fetchResults()
 {
+
+        S32 face_hit = -1;
+        LLVector3 intersection, normal, binormal;
+        LLVector2 uv;
+
+        LLHUDIcon* hit_icon = gViewerWindow->cursorIntersectIcon(mMousePt.mX, mMousePt.mY, 512.f, &intersection);
+        
+        F32 icon_dist = 0.f;
+        if (hit_icon)
+        {
+                icon_dist = (LLViewerCamera::getInstance()->getOrigin()-intersection).magVec();
+        }
+        LLViewerObject* hit_object = gViewerWindow->cursorIntersect(mMousePt.mX, mMousePt.mY, 512.f,
+                                                                        NULL, -1, mPickTransparent, &face_hit,
+                                                                        &intersection, &uv, &normal, &binormal);
+        
         // read back colors and depth values from buffer
-        glReadPixels(mScreenRegion.mLeft, mScreenRegion.mBottom, mScreenRegion.getWidth(), mScreenRegion.getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, mPickBuffer);
-        glReadPixels(mScreenRegion.mLeft, mScreenRegion.mBottom, mScreenRegion.getWidth(), mScreenRegion.getHeight(), GL_DEPTH_COMPONENT, GL_FLOAT, mPickDepthBuffer );
+        //glReadPixels(mScreenRegion.mLeft, mScreenRegion.mBottom, mScreenRegion.getWidth(), mScreenRegion.getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, mPickBuffer);
+        //glReadPixels(mScreenRegion.mLeft, mScreenRegion.mBottom, mScreenRegion.getWidth(), mScreenRegion.getHeight(), GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, mPickDepthBuffer );
 
         // find pick region that is fully onscreen
         LLCoordGL scaled_pick_point;;
         scaled_pick_point.mX = llclamp(llround((F32)mMousePt.mX * gViewerWindow->getDisplayScale().mV[VX]), PICK_HALF_WIDTH, gViewerWindow->getWindowDisplayWidth() - PICK_HALF_WIDTH);
         scaled_pick_point.mY = llclamp(llround((F32)mMousePt.mY * gViewerWindow->getDisplayScale().mV[VY]), PICK_HALF_WIDTH, gViewerWindow->getWindowDisplayHeight() - PICK_HALF_WIDTH);
-        S32 pixel_index = PICK_HALF_WIDTH * PICK_DIAMETER + PICK_HALF_WIDTH;
-        S32 pick_id = (U32)mPickBuffer[(pixel_index * 4) + 0] << 16 | (U32)mPickBuffer[(pixel_index * 4) + 1] << 8 | (U32)mPickBuffer[(pixel_index * 4) + 2];
-        F32 depth = mPickDepthBuffer[pixel_index];
+        //S32 pixel_index = PICK_HALF_WIDTH * PICK_DIAMETER + PICK_HALF_WIDTH;
+        //S32 pick_id = (U32)mPickBuffer[(pixel_index * 4) + 0] << 16 | (U32)mPickBuffer[(pixel_index * 4) + 1] << 8 | (U32)mPickBuffer[(pixel_index * 4) + 2];
+        //F32 depth = mPickDepthBuffer[pixel_index];
 
-        S32 x_offset = mMousePt.mX - llround((F32)scaled_pick_point.mX / gViewerWindow->getDisplayScale().mV[VX]);
-        S32 y_offset = mMousePt.mY - llround((F32)scaled_pick_point.mY / gViewerWindow->getDisplayScale().mV[VY]);
+        //S32 x_offset = mMousePt.mX - llround((F32)scaled_pick_point.mX / gViewerWindow->getDisplayScale().mV[VX]);
+        //S32 y_offset = mMousePt.mY - llround((F32)scaled_pick_point.mY / gViewerWindow->getDisplayScale().mV[VY]);
 
         mPickPt = mMousePt;
 
         // we hit nothing, scan surrounding pixels for something useful
-        if (!pick_id)
+        /*if (!pick_id)
         {
                 S32 closest_distance = 10000;
                 //S32 closest_pick_name = 0;
@@ -5138,23 +5259,28 @@ void LLPickInfo::fetchResults()
                                 }
                         }
                 }
-        }
+        }*/
 
-        U32 te_offset = ((U32)pick_id >> 20);
-        pick_id &= 0x000fffff;
 
-        //unproject relative clicked coordinate from window coordinate using GL
-        GLint viewport[4];
-        GLdouble modelview[16];
-        GLdouble projection[16];
-        GLfloat winX, winY;
-        GLdouble posX, posY, posZ;
+        U32 te_offset = face_hit > -1 ? face_hit : 0;
+        //pick_id &= 0x000fffff;
 
-        LLViewerObject* objectp = gObjectList.getSelectedObject(pick_id);
+        //unproject relative clicked coordinate from window coordinate using GL
+        
+        LLViewerObject* objectp = hit_object;
 
-        if (pick_id == (S32)GL_NAME_PARCEL_WALL)
+        //if (pick_id == (S32)GL_NAME_PARCEL_WALL)
+        //{
+        //      mPickType = PICK_PARCEL_WALL;
+        //}
+        if (hit_icon && 
+                (!objectp || 
+                icon_dist < (LLViewerCamera::getInstance()->getOrigin()-intersection).magVec()))
         {
-                mPickType = PICK_PARCEL_WALL;
+                // was this name referring to a hud icon?
+                mHUDIcon = hit_icon;
+                mPickType = PICK_ICON;
+                mPosGlobal = mHUDIcon->getPositionGlobal();
         }
         else if (objectp)
         {
@@ -5182,11 +5308,11 @@ void LLPickInfo::fetchResults()
                         {
                                 mPickType = PICK_OBJECT;
                         }
-                        mObjectOffset = gAgent.calcFocusOffset(objectp, mPickPt.mX, mPickPt.mY);
+                        mObjectOffset = gAgent.calcFocusOffset(objectp, intersection, mPickPt.mX, mPickPt.mY);
                         mObjectID = objectp->mID;
                         mObjectFace = (te_offset == NO_FACE) ? -1 : (S32)te_offset;
 
-                        glh::matrix4f newModel((F32*)LLViewerCamera::getInstance()->getModelview().mMatrix);
+                        /*glh::matrix4f newModel((F32*)LLViewerCamera::getInstance()->getModelview().mMatrix);
 
                         for(U32 i = 0; i < 16; ++i)
                         {
@@ -5198,9 +5324,9 @@ void LLPickInfo::fetchResults()
                         winX = ((F32)mPickPt.mX) * gViewerWindow->getDisplayScale().mV[VX];
                         winY = ((F32)mPickPt.mY) * gViewerWindow->getDisplayScale().mV[VY];
 
-                        gluUnProject( winX, winY, depth, modelview, projection, viewport, &posX, &posY, &posZ);
+                        gluUnProject( winX, winY, depth, modelview, projection, viewport, &posX, &posY, &posZ);*/
 
-                        mPosGlobal = gAgent.getPosGlobalFromAgent(LLVector3(posX, posY, posZ));
+                        mPosGlobal = gAgent.getPosGlobalFromAgent(intersection);
                         
                         if (mWantSurfaceInfo)
                         {
@@ -5208,17 +5334,7 @@ void LLPickInfo::fetchResults()
                         }
                 }
         }
-        else
-        {
-                // was this name referring to a hud icon?
-                mHUDIcon = LLHUDIcon::handlePick(pick_id);
-                if (mHUDIcon)
-                {
-                        mPickType = PICK_ICON;
-                        mPosGlobal = mHUDIcon->getPositionGlobal();
-                }
-        }
-
+        
         if (mPickCallback)
         {
                 mPickCallback(*this);
@@ -5232,16 +5348,19 @@ LLPointer<LLViewerObject> LLPickInfo::getObject() const
 
 void LLPickInfo::updateXYCoords()
 {
-        const LLTextureEntry* tep = getObject()->getTE(mObjectFace);
-        LLPointer<LLViewerImage> imagep = gImageList.getImage(tep->getID());
-        if(mUVCoords.mV[VX] >= 0.f && mUVCoords.mV[VY] >= 0.f && imagep.notNull())
+        if (mObjectFace > -1)
         {
-                LLCoordGL coords;
-                
-                coords.mX = llround(mUVCoords.mV[VX] * (F32)imagep->getWidth());
-                coords.mY = llround(mUVCoords.mV[VY] * (F32)imagep->getHeight());
+                const LLTextureEntry* tep = getObject()->getTE(mObjectFace);
+                LLPointer<LLViewerImage> imagep = gImageList.getImage(tep->getID());
+                if(mUVCoords.mV[VX] >= 0.f && mUVCoords.mV[VY] >= 0.f && imagep.notNull())
+                {
+                        LLCoordGL coords;
+                        
+                        coords.mX = llround(mUVCoords.mV[VX] * (F32)imagep->getWidth());
+                        coords.mY = llround(mUVCoords.mV[VY] * (F32)imagep->getHeight());
 
-                gViewerWindow->getWindow()->convertCoords(coords, &mXYCoords);
+                        gViewerWindow->getWindow()->convertCoords(coords, &mXYCoords);
+                }
         }
 }
 
@@ -5252,7 +5371,7 @@ void LLPickInfo::drawPickBuffer() const
                 gGL.pushMatrix();
                 LLGLDisable no_blend(GL_BLEND);
                 LLGLDisable no_alpha_test(GL_ALPHA_TEST);
-                LLGLSNoTexture no_texture;
+                gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
                 glPixelZoom(10.f, 10.f);
                 LLVector2 display_scale = gViewerWindow->getDisplayScale();
                 glRasterPos2f(((F32)mMousePt.mX * display_scale.mV[VX] + 10.f), 
@@ -5304,7 +5423,7 @@ void LLPickInfo::getSurfaceInfo()
         if (objectp)
         {
                 if (gViewerWindow->cursorIntersect(llround((F32)mMousePt.mX), llround((F32)mMousePt.mY), 1024.f,
-                                                                                   objectp, -1,
+                                                                                   objectp, -1, mPickTransparent,
                                                                                    &mObjectFace,
                                                                                    &mIntersection,
                                                                                    &mSTCoords,
@@ -5313,7 +5432,7 @@ void LLPickInfo::getSurfaceInfo()
                 {
                         // if we succeeded with the intersect above, compute the texture coordinates:
 
-                        if (objectp->mDrawable.notNull())
+                        if (objectp->mDrawable.notNull() && mObjectFace > -1)
                         {
                                 LLFace* facep = objectp->mDrawable->getFace(mObjectFace);