Merge branch 'sl-base-1.22' into next

Conflicts:
	linden/indra/newview/English.lproj/InfoPlist.strings
	linden/indra/newview/skins/default/xui/en-us/panel_chat_bar.xml

1 files changed, 213 insertions, 71 deletions

diff --git a/linden/indra/newview/llvoavatar.cpp b/linden/indra/newview/llvoavatar.cpp
index 7d70dd2..3d2523e 100644
--- a/linden/indra/newview/llvoavatar.cpp
+++ b/linden/indra/newview/llvoavatar.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
@@ -244,6 +244,11 @@ static F32 calc_bouncy_animation(F32 x)
         return -(cosf(x * F_PI * 2.5f - F_PI_BY_TWO))*(0.4f + x * -0.1f) + x * 1.3f;
 }
 
+BOOL LLLineSegmentCapsuleIntersect(const LLVector3& start, const LLVector3& end, const LLVector3& p1, const LLVector3& p2, const F32& radius, LLVector3& result)
+{
+        return FALSE;
+}
+
 //-----------------------------------------------------------------------------
 // Static Data
 //-----------------------------------------------------------------------------
@@ -267,6 +272,7 @@ LLUUID LLVOAvatar::sStepSounds[LL_MCODE_END] =
         LLUUID(SND_RUBBER_RUBBER)
 };
 
+// static
 S32 LLVOAvatar::sRenderName = RENDER_NAME_ALWAYS;
 BOOL LLVOAvatar::sRenderGroupTitles = TRUE;
 S32 LLVOAvatar::sNumVisibleChatBubbles = 0;
@@ -279,9 +285,12 @@ BOOL LLVOAvatar::sVisibleInFirstPerson = FALSE;
 F32 LLVOAvatar::sLODFactor = 1.f;
 BOOL LLVOAvatar::sUseImpostors = FALSE;
 BOOL LLVOAvatar::sJointDebug = FALSE;
-
 S32 LLVOAvatar::sCurJoint = 0;
 S32 LLVOAvatar::sCurVolume = 0;
+F32 LLVOAvatar::sUnbakedTime = 0.f;
+F32 LLVOAvatar::sUnbakedUpdateTime = 0.f;
+F32 LLVOAvatar::sGreyTime = 0.f;
+F32 LLVOAvatar::sGreyUpdateTime = 0.f;
 
 struct LLAvatarTexData
 {
@@ -753,7 +762,7 @@ LLVOAvatar::LLVOAvatar(
         mRippleTimeLast = 0.f;
 
         mShadowImagep = gImageList.getImageFromFile("foot_shadow.j2c");
-        mShadowImagep->bind();
+        gGL.getTexUnit(0)->bind(mShadowImagep.get());
         mShadowImagep->setClamp(TRUE, TRUE);
         
         mInAir = FALSE;
@@ -1062,11 +1071,29 @@ void LLVOAvatar::deleteLayerSetCaches()
         if( mLowerBodyLayerSet )        mLowerBodyLayerSet->deleteCaches();
         if( mEyesLayerSet )                     mEyesLayerSet->deleteCaches();
         if( mSkirtLayerSet )            mSkirtLayerSet->deleteCaches();
+
+        if(mUpperMaskTexName)
+        {
+                glDeleteTextures(1, (GLuint*)&mUpperMaskTexName);
+                mUpperMaskTexName = 0 ;
+        }
+        if(mHeadMaskTexName)
+        {
+                glDeleteTextures(1, (GLuint*)&mHeadMaskTexName);
+                mHeadMaskTexName = 0 ;
+        }
+        if(mLowerMaskTexName)
+        {
+                glDeleteTextures(1, (GLuint*)&mLowerMaskTexName);
+                mLowerMaskTexName = 0 ;
+        }
 }
 
 // static 
-BOOL LLVOAvatar::areAllNearbyInstancesBaked()
+BOOL LLVOAvatar::areAllNearbyInstancesBaked(S32& grey_avatars)
 {
+        BOOL res = TRUE;
+        grey_avatars = 0;
         for (std::vector<LLCharacter*>::iterator iter = LLCharacter::sInstances.begin();
                 iter != LLCharacter::sInstances.end(); ++iter)
         {
@@ -1075,18 +1102,22 @@ BOOL LLVOAvatar::areAllNearbyInstancesBaked()
                 {
                         continue;
                 }
-                else
-                if( inst->getPixelArea() < MIN_PIXEL_AREA_FOR_COMPOSITE )
-                {
-                        return TRUE;  // Assumes sInstances is sorted by pixel area.
-                }
+//              else
+//              if( inst->getPixelArea() < MIN_PIXEL_AREA_FOR_COMPOSITE )
+//              {
+//                      return res;  // Assumes sInstances is sorted by pixel area.
+//              }
                 else
                 if( !inst->isFullyBaked() )
                 {
-                        return FALSE;
+                        res = FALSE;
+                        if (inst->mHasGrey)
+                        {
+                                ++grey_avatars;
+                        }
                 }
         }
-        return TRUE;
+        return res;
 }
 
 // static 
@@ -1131,7 +1162,7 @@ void LLVOAvatar::dumpBakedStatus()
                 }
 
 
-                F64 dist_to_camera = (inst->getPositionGlobal() - camera_pos_global).magVec();
+                F64 dist_to_camera = (inst->getPositionGlobal() - camera_pos_global).length();
                 llcont << " " << dist_to_camera << "m ";
 
                 llcont << " " << inst->mPixelArea << " pixels";
@@ -1569,6 +1600,96 @@ void LLVOAvatar::getSpatialExtents(LLVector3& newMin, LLVector3& newMax)
         newMax += buffer;
 }
 
+//-----------------------------------------------------------------------------
+// renderCollisionVolumes()
+//-----------------------------------------------------------------------------
+void LLVOAvatar::renderCollisionVolumes()
+{
+        for (S32 i = 0; i < mNumCollisionVolumes; i++)
+        {
+                mCollisionVolumes[i].renderCollision();
+        }
+
+        if (mNameText.notNull())
+        {
+                LLVector3 unused;
+                mNameText->lineSegmentIntersect(LLVector3(0,0,0), LLVector3(0,0,1), unused, TRUE);
+        }
+}
+
+BOOL LLVOAvatar::lineSegmentIntersect(const LLVector3& start, const LLVector3& end,
+                                                                          S32 face,
+                                                                          BOOL pick_transparent,
+                                                                          S32* face_hit,
+                                                                          LLVector3* intersection,
+                                                                          LLVector2* tex_coord,
+                                                                          LLVector3* normal,
+                                                                          LLVector3* bi_normal
+                )
+{
+
+        if (mIsSelf && !gAgent.needsRenderAvatar() || !LLPipeline::sPickAvatar)
+        {
+                return FALSE;
+        }
+
+        if (lineSegmentBoundingBox(start, end))
+        {
+                for (S32 i = 0; i < mNumCollisionVolumes; ++i)
+                {
+                        mCollisionVolumes[i].updateWorldMatrix();
+
+                        glh::matrix4f mat((F32*) mCollisionVolumes[i].getXform()->getWorldMatrix().mMatrix);
+                        glh::matrix4f inverse = mat.inverse();
+                        glh::matrix4f norm_mat = inverse.transpose();
+
+                        glh::vec3f p1(start.mV);
+                        glh::vec3f p2(end.mV);
+
+                        inverse.mult_matrix_vec(p1);
+                        inverse.mult_matrix_vec(p2);
+
+                        LLVector3 position;
+                        LLVector3 norm;
+
+                        if (linesegment_sphere(LLVector3(p1.v), LLVector3(p2.v), LLVector3(0,0,0), 1.f, position, norm))
+                        {
+                                glh::vec3f res_pos(position.mV);
+                                mat.mult_matrix_vec(res_pos);
+                                
+                                norm.normalize();
+                                glh::vec3f res_norm(norm.mV);
+                                norm_mat.mult_matrix_dir(res_norm);
+
+                                if (intersection)
+                                {
+                                        *intersection = LLVector3(res_pos.v);
+                                }
+
+                                if (normal)
+                                {
+                                        *normal = LLVector3(res_norm.v);
+                                }
+
+                                return TRUE;
+                        }
+                }
+        }
+        
+        LLVector3 position;
+        if (mNameText.notNull() && mNameText->lineSegmentIntersect(start, end, position))
+        {
+                if (intersection)
+                {
+                        *intersection = position;
+                }
+
+                return TRUE;
+        }
+
+        return FALSE;
+}
+
 
 //-----------------------------------------------------------------------------
 // parseSkeletonFile()
@@ -2737,8 +2858,8 @@ void LLVOAvatar::idleUpdateMisc(bool detailed_update)
                         else
                         {
                                 getSpatialExtents(ext[0], ext[1]);
-                                if ((ext[1]-mImpostorExtents[1]).magVec() > 0.05f ||
-                                        (ext[0]-mImpostorExtents[0]).magVec() > 0.05f)
+                                if ((ext[1]-mImpostorExtents[1]).length() > 0.05f ||
+                                        (ext[0]-mImpostorExtents[0]).length() > 0.05f)
                                 {
                                         mNeedsImpostorUpdate = TRUE;
                                 }
@@ -2905,7 +3026,7 @@ void LLVOAvatar::idleUpdateWindEffect()
                 F32 time_delta = mRippleTimer.getElapsedTimeF32() - mRippleTimeLast;
                 mRippleTimeLast = mRippleTimer.getElapsedTimeF32();
                 LLVector3 velocity = getVelocity();
-                F32 speed = velocity.magVec();
+                F32 speed = velocity.length();
                 //RN: velocity varies too much frame to frame for this to work
                 mRippleAccel.clearVec();//lerp(mRippleAccel, (velocity - mLastVel) * time_delta, LLCriticalDamp::getInterpolant(0.02f));
                 mLastVel = velocity;
@@ -2924,7 +3045,7 @@ void LLVOAvatar::idleUpdateWindEffect()
                 }
 
                 wind.mV[VZ] += hover_strength;
-                wind.normVec();
+                wind.normalize();
 
                 wind.mV[VW] = llmin(0.025f + (speed * 0.015f) + hover_strength, 0.5f);
                 F32 interp;
@@ -3047,10 +3168,10 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
                                 LLVector3 pixel_up_vec;
                                 LLViewerCamera::getInstance()->getPixelVectors(root_pos_last, pixel_up_vec, pixel_right_vec);
                                 LLVector3 camera_to_av = root_pos_last - LLViewerCamera::getInstance()->getOrigin();
-                                camera_to_av.normVec();
+                                camera_to_av.normalize();
                                 LLVector3 local_camera_at = camera_to_av * ~root_rot;
                                 LLVector3 local_camera_up = camera_to_av % LLViewerCamera::getInstance()->getLeftAxis();
-                                local_camera_up.normVec();
+                                local_camera_up.normalize();
                                 local_camera_up = local_camera_up * ~root_rot;
                         
                                 local_camera_up.scaleVec(mBodySize * 0.5f);
@@ -3502,7 +3623,7 @@ BOOL LLVOAvatar::updateCharacter(LLAgent &agent)
 
         LLVector3 xyVel = getVelocity();
         xyVel.mV[VZ] = 0.0f;
-        speed = xyVel.magVec();
+        speed = xyVel.length();
 
         BOOL throttle = TRUE;
 
@@ -3587,14 +3708,14 @@ BOOL LLVOAvatar::updateCharacter(LLAgent &agent)
                         if (mIsSelf)
                         {
                                 primDir = agent.getAtAxis() - projected_vec(agent.getAtAxis(), agent.getReferenceUpVector());
-                                primDir.normVec();
+                                primDir.normalize();
                         }
                         else
                         {
                                 primDir = getRotation().getMatrix3().getFwdRow();
                         }
                         LLVector3 velDir = getVelocity();
-                        velDir.normVec();
+                        velDir.normalize();
                         if ( mSignaledAnimations.find(ANIM_AGENT_WALK) != mSignaledAnimations.end())
                         {
                                 F32 vpD = velDir * primDir;
@@ -3616,13 +3737,13 @@ BOOL LLVOAvatar::updateCharacter(LLAgent &agent)
                                         LLVector3 at_axis = LLViewerCamera::getInstance()->getAtAxis();
                                         LLVector3 up_vector = gAgent.getReferenceUpVector();
                                         at_axis -= up_vector * (at_axis * up_vector);
-                                        at_axis.normVec();
+                                        at_axis.normalize();
                                         
                                         F32 dot = fwdDir * at_axis;
                                         if (dot < 0.f)
                                         {
                                                 fwdDir -= 2.f * at_axis * dot;
-                                                fwdDir.normVec();
+                                                fwdDir.normalize();
                                         }
                                 }
                                 
@@ -3690,7 +3811,7 @@ BOOL LLVOAvatar::updateCharacter(LLAgent &agent)
 
                         // Now compute the full world space rotation for the whole body (wQv)
                         LLVector3 leftDir = upDir % fwdDir;
-                        leftDir.normVec();
+                        leftDir.normalize();
                         fwdDir = leftDir % upDir;
                         LLQuaternion wQv( fwdDir, leftDir, upDir );
 
@@ -4131,7 +4252,7 @@ U32 LLVOAvatar::renderSkinned(EAvatarRenderPass pass)
                 LLVector3 collide_point = slaved_pos;
                 collide_point.mV[VZ] -= foot_plane_normal.mV[VZ] * (dist_from_plane + COLLISION_TOLERANCE - FOOT_COLLIDE_FUDGE);
 
-                gGL.begin(LLVertexBuffer::LINES);
+                gGL.begin(LLRender::LINES);
                 {
                         F32 SQUARE_SIZE = 0.2f;
                         gGL.color4f(1.f, 0.f, 0.f, 1.f);
@@ -4278,7 +4399,7 @@ U32 LLVOAvatar::renderFootShadows()
         LLGLDepthTest test(GL_TRUE, GL_FALSE);
         //render foot shadows
         LLGLEnable blend(GL_BLEND);
-        mShadowImagep->bind();
+        gGL.getTexUnit(0)->bind(mShadowImagep.get());
         glColor4fv(mShadow0Facep->getRenderColor().mV);
         mShadow0Facep->renderIndexed(foot_mask);
         glColor4fv(mShadow1Facep->getRenderColor().mV);
@@ -4296,7 +4417,7 @@ U32 LLVOAvatar::renderImpostor(LLColor4U color)
 
         LLVector3 pos(getRenderPosition()+mImpostorOffset);
         LLVector3 at = (pos - LLViewerCamera::getInstance()->getOrigin());
-        at.normVec();
+        at.normalize();
         LLVector3 left = LLViewerCamera::getInstance()->getUpAxis() % at;
         LLVector3 up = at%left;
 
@@ -4324,8 +4445,8 @@ U32 LLVOAvatar::renderImpostor(LLColor4U color)
         color.mV[3] = (U8) (alpha*255);
         
         gGL.color4ubv(color.mV);
-        mImpostor.bindTexture();
-        gGL.begin(LLVertexBuffer::QUADS);
+        gGL.getTexUnit(0)->bind(&mImpostor);
+        gGL.begin(LLRender::QUADS);
         gGL.texCoord2f(0,0);
         gGL.vertex3fv((pos+left-up).mV);
         gGL.texCoord2f(1,0);
@@ -4340,17 +4461,6 @@ U32 LLVOAvatar::renderImpostor(LLColor4U color)
         return 6;
 }
 
-//-----------------------------------------------------------------------------
-// renderCollisionVolumes()
-//-----------------------------------------------------------------------------
-void LLVOAvatar::renderCollisionVolumes()
-{
-        for (S32 i = 0; i < mNumCollisionVolumes; i++)
-        {
-                mCollisionVolumes[i].renderCollision();
-        }
-}
-
 //------------------------------------------------------------------------
 // LLVOAvatar::updateTextures()
 //------------------------------------------------------------------------
@@ -4385,23 +4495,23 @@ void LLVOAvatar::updateTextures(LLAgent &agent)
         {
                 if( head_baked && ! mHeadBakedLoaded )
                 {
-                        getTEImage( TEX_HEAD_BAKED )->bind();
+                        gGL.getTexUnit(0)->bind(getTEImage( TEX_HEAD_BAKED ));
                 }
                 if( upper_baked && ! mUpperBakedLoaded )
                 {
-                        getTEImage( TEX_UPPER_BAKED )->bind();
+                        gGL.getTexUnit(0)->bind(getTEImage( TEX_UPPER_BAKED ));
                 }
                 if( lower_baked && ! mLowerBakedLoaded )
                 {
-                        getTEImage( TEX_LOWER_BAKED )->bind();
+                        gGL.getTexUnit(0)->bind(getTEImage( TEX_LOWER_BAKED ));
                 }
                 if( eyes_baked && ! mEyesBakedLoaded )
                 {
-                        getTEImage( TEX_EYES_BAKED )->bind();
+                        gGL.getTexUnit(0)->bind(getTEImage( TEX_EYES_BAKED ));
                 }
                 if( skirt_baked && ! mSkirtBakedLoaded )
                 {
-                        getTEImage( TEX_SKIRT_BAKED )->bind();
+                        gGL.getTexUnit(0)->bind(getTEImage( TEX_SKIRT_BAKED ));
                 }
         }
 
@@ -4432,6 +4542,7 @@ void LLVOAvatar::updateTextures(LLAgent &agent)
 
         mMaxPixelArea = 0.f;
         mMinPixelArea = 99999999.f;
+        mHasGrey = FALSE; // debug
         for (U32 i = 0; i < getNumTEs(); i++)
         {
                 LLViewerImage *imagep = getTEImage(i);
@@ -4590,22 +4701,35 @@ void LLVOAvatar::updateTextures(LLAgent &agent)
 void LLVOAvatar::addLocalTextureStats( LLVOAvatar::ELocTexIndex idx, LLViewerImage* imagep,
                                                                            F32 texel_area_ratio, BOOL render_avatar, BOOL covered_by_baked )
 {
-        if (!covered_by_baked &&
-                render_avatar && // always true if mIsSelf
-                mLocalTexture[ idx ].notNull() && mLocalTexture[idx]->getID() != IMG_DEFAULT_AVATAR)
-        {       
-                F32 desired_pixels;
-                if( mIsSelf )
+        if (!covered_by_baked && render_avatar) // render_avatar is always true if mIsSelf
+        {
+                if (mLocalTexture[ idx ].notNull() && mLocalTexture[idx]->getID() != IMG_DEFAULT_AVATAR)
                 {
-                        desired_pixels = llmin(mPixelArea, (F32)LOCTEX_IMAGE_AREA_SELF );
-                        imagep->setBoostLevel(LLViewerImage::BOOST_AVATAR_SELF);
+                        F32 desired_pixels;
+                        if( mIsSelf )
+                        {
+                                desired_pixels = llmin(mPixelArea, (F32)LOCTEX_IMAGE_AREA_SELF );
+                                imagep->setBoostLevel(LLViewerImage::BOOST_AVATAR_SELF);
+                        }
+                        else
+                        {
+                                desired_pixels = llmin(mPixelArea, (F32)LOCTEX_IMAGE_AREA_OTHER );
+                                imagep->setBoostLevel(LLViewerImage::BOOST_AVATAR);
+                        }
+                        imagep->addTextureStats( desired_pixels / texel_area_ratio );
+                        if (imagep->getDiscardLevel() < 0)
+                        {
+                                mHasGrey = TRUE; // for statistics gathering
+                        }
                 }
                 else
                 {
-                        desired_pixels = llmin(mPixelArea, (F32)LOCTEX_IMAGE_AREA_OTHER );
-                        imagep->setBoostLevel(LLViewerImage::BOOST_AVATAR);
+                        if (mLocalTexture[idx]->getID() == IMG_DEFAULT_AVATAR)
+                        {
+                                // texture asset is missing
+                                mHasGrey = TRUE; // for statistics gathering
+                        }
                 }
-                imagep->addTextureStats( desired_pixels, texel_area_ratio );
         }
 }
 
@@ -4614,7 +4738,7 @@ void LLVOAvatar::addBakedTextureStats( LLViewerImage* imagep, F32 pixel_area, F3
 {
         mMaxPixelArea = llmax(pixel_area, mMaxPixelArea);
         mMinPixelArea = llmin(pixel_area, mMinPixelArea);
-        imagep->addTextureStats(pixel_area, texel_area_ratio);
+        imagep->addTextureStats(pixel_area / texel_area_ratio);
         imagep->setBoostLevel(boost_level);
 }
 
@@ -4803,12 +4927,13 @@ BOOL LLVOAvatar::processSingleAnimationStateChange( const LLUUID& anim_id, BOOL
                                         // to support both spatialized and non-spatialized instances of the same sound
                                         //if (mIsSelf)
                                         //{
-                                        //  F32 volume = gain * gSavedSettings.getF32("AudioLevelUI")
-                                        //      gAudiop->triggerSound(LLUUID(gSavedSettings.getString("UISndTyping")), volume);
+                                        //      gAudiop->triggerSound(LLUUID(gSavedSettings.getString("UISndTyping")), 1.0f, LLAudioEngine::AUDIO_TYPE_UI);
                                         //}
                                         //else
-                                        LLUUID sound_id = LLUUID(gSavedSettings.getString("UISndTyping"));
-                                        gAudiop->triggerSound(sound_id, getID(), 1.0f, LLAudioEngine::AUDIO_TYPE_SFX, char_pos_global);
+                                        {
+                                                LLUUID sound_id = LLUUID(gSavedSettings.getString("UISndTyping"));
+                                                gAudiop->triggerSound(sound_id, getID(), 1.0f, LLAudioEngine::AUDIO_TYPE_SFX, char_pos_global);
+                                        }
                                 }
                         }
                 }
@@ -5826,7 +5951,7 @@ void LLVOAvatar::setPixelAreaAndAngle(LLAgent &agent)
         }
         else
         {
-                F32 radius = size.magVec();
+                F32 radius = size.length();
                 mAppAngle = (F32) atan2( radius, range) * RAD_TO_DEG;
         }
 
@@ -5998,7 +6123,7 @@ void LLVOAvatar::updateShadowFaces()
                         sprite.setPosition(shadow_pos_agent);
 
                         LLVector3 foot_to_knee = mKneeLeftp->getWorldPosition() - joint_world_pos;
-                        //foot_to_knee.normVec();
+                        //foot_to_knee.normalize();
                         foot_to_knee -= projected_vec(foot_to_knee, sun_vec);
                         sprite.setYaw(azimuth(sun_vec - foot_to_knee));
                 
@@ -6031,7 +6156,7 @@ void LLVOAvatar::updateShadowFaces()
                         sprite.setPosition(shadow_pos_agent);
 
                         LLVector3 foot_to_knee = mKneeRightp->getWorldPosition() - joint_world_pos;
-                        //foot_to_knee.normVec();
+                        //foot_to_knee.normalize();
                         foot_to_knee -= projected_vec(foot_to_knee, sun_vec);
                         sprite.setYaw(azimuth(sun_vec - foot_to_knee));
         
@@ -6392,7 +6517,7 @@ void LLVOAvatar::getOffObject()
                 LLVector3 at_axis = LLVector3::x_axis;
                 at_axis = at_axis * av_rot;
                 at_axis.mV[VZ] = 0.f;
-                at_axis.normVec();
+                at_axis.normalize();
                 gAgent.resetAxes(at_axis);
 
                 //reset orientation
@@ -6946,7 +7071,7 @@ BOOL LLVOAvatar::bindScratchTexture( LLGLenum format )
         GLuint gl_name = getScratchTexName( format, &texture_bytes );
         if( gl_name )
         {
-                LLImageGL::bindExternalTexture( gl_name, 0, GL_TEXTURE_2D );
+                gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, gl_name);
                 stop_glerror();
 
                 F32* last_bind_time = LLVOAvatar::sScratchTexLastBindTime.getIfThere( format );
@@ -7004,7 +7129,7 @@ LLGLuint LLVOAvatar::getScratchTexName( LLGLenum format, U32* texture_bytes )
                 glGenTextures(1, &name );
                 stop_glerror();
 
-                LLImageGL::bindExternalTexture( name, 0, GL_TEXTURE_2D ); 
+                gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, name);
                 stop_glerror();
 
                 glTexImage2D(
@@ -7019,7 +7144,7 @@ LLGLuint LLVOAvatar::getScratchTexName( LLGLenum format, U32* texture_bytes )
                 glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
                 stop_glerror();
 
-                LLImageGL::unbindTexture(0, GL_TEXTURE_2D); 
+                gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
                 stop_glerror();
 
                 LLVOAvatar::sScratchTexNames.addData( format, new LLGLuint( name ) );
@@ -8628,7 +8753,7 @@ void LLVOAvatar::onBakedTextureMasksLoaded( BOOL success, LLViewerImage *src_vi,
                         glGenTextures(1, (GLuint*) &gl_name );
                         stop_glerror();
 
-                        LLImageGL::bindExternalTexture( gl_name, 0, GL_TEXTURE_2D ); 
+                        gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, gl_name);
                         stop_glerror();
 
                         glTexImage2D(
@@ -9034,10 +9159,27 @@ void LLVOAvatar::cullAvatarsByPixelArea()
                 }
         }
 
-        if( LLVOAvatar::areAllNearbyInstancesBaked() )
+        S32 grey_avatars = 0;
+        if( LLVOAvatar::areAllNearbyInstancesBaked(grey_avatars) )
         {
                 LLVOAvatar::deleteCachedImages();
         }
+        else
+        {
+                if (gFrameTimeSeconds != sUnbakedUpdateTime) // only update once per frame
+                {
+                        sUnbakedUpdateTime = gFrameTimeSeconds;
+                        sUnbakedTime += gFrameIntervalSeconds;
+                }
+                if (grey_avatars > 0)
+                {
+                        if (gFrameTimeSeconds != sGreyUpdateTime) // only update once per frame
+                        {
+                                sGreyUpdateTime = gFrameTimeSeconds;
+                                sGreyTime += gFrameIntervalSeconds;
+                        }
+                }
+        }
 }
 
 const LLUUID& LLVOAvatar::grabLocalTexture(ETextureIndex index)
@@ -9903,7 +10045,7 @@ void LLVOAvatar::getImpostorValues(LLVector3* extents, LLVector3& angle, F32& di
         extents[1] = ext[1];
 
         LLVector3 at = LLViewerCamera::getInstance()->getOrigin()-(getRenderPosition()+mImpostorOffset);
-        distance = at.normVec();
+        distance = at.normalize();
         F32 da = 1.f - (at*LLViewerCamera::getInstance()->getAtAxis());
         angle.mV[0] = LLViewerCamera::getInstance()->getYaw()*da;
         angle.mV[1] = LLViewerCamera::getInstance()->getPitch()*da;