Second Life viewer sources 1.23.0-RC

1 files changed, 1563 insertions, 2516 deletions

diff --git a/linden/indra/newview/llvoavatar.cpp b/linden/indra/newview/llvoavatar.cpp
index e29ea78..b06652a 100644
--- a/linden/indra/newview/llvoavatar.cpp
+++ b/linden/indra/newview/llvoavatar.cpp
@@ -17,7 +17,8 @@
  * There are special exceptions to the terms and conditions of the GPL as
  * it is applied to this Source Code. View the full text of the exception
  * in the file doc/FLOSS-exception.txt in this software distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -31,175 +32,116 @@
 
 #include "llviewerprecompiledheaders.h"
 
-#include <algorithm>
-#include <vector>
-#include "llstl.h"
-
 #include "llvoavatar.h"
 
-#include "llrender.h"
+#include <stdio.h>
+#include <ctype.h>
+
 #include "audioengine.h"
-#include "imageids.h"
-#include "indra_constants.h"
-#include "llchat.h"
-#include "llfontgl.h"
-#include "llprimitive.h"
-#include "lltextureentry.h"
-#include "message.h"
 #include "noise.h"
-#include "sound_ids.h"
-#include "lltimer.h"
-#include "timing.h"
 
-#include "llagent.h"                    //  Get state values from here
+#include "llagent.h" //  Get state values from here
 #include "llviewercontrol.h"
-#include "llcriticaldamp.h"
-#include "lldir.h"
-#include "lldrawable.h"
 #include "lldrawpoolavatar.h"
-#include "lldrawpoolalpha.h"
-#include "lldrawpoolbump.h"
 #include "lldriverparam.h"
 #include "lleditingmotion.h"
 #include "llemote.h"
-#include "llface.h"
-#include "llfasttimer.h"
 #include "llfirstuse.h"
-#include "llfloatercustomize.h"
-#include "llfloatertools.h"
-#include "llgldbg.h"
-#include "llhandmotion.h"
 #include "llheadrotmotion.h"
-#include "llhudeffectbeam.h"
-#include "llhudeffectlookat.h"
 #include "llhudeffecttrail.h"
 #include "llhudmanager.h"
-#include "llhudtext.h"
-#include "llinventorymodel.h"
 #include "llinventoryview.h"
 #include "llkeyframefallmotion.h"
-#include "llkeyframemotion.h"
-#include "llkeyframemotionparam.h"
 #include "llkeyframestandmotion.h"
 #include "llkeyframewalkmotion.h"
-#include "llmenugl.h"
 #include "llmutelist.h"
-#include "llnetmap.h"
 #include "llnotify.h"
 #include "llquantize.h"
 #include "llregionhandle.h"
 #include "llresmgr.h"
 #include "llselectmgr.h"
-#include "llsky.h"
 #include "llsprite.h"
-#include "llstatusbar.h"
 #include "lltargetingmotion.h"
 #include "lltexlayer.h"
-#include "lltoolgrab.h"         // for needsRenderBeam
-#include "lltoolmgr.h"          // for needsRenderBeam
+#include "lltoolgrab.h" // for needsRenderBeam
+#include "lltoolmgr.h" // for needsRenderBeam
 #include "lltoolmorph.h"
 #include "llviewercamera.h"
 #include "llviewerimagelist.h"
-#include "llviewerinventory.h"
 #include "llviewermenu.h"
 #include "llviewerobjectlist.h"
 #include "llviewerparcelmgr.h"
-#include "llviewerregion.h"
 #include "llviewerstats.h"
-#include "llviewerwindow.h"
-#include "llvosky.h"
 #include "llvovolume.h"
-#include "llwearable.h"
-#include "llwearablelist.h"
 #include "llworld.h"
 #include "pipeline.h"
-#include "llspatialpartition.h"
 #include "llviewershadermgr.h"
-#include "llappviewer.h"
 #include "llsky.h"
 #include "llanimstatelabels.h"
-
-//#include "vtune/vtuneapi.h"
-
 #include "llgesturemgr.h" //needed to trigger the voice gesticulations
-#include "llvoicevisualizer.h" 
 #include "llvoiceclient.h"
+#include "llvoicevisualizer.h" // Ventrella
 
-LLXmlTree LLVOAvatar::sXMLTree;
-LLXmlTree LLVOAvatar::sSkeletonXMLTree;
-LLVOAvatarSkeletonInfo* LLVOAvatar::sSkeletonInfo = NULL;
-LLVOAvatarInfo*                 LLVOAvatar::sAvatarInfo = NULL;
+#include "boost/lexical_cast.hpp"
 
-BOOL gDebugAvatarRotation = FALSE;
-S32 LLVOAvatar::sFreezeCounter = 0 ;
+using namespace LLVOAvatarDefines;
+
+//-----------------------------------------------------------------------------
+// Global constants
+//-----------------------------------------------------------------------------
+const LLUUID ANIM_AGENT_BODY_NOISE = LLUUID("9aa8b0a6-0c6f-9518-c7c3-4f41f2c001ad"); //"body_noise"
+const LLUUID ANIM_AGENT_BREATHE_ROT     = LLUUID("4c5a103e-b830-2f1c-16bc-224aa0ad5bc8");  //"breathe_rot"
+const LLUUID ANIM_AGENT_EDITING = LLUUID("2a8eba1d-a7f8-5596-d44a-b4977bf8c8bb");  //"editing"
+const LLUUID ANIM_AGENT_EYE     = LLUUID("5c780ea8-1cd1-c463-a128-48c023f6fbea");  //"eye"
+const LLUUID ANIM_AGENT_FLY_ADJUST = LLUUID("db95561f-f1b0-9f9a-7224-b12f71af126e");  //"fly_adjust"
+const LLUUID ANIM_AGENT_HAND_MOTION     = LLUUID("ce986325-0ba7-6e6e-cc24-b17c4b795578");  //"hand_motion"
+const LLUUID ANIM_AGENT_HEAD_ROT = LLUUID("e6e8d1dd-e643-fff7-b238-c6b4b056a68d");  //"head_rot"
+const LLUUID ANIM_AGENT_PELVIS_FIX = LLUUID("0c5dd2a2-514d-8893-d44d-05beffad208b");  //"pelvis_fix"
+const LLUUID ANIM_AGENT_TARGET = LLUUID("0e4896cb-fba4-926c-f355-8720189d5b55");  //"target"
+const LLUUID ANIM_AGENT_WALK_ADJUST     = LLUUID("829bc85b-02fc-ec41-be2e-74cc6dd7215d");  //"walk_adjust"
 
-//extern BOOL gVelocityInterpolate;
 
 //-----------------------------------------------------------------------------
 // Constants
 //-----------------------------------------------------------------------------
-const F32 MIN_PIXEL_AREA_FOR_COMPOSITE = 1024;
+const std::string AVATAR_DEFAULT_CHAR = "avatar";
 
-F32 SHADOW_OFFSET_AMT = 0.03f;
+const S32 MIN_PIXEL_AREA_FOR_COMPOSITE = 1024;
+const F32 SHADOW_OFFSET_AMT = 0.03f;
 
-#define DELTA_TIME_MIN                  0.01f   // we clamp measured deltaTime to this
-#define DELTA_TIME_MAX                  0.2f    // range to insure stability of computations.
+const F32 DELTA_TIME_MIN = 0.01f;       // we clamp measured deltaTime to this
+const F32 DELTA_TIME_MAX = 0.2f;        // range to insure stability of computations.
 
 const F32 PELVIS_LAG_FLYING             = 0.22f;// pelvis follow half life while flying
-
 const F32 PELVIS_LAG_WALKING    = 0.4f; // ...while walking
-
 const F32 PELVIS_LAG_MOUSELOOK = 0.15f;
 const F32 MOUSELOOK_PELVIS_FOLLOW_FACTOR = 0.5f;
-
 const F32 PELVIS_LAG_WHEN_FOLLOW_CAM_IS_ON = 0.0001f; // not zero! - something gets divided by this!
 
-#define PELVIS_ROT_THRESHOLD_SLOW       60.0f   // amount of deviation allowed between
-#define PELVIS_ROT_THRESHOLD_FAST       2.0f    // the pelvis and the view direction
+const F32 PELVIS_ROT_THRESHOLD_SLOW = 60.0f;    // amount of deviation allowed between
+const F32 PELVIS_ROT_THRESHOLD_FAST = 2.0f;     // the pelvis and the view direction
                                                                                         // when moving fast & slow
-
-const F32 MIN_SPEED_PELVIS_FOLLOW = 0.1f;
-
-#define TORSO_NOISE_AMOUNT              1.f     // Amount of deviation from up-axis, in degrees
-#define TORSO_NOISE_SPEED               0.2f    // Time scale factor on torso noise.
+const F32 TORSO_NOISE_AMOUNT = 1.0f;    // Amount of deviation from up-axis, in degrees
+const F32 TORSO_NOISE_SPEED = 0.2f;     // Time scale factor on torso noise.
 
 const F32 BREATHE_ROT_MOTION_STRENGTH = 0.05f;
-
 const F32 BREATHE_SCALE_MOTION_STRENGTH = 0.005f;
 
-#define PELVIS_NOISE_FACTOR             0.5f    // amount of random noise
-
-#define AUDIO_STEP_PRI                  0xC0000000
-#define AUDIO_STEP_LO_SPEED             0.01f   // as average speed goes from lo to hi,
-#define AUDIO_STEP_HI_SPEED             3.0f    // from lo to hi
-#define AUDIO_STEP_LO_GAIN              0.15f   // the resulting gain will ramp linearly
-#define AUDIO_STEP_HI_GAIN              0.15f
-
-const F32 DAMPED_MOTION_TIME_SCALE = 0.15f;
-
-const F32 LOOKAT_CAMERA_DIST_SQUARED = 25.f;
-
-#define AVATAR_HEADER           "Linden Avatar 1.0"
-#define AVATAR_SECTION          "[avatar]"
-
-#define AVATAR_DEFAULT_CHAR     "avatar"
-
 const F32 MIN_SHADOW_HEIGHT = 0.f;
 const F32 MAX_SHADOW_HEIGHT = 0.3f;
 
-#define MIN_REQUIRED_PIXEL_AREA_BODY_NOISE (10000.f)
-#define MIN_REQUIRED_PIXEL_AREA_BREATHE (10000.f)
-#define MIN_REQUIRED_PIXEL_AREA_PELVIS_FIX (40.f)
+const S32 MIN_REQUIRED_PIXEL_AREA_BODY_NOISE = 10000;
+const S32 MIN_REQUIRED_PIXEL_AREA_BREATHE = 10000;
+const S32 MIN_REQUIRED_PIXEL_AREA_PELVIS_FIX = 40;
 
-const S32 LOCTEX_IMAGE_SIZE_SELF = 512;
-const S32 LOCTEX_IMAGE_AREA_SELF = LOCTEX_IMAGE_SIZE_SELF * LOCTEX_IMAGE_SIZE_SELF;
-const S32 LOCTEX_IMAGE_SIZE_OTHER = LOCTEX_IMAGE_SIZE_SELF / 4;  // The size of local textures for other (!mIsSelf) avatars
-const S32 LOCTEX_IMAGE_AREA_OTHER = LOCTEX_IMAGE_SIZE_OTHER * LOCTEX_IMAGE_SIZE_OTHER;
+const S32 TEX_IMAGE_SIZE_SELF = 512;
+const S32 TEX_IMAGE_AREA_SELF = TEX_IMAGE_SIZE_SELF * TEX_IMAGE_SIZE_SELF;
+const S32 TEX_IMAGE_SIZE_OTHER = TEX_IMAGE_SIZE_SELF / 4;  // The size of local textures for other (!mIsSelf) avatars
+const S32 TEX_IMAGE_AREA_OTHER = TEX_IMAGE_SIZE_OTHER * TEX_IMAGE_SIZE_OTHER;
 
 const F32 HEAD_MOVEMENT_AVG_TIME = 0.9f;
 
 const S32 MORPH_MASK_REQUESTED_DISCARD = 0;
-const S32 MIN_PIXEL_AREA_BUMP = 500;
 
 // Discard level at which to switch to baked textures
 // Should probably be 4 or 3, but didn't want to change it while change other logic - SJB
@@ -209,95 +151,36 @@ const F32 FOOT_COLLIDE_FUDGE = 0.04f;
 
 const F32 HOVER_EFFECT_MAX_SPEED = 3.f;
 const F32 HOVER_EFFECT_STRENGTH = 0.f;
-F32 UNDERWATER_EFFECT_STRENGTH = 0.1f;
+const F32 UNDERWATER_EFFECT_STRENGTH = 0.1f;
 const F32 UNDERWATER_FREQUENCY_DAMP = 0.33f;
 const F32 APPEARANCE_MORPH_TIME = 0.65f;
-const F32 CAMERA_SHAKE_ACCEL_THRESHOLD_SQUARED = 5.f * 5.f;
 const F32 TIME_BEFORE_MESH_CLEANUP = 5.f; // seconds
 const S32 AVATAR_RELEASE_THRESHOLD = 10; // number of avatar instances before releasing memory
 const F32 FOOT_GROUND_COLLISION_TOLERANCE = 0.25f;
 const F32 AVATAR_LOD_TWEAK_RANGE = 0.7f;
-const S32 MAX_LOD_CHANGES_PER_FRAME = 2;
 const S32 MAX_BUBBLE_CHAT_LENGTH = 1023;
 const S32 MAX_BUBBLE_CHAT_UTTERANCES = 12;
 const F32 CHAT_FADE_TIME = 8.0;
 const F32 BUBBLE_CHAT_TIME = CHAT_FADE_TIME * 3.f;
-const S32 MAX_BUBBLES = 7;
 
-S32 LLVOAvatar::sMaxVisible = 50;
+const LLColor4 DUMMY_COLOR = LLColor4(0.5,0.5,0.5,1.0);
 
-LLVOAvatar::ETextureIndex LLVOAvatar::sBakedTextureIndices[BAKED_TEXTURE_COUNT] = 
+enum ERenderName
 {
-        LLVOAvatar::TEX_HEAD_BAKED,
-        LLVOAvatar::TEX_UPPER_BAKED,
-        LLVOAvatar::TEX_LOWER_BAKED,
-        LLVOAvatar::TEX_EYES_BAKED,
-        LLVOAvatar::TEX_SKIRT_BAKED
+        RENDER_NAME_NEVER,
+        RENDER_NAME_FADE,
+        RENDER_NAME_ALWAYS
 };
 
 //-----------------------------------------------------------------------------
-// Utility functions
-//-----------------------------------------------------------------------------
-
-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
+// Callback data
 //-----------------------------------------------------------------------------
-S32 LLVOAvatar::sMaxOtherAvatarsToComposite = 1;  // Only this many avatars (other than yourself) can be composited at a time.  Set in initClass().
-LLMap< LLGLenum, LLGLuint*> LLVOAvatar::sScratchTexNames;
-LLMap< LLGLenum, F32*> LLVOAvatar::sScratchTexLastBindTime;
-S32 LLVOAvatar::sScratchTexBytes = 0;
-F32 LLVOAvatar::sRenderDistance = 256.f;
-S32     LLVOAvatar::sNumVisibleAvatars = 0;
-S32     LLVOAvatar::sNumLODChangesThisFrame = 0;
-
-LLUUID LLVOAvatar::sStepSoundOnLand = LLUUID("e8af4a28-aa83-4310-a7c4-c047e15ea0df");
-LLUUID LLVOAvatar::sStepSounds[LL_MCODE_END] =
-{
-        LLUUID(SND_STONE_RUBBER),
-        LLUUID(SND_METAL_RUBBER),
-        LLUUID(SND_GLASS_RUBBER),
-        LLUUID(SND_WOOD_RUBBER),
-        LLUUID(SND_FLESH_RUBBER),
-        LLUUID(SND_RUBBER_PLASTIC),
-        LLUUID(SND_RUBBER_RUBBER)
-};
-
-// static
-S32 LLVOAvatar::sRenderName = RENDER_NAME_ALWAYS;
-BOOL LLVOAvatar::sRenderGroupTitles = TRUE;
-S32 LLVOAvatar::sNumVisibleChatBubbles = 0;
-BOOL LLVOAvatar::sDebugInvisible = FALSE;
-BOOL LLVOAvatar::sShowAttachmentPoints = FALSE;
-BOOL LLVOAvatar::sShowAnimationDebug = FALSE;
-BOOL LLVOAvatar::sShowFootPlane = FALSE;
-BOOL LLVOAvatar::sShowCollisionVolumes = FALSE;
-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
 {
-        LLAvatarTexData( const LLUUID& id, LLVOAvatar::ELocTexIndex index )
+        LLAvatarTexData( const LLUUID& id, ETextureIndex index )
                 : mAvatarID(id), mIndex(index) {}
         LLUUID                          mAvatarID;
-        LLVOAvatar::ELocTexIndex        mIndex;
+        ETextureIndex   mIndex;
 };
 
 struct LLTextureMaskData
@@ -308,6 +191,142 @@ struct LLTextureMaskData
         S32                                     mLastDiscardLevel;
 };
 
+/*********************************************************************************
+ **                                                                             **
+ ** Begin LLVOAvatar Support classes
+ **
+ **/
+
+//------------------------------------------------------------------------
+// LLVOBoneInfo
+// Trans/Scale/Rot etc. info about each avatar bone.  Used by LLVOAvatarSkeleton.
+//------------------------------------------------------------------------
+class LLVOAvatarBoneInfo
+{
+        friend class LLVOAvatar;
+        friend class LLVOAvatarSkeletonInfo;
+public:
+        LLVOAvatarBoneInfo() : mIsJoint(FALSE) {}
+        ~LLVOAvatarBoneInfo()
+        {
+                std::for_each(mChildList.begin(), mChildList.end(), DeletePointer());
+        }
+        BOOL parseXml(LLXmlTreeNode* node);
+        
+private:
+        std::string mName;
+        BOOL mIsJoint;
+        LLVector3 mPos;
+        LLVector3 mRot;
+        LLVector3 mScale;
+        LLVector3 mPivot;
+        typedef std::vector<LLVOAvatarBoneInfo*> child_list_t;
+        child_list_t mChildList;
+};
+
+//------------------------------------------------------------------------
+// LLVOAvatarSkeletonInfo
+// Overall avatar skeleton
+//------------------------------------------------------------------------
+class LLVOAvatarSkeletonInfo
+{
+        friend class LLVOAvatar;
+public:
+        LLVOAvatarSkeletonInfo() :
+                mNumBones(0), mNumCollisionVolumes(0) {}
+        ~LLVOAvatarSkeletonInfo()
+        {
+                std::for_each(mBoneInfoList.begin(), mBoneInfoList.end(), DeletePointer());
+        }
+        BOOL parseXml(LLXmlTreeNode* node);
+        S32 getNumBones() const { return mNumBones; }
+        S32 getNumCollisionVolumes() const { return mNumCollisionVolumes; }
+        
+private:
+        S32 mNumBones;
+        S32 mNumCollisionVolumes;
+        typedef std::vector<LLVOAvatarBoneInfo*> bone_info_list_t;
+        bone_info_list_t mBoneInfoList;
+};
+
+
+//------------------------------------------------------------------------
+// LLVOAvatarXmlInfo
+// One instance (in LLVOAvatar) with common data parsed from the XML files
+//------------------------------------------------------------------------
+class LLVOAvatarXmlInfo
+{
+        friend class LLVOAvatar;
+public:
+        LLVOAvatarXmlInfo();
+        ~LLVOAvatarXmlInfo();
+        
+private:
+        BOOL    parseXmlSkeletonNode(LLXmlTreeNode* root);
+        BOOL    parseXmlMeshNodes(LLXmlTreeNode* root);
+        BOOL    parseXmlColorNodes(LLXmlTreeNode* root);
+        BOOL    parseXmlLayerNodes(LLXmlTreeNode* root);
+        BOOL    parseXmlDriverNodes(LLXmlTreeNode* root);
+        
+        struct LLVOAvatarMeshInfo
+        {
+                typedef std::pair<LLPolyMorphTargetInfo*,BOOL> morph_info_pair_t;
+                typedef std::vector<morph_info_pair_t> morph_info_list_t;
+
+                LLVOAvatarMeshInfo() : mLOD(0), mMinPixelArea(.1f) {}
+                ~LLVOAvatarMeshInfo()
+                {
+                        morph_info_list_t::iterator iter;
+                        for (iter = mPolyMorphTargetInfoList.begin(); iter != mPolyMorphTargetInfoList.end(); iter++)
+                        {
+                                delete iter->first;
+                        }
+                        mPolyMorphTargetInfoList.clear();
+                }
+
+                std::string mType;
+                S32                     mLOD;
+                std::string     mMeshFileName;
+                std::string     mReferenceMeshName;
+                F32                     mMinPixelArea;
+                morph_info_list_t mPolyMorphTargetInfoList;
+        };
+        typedef std::vector<LLVOAvatarMeshInfo*> mesh_info_list_t;
+        mesh_info_list_t mMeshInfoList;
+
+        typedef std::vector<LLPolySkeletalDistortionInfo*> skeletal_distortion_info_list_t;
+        skeletal_distortion_info_list_t mSkeletalDistortionInfoList;
+        
+        struct LLVOAvatarAttachmentInfo
+        {
+                LLVOAvatarAttachmentInfo()
+                        : mGroup(-1), mAttachmentID(-1), mPieMenuSlice(-1), mVisibleFirstPerson(FALSE),
+                          mIsHUDAttachment(FALSE), mHasPosition(FALSE), mHasRotation(FALSE) {}
+                std::string mName;
+                std::string mJointName;
+                LLVector3 mPosition;
+                LLVector3 mRotationEuler;
+                S32 mGroup;
+                S32 mAttachmentID;
+                S32 mPieMenuSlice;
+                BOOL mVisibleFirstPerson;
+                BOOL mIsHUDAttachment;
+                BOOL mHasPosition;
+                BOOL mHasRotation;
+        };
+        typedef std::vector<LLVOAvatarAttachmentInfo*> attachment_info_list_t;
+        attachment_info_list_t mAttachmentInfoList;
+        
+        LLTexGlobalColorInfo *mTexSkinColorInfo;
+        LLTexGlobalColorInfo *mTexHairColorInfo;
+        LLTexGlobalColorInfo *mTexEyeColorInfo;
+
+        typedef std::vector<LLTexLayerSetInfo*> layer_info_list_t;
+        layer_info_list_t mLayerInfoList;
+
+        typedef std::vector<LLDriverParamInfo*> driver_info_list_t;
+        driver_info_list_t mDriverInfoList;
+};
 
 //-----------------------------------------------------------------------------
 // class LLBodyNoiseMotion
@@ -321,7 +340,6 @@ public:
                 : LLMotion(id)
         {
                 mName = "body_noise";
-
                 mTorsoState = new LLJointState;
         }
 
@@ -408,7 +426,7 @@ public:
         // called when a motion is deactivated
         virtual void onDeactivate() {}
 
-public:
+private:
         //-------------------------------------------------------------------------
         // joint states to be animated
         //-------------------------------------------------------------------------
@@ -429,12 +447,11 @@ public:
                 mCharacter(NULL)
         {
                 mName = "breathe_rot";
-
                 mChestState = new LLJointState;
         }
 
         // Destructor
-        virtual ~LLBreatheMotionRot() { }
+        virtual ~LLBreatheMotionRot() {}
 
 public:
         //-------------------------------------------------------------------------
@@ -517,7 +534,7 @@ public:
         // called when a motion is deactivated
         virtual void onDeactivate() {}
 
-public:
+private:
         //-------------------------------------------------------------------------
         // joint states to be animated
         //-------------------------------------------------------------------------
@@ -614,7 +631,7 @@ public:
         // called when a motion is deactivated
         virtual void onDeactivate() {}
 
-public:
+private:
         //-------------------------------------------------------------------------
         // joint states to be animated
         //-------------------------------------------------------------------------
@@ -622,20 +639,73 @@ public:
         LLCharacter*            mCharacter;
 };
 
+/**
+ **
+ ** End LLVOAvatar Support classes
+ **                                                                             **
+ *********************************************************************************/
+
+
+//-----------------------------------------------------------------------------
+// Static Data
+//-----------------------------------------------------------------------------
+LLXmlTree LLVOAvatar::sXMLTree;
+LLXmlTree LLVOAvatar::sSkeletonXMLTree;
+BOOL LLVOAvatar::sDebugAvatarRotation = FALSE;
+LLVOAvatarSkeletonInfo* LLVOAvatar::sAvatarSkeletonInfo = NULL;
+LLVOAvatarXmlInfo* LLVOAvatar::sAvatarXmlInfo = NULL;
+LLVOAvatarDictionary *LLVOAvatar::sAvatarDictionary = NULL;
+S32 LLVOAvatar::sFreezeCounter = 0;
+S32 LLVOAvatar::sMaxVisible = 50;
+LLMap< LLGLenum, LLGLuint*> LLVOAvatar::sScratchTexNames;
+LLMap< LLGLenum, F32*> LLVOAvatar::sScratchTexLastBindTime;
+S32 LLVOAvatar::sScratchTexBytes = 0;
+F32 LLVOAvatar::sRenderDistance = 256.f;
+S32     LLVOAvatar::sNumVisibleAvatars = 0;
+S32     LLVOAvatar::sNumLODChangesThisFrame = 0;
+
+const LLUUID LLVOAvatar::sStepSoundOnLand = LLUUID("e8af4a28-aa83-4310-a7c4-c047e15ea0df");
+const LLUUID LLVOAvatar::sStepSounds[LL_MCODE_END] =
+{
+        LLUUID(SND_STONE_RUBBER),
+        LLUUID(SND_METAL_RUBBER),
+        LLUUID(SND_GLASS_RUBBER),
+        LLUUID(SND_WOOD_RUBBER),
+        LLUUID(SND_FLESH_RUBBER),
+        LLUUID(SND_RUBBER_PLASTIC),
+        LLUUID(SND_RUBBER_RUBBER)
+};
+
+S32 LLVOAvatar::sRenderName = RENDER_NAME_ALWAYS;
+BOOL LLVOAvatar::sRenderGroupTitles = TRUE;
+S32 LLVOAvatar::sNumVisibleChatBubbles = 0;
+BOOL LLVOAvatar::sDebugInvisible = FALSE;
+BOOL LLVOAvatar::sShowAttachmentPoints = FALSE;
+BOOL LLVOAvatar::sShowAnimationDebug = FALSE;
+BOOL LLVOAvatar::sShowFootPlane = FALSE;
+BOOL LLVOAvatar::sVisibleInFirstPerson = FALSE;
+F32 LLVOAvatar::sLODFactor = 1.f;
+BOOL LLVOAvatar::sUseImpostors = FALSE;
+BOOL LLVOAvatar::sJointDebug = FALSE;
+
+F32 LLVOAvatar::sUnbakedTime = 0.f;
+F32 LLVOAvatar::sUnbakedUpdateTime = 0.f;
+F32 LLVOAvatar::sGreyTime = 0.f;
+F32 LLVOAvatar::sGreyUpdateTime = 0.f;
+
+//-----------------------------------------------------------------------------
+// Helper functions
+//-----------------------------------------------------------------------------
+static F32 calc_bouncy_animation(F32 x);
+static U32 calc_shame(LLVOVolume* volume, std::set<LLUUID> &textures);
+
 //-----------------------------------------------------------------------------
 // LLVOAvatar()
 //-----------------------------------------------------------------------------
-LLVOAvatar::LLVOAvatar(
-        const LLUUID& id,
-        const LLPCode pcode,
-        LLViewerRegion* regionp)
-        :
+LLVOAvatar::LLVOAvatar(const LLUUID& id,
+                                           const LLPCode pcode,
+                                           LLViewerRegion* regionp) :
         LLViewerObject(id, pcode, regionp),
-        mLastHeadBakedID( IMG_DEFAULT_AVATAR ),
-        mLastUpperBodyBakedID( IMG_DEFAULT_AVATAR ),
-        mLastLowerBodyBakedID( IMG_DEFAULT_AVATAR ),
-        mLastEyesBakedID( IMG_DEFAULT_AVATAR ),
-        mLastSkirtBakedID( IMG_DEFAULT_AVATAR ),
         mIsDummy(FALSE),
         mSpecialRenderMode(0),
         mTurning(FALSE),
@@ -653,12 +723,6 @@ LLVOAvatar::LLVOAvatar(
         mAppearanceAnimSetByUser(FALSE),
         mLastAppearanceBlendTime(0.f),
         mAppearanceAnimating(FALSE),
-        mHeadLayerSet( NULL ),
-        mUpperBodyLayerSet( NULL ),
-        mLowerBodyLayerSet( NULL ),
-        mEyesLayerSet( NULL ),
-        mSkirtLayerSet( NULL ),
-        mRenderPriority(1.0f),
         mNameString(),
         mTitle(),
         mNameAway(FALSE),
@@ -670,45 +734,43 @@ LLVOAvatar::LLVOAvatar(
         mRegionCrossingCount(0),
         mFirstTEMessageReceived( FALSE ),
         mFirstAppearanceMessageReceived( FALSE ),
-        mHeadBakedLoaded(FALSE),
-        mHeadMaskDiscard(-1),
-        mUpperBakedLoaded(FALSE),
-        mUpperMaskDiscard(-1),
-        mLowerBakedLoaded(FALSE),
-        mLowerMaskDiscard(-1),
-        mEyesBakedLoaded(FALSE),
-        mSkirtBakedLoaded(FALSE),
-        mHeadMaskTexName(0),
-        mUpperMaskTexName(0),
-        mLowerMaskTexName(0),
         mCulled( FALSE ),
         mVisibilityRank(0),
-        mFadeTime(0.f),
-        mLastFadeTime(0.f),
-        mLastFadeDistance(1.f),
         mTexSkinColor( NULL ),
         mTexHairColor( NULL ),
         mTexEyeColor( NULL ),
         mNeedsSkin(FALSE),
         mUpdatePeriod(1),
-        mFullyLoadedInitialized(FALSE)
+        mFullyLoadedInitialized(FALSE),
+        mHasBakedHair( FALSE )
 {
         LLMemType mt(LLMemType::MTYPE_AVATAR);
-        
         //VTResume();  // VTune
         
         // mVoiceVisualizer is created by the hud effects manager and uses the HUD Effects pipeline
-        bool needsSendToSim = false; // currently, this HUD effect doesn't need to pack and unpack data to do its job
+        const bool needsSendToSim = false; // currently, this HUD effect doesn't need to pack and unpack data to do its job
         mVoiceVisualizer = ( LLVoiceVisualizer *)LLHUDManager::getInstance()->createViewerEffect( LLHUDObject::LL_HUD_EFFECT_VOICE_VISUALIZER, needsSendToSim );
 
         lldebugs << "LLVOAvatar Constructor (0x" << this << ") id:" << mID << llendl;
 
         mPelvisp = NULL;
 
-        for( S32 i=0; i<LOCTEX_NUM_ENTRIES; i++ )
+        for( S32 i=0; i<TEX_NUM_INDICES; i++ )
+        {
+                if (isIndexLocalTexture((ETextureIndex)i))
+                {
+                        mLocalTextureData[(ETextureIndex)i] = LocalTextureData();
+                }
+        }
+
+        mBakedTextureData.resize(BAKED_NUM_INDICES);
+        for (U32 i = 0; i < mBakedTextureData.size(); i++ )
         {
-                mLocalTextureBaked[i] = FALSE;
-                mLocalTextureDiscard[i] = MAX_DISCARD_LEVEL+1;
+                mBakedTextureData[i].mLastTextureIndex = IMG_DEFAULT_AVATAR;
+                mBakedTextureData[i].mTexLayerSet = NULL;
+                mBakedTextureData[i].mIsLoaded = false;
+                mBakedTextureData[i].mMaskTexName = 0;
+                mBakedTextureData[i].mTextureIndex = getTextureIndex((EBakedTextureIndex)i);
         }
 
         mDirtyMesh = TRUE;      // Dirty geometry, need to regenerate.
@@ -746,7 +808,7 @@ LLVOAvatar::LLVOAvatar(
         mImpostorDistance = 0;
         mImpostorPixelArea = 0;
 
-        setNumTEs(TEX_NUM_ENTRIES);
+        setNumTEs(TEX_NUM_INDICES);
 
         mbCanSelect = TRUE;
 
@@ -763,7 +825,7 @@ LLVOAvatar::LLVOAvatar(
 
         mShadowImagep = gImageList.getImageFromFile("foot_shadow.j2c");
         gGL.getTexUnit(0)->bind(mShadowImagep.get());
-        mShadowImagep->setClamp(TRUE, TRUE);
+        mShadowImagep->setAddressMode(LLTexUnit::TAM_CLAMP);
         
         mInAir = FALSE;
 
@@ -779,118 +841,71 @@ LLVOAvatar::LLVOAvatar(
         //-------------------------------------------------------------------------
         mRoot.setName( "mRoot" );
 
-        // skinned mesh objects
-        mHairLOD.setName("mHairLOD");
-        mHairMesh0.setName("mHairMesh0");
-        mHairMesh0.setMeshID(MESH_ID_HAIR);
-        mHairMesh1.setName("mHairMesh1");
-        mHairMesh2.setName("mHairMesh2");
-        mHairMesh3.setName("mHairMesh3");
-        mHairMesh4.setName("mHairMesh4");
-        mHairMesh5.setName("mHairMesh5");
-        
-        mHairMesh0.setIsTransparent(TRUE);
-        mHairMesh1.setIsTransparent(TRUE);
-        mHairMesh2.setIsTransparent(TRUE);
-        mHairMesh3.setIsTransparent(TRUE);
-        mHairMesh4.setIsTransparent(TRUE);
-        mHairMesh5.setIsTransparent(TRUE);
-
-        mHeadLOD.setName("mHeadLOD");
-        mHeadMesh0.setName("mHeadMesh0");
-        mHeadMesh0.setMeshID(MESH_ID_HEAD);
-        mHeadMesh1.setName("mHeadMesh1");
-        mHeadMesh2.setName("mHeadMesh2");
-        mHeadMesh3.setName("mHeadMesh3");
-        mHeadMesh4.setName("mHeadMesh4");
-        
-        mEyeLashLOD.setName("mEyeLashLOD");
-        mEyeLashMesh0.setName("mEyeLashMesh0");
-        mEyeLashMesh0.setMeshID(MESH_ID_HEAD);
-        mEyeLashMesh0.setIsTransparent(TRUE);
-
-        mUpperBodyLOD.setName("mUpperBodyLOD");
-        mUpperBodyMesh0.setName("mUpperBodyMesh0");
-        mUpperBodyMesh0.setMeshID(MESH_ID_UPPER_BODY);
-        mUpperBodyMesh1.setName("mUpperBodyMesh1");
-        mUpperBodyMesh2.setName("mUpperBodyMesh2");
-        mUpperBodyMesh3.setName("mUpperBodyMesh3");
-        mUpperBodyMesh4.setName("mUpperBodyMesh4");
-
-        mLowerBodyLOD.setName("mLowerBodyLOD");
-        mLowerBodyMesh0.setName("mLowerBodyMesh0");
-        mLowerBodyMesh0.setMeshID(MESH_ID_LOWER_BODY);
-        mLowerBodyMesh1.setName("mLowerBodyMesh1");
-        mLowerBodyMesh2.setName("mLowerBodyMesh2");
-        mLowerBodyMesh3.setName("mLowerBodyMesh3");
-        mLowerBodyMesh4.setName("mLowerBodyMesh4");
-
-        mEyeBallLeftLOD.setName("mEyeBallLeftLOD");
-        mEyeBallLeftMesh0.setName("mEyeBallLeftMesh0");
-        mEyeBallLeftMesh1.setName("mEyeBallLeftMesh1");
-
-        mEyeBallRightLOD.setName("mEyeBallRightLOD");
-        mEyeBallRightMesh0.setName("mEyeBallRightMesh0");
-        mEyeBallRightMesh1.setName("mEyeBallRightMesh1");
-
-        mSkirtLOD.setName("mSkirtLOD");
-        mSkirtMesh0.setName("mSkirtMesh0");
-        mSkirtMesh0.setMeshID(MESH_ID_SKIRT);
-        mSkirtMesh1.setName("mSkirtMesh1");
-        mSkirtMesh2.setName("mSkirtMesh2");
-        mSkirtMesh3.setName("mSkirtMesh3");
-        mSkirtMesh4.setName("mSkirtMesh4");
-
-        mSkirtMesh0.setIsTransparent(TRUE);
-        mSkirtMesh1.setIsTransparent(TRUE);
-        mSkirtMesh2.setIsTransparent(TRUE);
-        mSkirtMesh3.setIsTransparent(TRUE);
-        mSkirtMesh4.setIsTransparent(TRUE);
-
-        // set the pick names for the avatar
-        mHeadMesh0.setPickName( LLViewerJoint::PN_0 );
-        mHeadMesh1.setPickName( LLViewerJoint::PN_0 );
-        mHeadMesh2.setPickName( LLViewerJoint::PN_0 );
-        mHeadMesh3.setPickName( LLViewerJoint::PN_0 );
-        mHeadMesh4.setPickName( LLViewerJoint::PN_0 );
-        mEyeLashMesh0.setPickName( LLViewerJoint::PN_0 );
-
-        mUpperBodyMesh0.setPickName( LLViewerJoint::PN_1 );
-        mUpperBodyMesh1.setPickName( LLViewerJoint::PN_1 );
-        mUpperBodyMesh2.setPickName( LLViewerJoint::PN_1 );
-        mUpperBodyMesh3.setPickName( LLViewerJoint::PN_1 );
-        mUpperBodyMesh4.setPickName( LLViewerJoint::PN_1 );
-
-        mLowerBodyMesh0.setPickName( LLViewerJoint::PN_2 );
-        mLowerBodyMesh1.setPickName( LLViewerJoint::PN_2 );
-        mLowerBodyMesh2.setPickName( LLViewerJoint::PN_2 );
-        mLowerBodyMesh3.setPickName( LLViewerJoint::PN_2 );
-        mLowerBodyMesh4.setPickName( LLViewerJoint::PN_2 );
-
-        mEyeBallLeftMesh0.setPickName( LLViewerJoint::PN_3 );
-        mEyeBallLeftMesh1.setPickName( LLViewerJoint::PN_3 );
-        mEyeBallRightMesh0.setPickName( LLViewerJoint::PN_3 );
-        mEyeBallRightMesh1.setPickName( LLViewerJoint::PN_3 );
-
-        mHairMesh0.setPickName( LLViewerJoint::PN_4);
-        mHairMesh1.setPickName( LLViewerJoint::PN_4);
-        mHairMesh2.setPickName( LLViewerJoint::PN_4);
-        mHairMesh3.setPickName( LLViewerJoint::PN_4);
-        mHairMesh4.setPickName( LLViewerJoint::PN_4);
-        mHairMesh5.setPickName( LLViewerJoint::PN_4);
-
-        mSkirtMesh0.setPickName( LLViewerJoint::PN_5 );
-        mSkirtMesh1.setPickName( LLViewerJoint::PN_5 );
-        mSkirtMesh2.setPickName( LLViewerJoint::PN_5 );
-        mSkirtMesh3.setPickName( LLViewerJoint::PN_5 );
-        mSkirtMesh4.setPickName( LLViewerJoint::PN_5 );
-
-        // material settings
-
-        mEyeBallLeftMesh0.setSpecular( LLColor4( 1.0f, 1.0f, 1.0f, 1.0f ), 1.f );
-        mEyeBallLeftMesh1.setSpecular( LLColor4( 1.0f, 1.0f, 1.0f, 1.0f ), 1.f );
-        mEyeBallRightMesh0.setSpecular( LLColor4( 1.0f, 1.0f, 1.0f, 1.0f ), 1.f );
-        mEyeBallRightMesh1.setSpecular( LLColor4( 1.0f, 1.0f, 1.0f, 1.0f ), 1.f );
+        for (LLVOAvatarDictionary::mesh_map_t::const_iterator iter = LLVOAvatarDictionary::getInstance()->getMeshes().begin();
+                 iter != LLVOAvatarDictionary::getInstance()->getMeshes().end();
+                 iter++)
+        {
+                const EMeshIndex mesh_index = iter->first;
+                const LLVOAvatarDictionary::MeshDictionaryEntry *mesh_dict = iter->second;
+
+                LLViewerJoint* joint = new LLViewerJoint();
+                joint->setName(mesh_dict->mName);
+                joint->setMeshID(mesh_index);
+                mMeshLOD.push_back(joint);
+                
+                /* mHairLOD.setName("mHairLOD");
+                   mHairMesh0.setName("mHairMesh0");
+                   mHairMesh0.setMeshID(MESH_ID_HAIR);
+                   mHairMesh1.setName("mHairMesh1"); */
+                for (U32 lod = 0; lod < mesh_dict->mLOD; lod++)
+                {
+                        LLViewerJointMesh* mesh = new LLViewerJointMesh();
+                        std::string mesh_name = "m" + mesh_dict->mName + boost::lexical_cast<std::string>(lod);
+                        // We pre-pended an m - need to capitalize first character for camelCase
+                        mesh_name[1] = toupper(mesh_name[1]);
+                        mesh->setName(mesh_name);
+                        mesh->setMeshID(mesh_index);
+                        mesh->setPickName(mesh_dict->mPickName);
+                        switch((int)mesh_index)
+                        {
+                                case MESH_ID_HAIR:
+                                        mesh->setIsTransparent(TRUE);
+                                        break;
+                                case MESH_ID_SKIRT:
+                                        mesh->setIsTransparent(TRUE);
+                                        break;
+                                case MESH_ID_EYEBALL_LEFT:
+                                case MESH_ID_EYEBALL_RIGHT:
+                                        mesh->setSpecular( LLColor4( 1.0f, 1.0f, 1.0f, 1.0f ), 1.f );
+                                        break;
+                        }
+
+                        joint->mMeshParts.push_back(mesh);
+                }
+        }
+
+        //-------------------------------------------------------------------------
+        // associate baked textures with meshes
+        //-------------------------------------------------------------------------
+        for (LLVOAvatarDictionary::mesh_map_t::const_iterator iter = LLVOAvatarDictionary::getInstance()->getMeshes().begin();
+                 iter != LLVOAvatarDictionary::getInstance()->getMeshes().end();
+                 iter++)
+        {
+                const EMeshIndex mesh_index = iter->first;
+                const LLVOAvatarDictionary::MeshDictionaryEntry *mesh_dict = iter->second;
+                const EBakedTextureIndex baked_texture_index = mesh_dict->mBakedID;
+
+                // Skip it if there's no associated baked texture.
+                if (baked_texture_index == BAKED_NUM_INDICES) continue;
+
+                for (std::vector<LLViewerJointMesh* >::iterator iter = mMeshLOD[mesh_index]->mMeshParts.begin();
+                         iter != mMeshLOD[mesh_index]->mMeshParts.end(); iter++)
+                {
+                        LLViewerJointMesh* mesh = (LLViewerJointMesh*) *iter;
+                        mBakedTextureData[(int)baked_texture_index].mMeshes.push_back(mesh);
+                }
+        }
+
 
         //-------------------------------------------------------------------------
         // register motions
@@ -989,20 +1004,11 @@ LLVOAvatar::~LLVOAvatar()
 
         mNumJoints = 0;
 
-        delete mHeadLayerSet;
-        mHeadLayerSet = NULL;
-
-        delete mUpperBodyLayerSet;
-        mUpperBodyLayerSet = NULL;
-
-        delete mLowerBodyLayerSet;
-        mLowerBodyLayerSet = NULL;
-
-        delete mEyesLayerSet;
-        mEyesLayerSet = NULL;
-
-        delete mSkirtLayerSet;
-        mSkirtLayerSet = NULL;
+        for (U32 i = 0; i < mBakedTextureData.size(); i++)
+        {
+                delete mBakedTextureData[i].mTexLayerSet;
+                mBakedTextureData[i].mTexLayerSet = NULL;
+        }
 
         std::for_each(mAttachmentPoints.begin(), mAttachmentPoints.end(), DeletePairedPointer());
         mAttachmentPoints.clear();
@@ -1016,6 +1022,16 @@ LLVOAvatar::~LLVOAvatar()
 
         std::for_each(mMeshes.begin(), mMeshes.end(), DeletePairedPointer());
         mMeshes.clear();
+
+        for (std::vector<LLViewerJoint*>::iterator jointIter = mMeshLOD.begin();
+                jointIter != mMeshLOD.end(); jointIter++)
+        {
+                LLViewerJoint* joint = (LLViewerJoint *) *jointIter;
+                std::for_each(joint->mMeshParts.begin(), joint->mMeshParts.end(), DeletePointer());
+                joint->mMeshParts.clear();
+        }
+        std::for_each(mMeshLOD.begin(), mMeshLOD.end(), DeletePointer());
+        mMeshLOD.clear();
         
         mDead = TRUE;
         
@@ -1047,45 +1063,34 @@ BOOL LLVOAvatar::isFullyBaked()
 {
         if (mIsDummy) return TRUE;
         if (getNumTEs() == 0) return FALSE;
-        
-        BOOL head_baked = ( getTEImage( TEX_HEAD_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-        BOOL upper_baked = ( getTEImage( TEX_UPPER_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-        BOOL lower_baked = ( getTEImage( TEX_LOWER_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-        BOOL eyes_baked = ( getTEImage( TEX_EYES_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-        BOOL skirt_baked = ( getTEImage( TEX_SKIRT_BAKED )->getID() != IMG_DEFAULT_AVATAR );
 
-        if (isWearingWearableType(WT_SKIRT))
-        {
-                return head_baked && upper_baked && lower_baked && eyes_baked && skirt_baked;
-        }
-        else
+        for (U32 i = 0; i < mBakedTextureData.size(); i++)
         {
-                return head_baked && upper_baked && lower_baked && eyes_baked;
+                if (!isTextureDefined(mBakedTextureData[i].mTextureIndex)
+                        && ( (i != BAKED_SKIRT) || isWearingWearableType(WT_SKIRT) ) )
+                {
+                        return FALSE;
+                }
         }
+        return TRUE;
 }
 
-void LLVOAvatar::deleteLayerSetCaches()
+void LLVOAvatar::deleteLayerSetCaches(bool clearAll)
 {
-        if( mHeadLayerSet )                     mHeadLayerSet->deleteCaches();
-        if( mUpperBodyLayerSet )        mUpperBodyLayerSet->deleteCaches();
-        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)
+        for (U32 i = 0; i < mBakedTextureData.size(); i++)
         {
-                glDeleteTextures(1, (GLuint*)&mLowerMaskTexName);
-                mLowerMaskTexName = 0 ;
+                if (mBakedTextureData[i].mTexLayerSet)
+                {
+                        if ((i != BAKED_HAIR || mIsSelf) && !clearAll)          // Backwards compatibility - can be removed after hair baking is mandatory on the grid
+                        {
+                                mBakedTextureData[i].mTexLayerSet->deleteCaches();
+                        }
+                }
+                if (mBakedTextureData[i].mMaskTexName)
+                {
+                        glDeleteTextures(1, (GLuint*)&(mBakedTextureData[i].mMaskTexName));
+                        mBakedTextureData[i].mMaskTexName = 0 ;
+                }
         }
 }
 
@@ -1156,7 +1161,7 @@ void LLVOAvatar::dumpBakedStatus()
                         llcont << " DEAD ("<< inst->getNumRefs() << " refs)";
                 }
 
-                if( inst->mIsSelf )
+                if( inst->isSelf() )
                 {
                         llcont << " (self)";
                 }
@@ -1183,130 +1188,26 @@ void LLVOAvatar::dumpBakedStatus()
                 else
                 {
                         llcont << " Unbaked (";
-                        if( inst->getTEImage( TEX_HEAD_BAKED )->getID()  == IMG_DEFAULT_AVATAR )
-                        {
-                                llcont << " head";
-                        }
-
-                        if( inst->getTEImage( TEX_UPPER_BAKED )->getID() == IMG_DEFAULT_AVATAR )
-                        {
-                                llcont << " upper";
-                        }
-
-                        if( inst->getTEImage( TEX_LOWER_BAKED )->getID() == IMG_DEFAULT_AVATAR )
-                        {
-                                llcont << " lower";
-                        }
-
-                        if( inst->getTEImage( TEX_EYES_BAKED )->getID()  == IMG_DEFAULT_AVATAR )
-                        {
-                                llcont << " eyes";
-                        }
-
-                        if (inst->isWearingWearableType(WT_SKIRT))
+                        
+                        for (LLVOAvatarDictionary::baked_map_t::const_iterator iter = LLVOAvatarDictionary::getInstance()->getBakedTextures().begin();
+                                 iter != LLVOAvatarDictionary::getInstance()->getBakedTextures().end();
+                                 iter++)
                         {
-                                if( inst->getTEImage( TEX_SKIRT_BAKED )->getID()  == IMG_DEFAULT_AVATAR )
+                                const LLVOAvatarDictionary::BakedDictionaryEntry *baked_dict = iter->second;
+                                const ETextureIndex index = baked_dict->mTextureIndex;
+                                if (!inst->isTextureDefined(index))
                                 {
-                                        llcont << " skirt";
+                                        llcont << " " << LLVOAvatarDictionary::getInstance()->getTexture(index)->mName;
                                 }
                         }
 
-                        llcont << " ) " << inst->getUnbakedPixelAreaRank() << "/" << LLVOAvatar::sMaxOtherAvatarsToComposite;
+                        llcont << " ) " << inst->getUnbakedPixelAreaRank();
                         if( inst->isCulled() )
                         {
                                 llcont << " culled";
                         }
                 }
                 llcont << llendl;
-/*
-                if( inst->isDead() )
-                {
-                        llinfos << "DEAD LIST " << llendl;
-
-                        
-                        for( S32 i = 0; i < inst->mOwners.count(); i++ )
-                        {
-                                llinfos << i << llendl;
-                                LLPointer<LLViewerObject>* owner = (LLPointer<LLViewerObject>*)(inst->mOwners[i]);
-                                LLPointer<LLViewerObject>* cur;
-                                if( !owner->mName.isEmpty() )
-                                {
-                                        llinfos << "    " << owner->mName << llendl;
-                                }
-
-                                LLViewerObject* key_vo;
-                                for( key_vo = gObjectList.mActiveObjects.getFirstKey(); key_vo; key_vo = gObjectList.mActiveObjects.getNextKey() )
-                                {
-                                        cur = &(gObjectList.mActiveObjects.getCurrentDataWithoutIncrement());
-                                        if( cur == owner )
-                                        {
-                                                llinfos << "    gObjectList.mActiveObjects" << llendl;
-                                        }
-                                }
-
-                                for( key_vo = gObjectList.mAvatarObjects.getFirstKey(); key_vo; key_vo = gObjectList.mAvatarObjects.getNextKey() )
-                                {
-                                        cur = &(gObjectList.mAvatarObjects.getCurrentDataWithoutIncrement());   
-                                        if( cur == owner )
-                                        {
-                                                llinfos << "    gObjectList.mAvatarObjects" << llendl;
-                                        }
-                                }
-
-                                LLUUID id;
-                                for( id = gObjectList.mDeadObjects.getFirstKey(); id; id = gObjectList.mDeadObjects.getNextKey() )
-                                {
-                                        cur = &(gObjectList.mDeadObjects.getCurrentDataWithoutIncrement());
-                                        if( cur == owner )
-                                        {
-                                                llinfos << "    gObjectList.mDeadObjects" << llendl;
-                                        }
-                                }
-
-
-                                for( id = gObjectList.mUUIDObjectMap.getFirstKey(); id; id = gObjectList.mUUIDObjectMap.getNextKey() )
-                                {
-                                        cur = &(gObjectList.mUUIDObjectMap.getCurrentDataWithoutIncrement());
-                                        if( cur == owner )
-                                        {
-                                                llinfos << "    gObjectList.mUUIDObjectMap" << llendl;
-                                        }
-                                }
-
-                                S32 j;
-                                S32 k;
-                                for( j = 0; j < 16; j++ )
-                                {
-                                        for( k = 0; k < 10; k++ )
-                                        {
-                                                cur = &(gObjectList.mCloseObjects[j][k]);
-                                                if( cur == owner )
-                                                {
-                                                        llinfos << "    gObjectList.mCloseObjects" << llendl;
-                                                }
-                                        }
-                                }
-
-                                for( j = 0; j < gObjectList.mObjects.count(); j++ )
-                                {
-                                        cur = &(gObjectList.mObjects[j]);
-                                        if( cur == owner )
-                                        {
-                                                llinfos << "    gObjectList.mObjects" << llendl;
-                                        }
-                                }
-
-                                for( j = 0; j < gObjectList.mMapObjects.count(); j++ )
-                                {
-                                        cur = &(gObjectList.mMapObjects[j]);
-                                        if( cur == owner )
-                                        {
-                                                llinfos << "    gObjectList.mMapObjects" << llendl;
-                                        }
-                                }
-                        }
-                }
-                */
         }
 }
 
@@ -1318,11 +1219,10 @@ void LLVOAvatar::restoreGL()
         {
                 LLVOAvatar* inst = (LLVOAvatar*) *iter;
                 inst->setCompositeUpdatesEnabled( TRUE );
-                inst->invalidateComposite( inst->mHeadLayerSet,         FALSE );
-                inst->invalidateComposite( inst->mLowerBodyLayerSet,    FALSE );
-                inst->invalidateComposite( inst->mUpperBodyLayerSet,    FALSE );
-                inst->invalidateComposite( inst->mEyesLayerSet, FALSE );
-                inst->invalidateComposite( inst->mSkirtLayerSet,        FALSE );
+                for (U32 i = 0; i < inst->mBakedTextureData.size(); i++)
+                {
+                        inst->invalidateComposite( inst->mBakedTextureData[i].mTexLayerSet, FALSE );
+                }
                 inst->updateMeshTextures();
         }
 }
@@ -1347,7 +1247,7 @@ void LLVOAvatar::resetImpostors()
 }
 
 // static
-void LLVOAvatar::deleteCachedImages()
+void LLVOAvatar::deleteCachedImages(bool clearAll)
 {
         if (LLTexLayerSet::sHasCaches)
         {
@@ -1356,16 +1256,16 @@ void LLVOAvatar::deleteCachedImages()
                 iter != LLCharacter::sInstances.end(); ++iter)
                 {
                         LLVOAvatar* inst = (LLVOAvatar*) *iter;
-                        inst->deleteLayerSetCaches();
+                        inst->deleteLayerSetCaches(clearAll);
                 }
                 LLTexLayerSet::sHasCaches = FALSE;
         }
         
-        for( GLuint* namep = (GLuint*)sScratchTexNames.getFirstData(); 
+        for( LLGLuint* namep = sScratchTexNames.getFirstData(); 
                  namep; 
-                 namep = (GLuint*)sScratchTexNames.getNextData() )
+                 namep = sScratchTexNames.getNextData() )
         {
-                glDeleteTextures(1, namep );
+                LLImageGL::deleteTextures(1, (U32 *)namep );
                 stop_glerror();
         }
 
@@ -1389,8 +1289,6 @@ void LLVOAvatar::deleteCachedImages()
 //------------------------------------------------------------------------
 void LLVOAvatar::initClass()
 { 
-        LLVOAvatar::sMaxOtherAvatarsToComposite = gSavedSettings.getS32("AvatarCompositeLimit");
-
         std::string xmlFile;
 
         xmlFile = gDirUtilp->getExpandedFilename(LL_PATH_CHARACTER,AVATAR_DEFAULT_CHAR) + "_lad.xml";
@@ -1454,44 +1352,45 @@ void LLVOAvatar::initClass()
         // Process XML data
 
         // avatar_skeleton.xml
-        llassert(!sSkeletonInfo);
-        sSkeletonInfo = new LLVOAvatarSkeletonInfo;
-        if (!sSkeletonInfo->parseXml(sSkeletonXMLTree.getRoot()))
+        llassert(!sAvatarSkeletonInfo);
+        sAvatarSkeletonInfo = new LLVOAvatarSkeletonInfo;
+        if (!sAvatarSkeletonInfo->parseXml(sSkeletonXMLTree.getRoot()))
         {
                 llerrs << "Error parsing skeleton XML file: " << skeleton_path << llendl;
         }
         // parse avatar_lad.xml
-        llassert(!sAvatarInfo);
-        sAvatarInfo = new LLVOAvatarInfo;
-        if (!sAvatarInfo->parseXmlSkeletonNode(root))
+        llassert(!sAvatarXmlInfo);
+        sAvatarXmlInfo = new LLVOAvatarXmlInfo;
+        if (!sAvatarXmlInfo->parseXmlSkeletonNode(root))
         {
                 llerrs << "Error parsing skeleton node in avatar XML file: " << skeleton_path << llendl;
         }
-        if (!sAvatarInfo->parseXmlMeshNodes(root))
+        if (!sAvatarXmlInfo->parseXmlMeshNodes(root))
         {
                 llerrs << "Error parsing skeleton node in avatar XML file: " << skeleton_path << llendl;
         }
-        if (!sAvatarInfo->parseXmlColorNodes(root))
+        if (!sAvatarXmlInfo->parseXmlColorNodes(root))
         {
                 llerrs << "Error parsing skeleton node in avatar XML file: " << skeleton_path << llendl;
         }
-        if (!sAvatarInfo->parseXmlLayerNodes(root))
+        if (!sAvatarXmlInfo->parseXmlLayerNodes(root))
         {
                 llerrs << "Error parsing skeleton node in avatar XML file: " << skeleton_path << llendl;
         }
-        if (!sAvatarInfo->parseXmlDriverNodes(root))
+        if (!sAvatarXmlInfo->parseXmlDriverNodes(root))
         {
                 llerrs << "Error parsing skeleton node in avatar XML file: " << skeleton_path << llendl;
         }
+
 }
 
 
 void LLVOAvatar::cleanupClass()
 {
-        delete sAvatarInfo;
-        sAvatarInfo = NULL;
-        delete sSkeletonInfo;
-        sSkeletonInfo = NULL;
+        delete sAvatarXmlInfo;
+        sAvatarXmlInfo = NULL;
+        delete sAvatarSkeletonInfo;
+        sAvatarSkeletonInfo = NULL;
         sSkeletonXMLTree.cleanup();
         sXMLTree.cleanup();
 }
@@ -1554,7 +1453,7 @@ void LLVOAvatar::getSpatialExtents(LLVector3& newMin, LLVector3& newMax)
         newMax = pos + buffer;
         
         //stretch bounding box by joint positions
-        for (mesh_map_t::iterator i = mMeshes.begin(); i != mMeshes.end(); ++i)
+        for (polymesh_map_t::iterator i = mMeshes.begin(); i != mMeshes.end(); ++i)
         {
                 LLPolyMesh* mesh = i->second;
                 for (S32 joint_num = 0; joint_num < mesh->mJointRenderData.count(); joint_num++)
@@ -1573,7 +1472,7 @@ void LLVOAvatar::getSpatialExtents(LLVector3& newMin, LLVector3& newMax)
         {
                 LLViewerJointAttachment* attachment = iter->second;
 
-                if(!attachment->getValid())
+                if (!attachment->getValid())
                 {
                         continue ;
                 }
@@ -1690,7 +1589,6 @@ BOOL LLVOAvatar::lineSegmentIntersect(const LLVector3& start, const LLVector3& e
         return FALSE;
 }
 
-
 //-----------------------------------------------------------------------------
 // parseSkeletonFile()
 //-----------------------------------------------------------------------------
@@ -1734,7 +1632,7 @@ BOOL LLVOAvatar::parseSkeletonFile(const std::string& filename)
 //-----------------------------------------------------------------------------
 // setupBone()
 //-----------------------------------------------------------------------------
-BOOL LLVOAvatar::setupBone(LLVOAvatarBoneInfo* info, LLViewerJoint* parent)
+BOOL LLVOAvatar::setupBone(const LLVOAvatarBoneInfo* info, LLViewerJoint* parent, S32 &volume_num, S32 &joint_num)
 {
         LLMemType mt(LLMemType::MTYPE_AVATAR);
         
@@ -1742,7 +1640,7 @@ BOOL LLVOAvatar::setupBone(LLVOAvatarBoneInfo* info, LLViewerJoint* parent)
 
         if (info->mIsJoint)
         {
-                joint = (LLViewerJoint*)getCharacterJoint(sCurJoint);
+                joint = (LLViewerJoint*)getCharacterJoint(joint_num);
                 if (!joint)
                 {
                         llwarns << "Too many bones" << llendl;
@@ -1752,12 +1650,12 @@ BOOL LLVOAvatar::setupBone(LLVOAvatarBoneInfo* info, LLViewerJoint* parent)
         }
         else // collision volume
         {
-                if (sCurVolume >= (S32)mNumCollisionVolumes)
+                if (volume_num >= (S32)mNumCollisionVolumes)
                 {
                         llwarns << "Too many bones" << llendl;
                         return FALSE;
                 }
-                joint = (LLViewerJoint*)(&mCollisionVolumes[sCurVolume]);
+                joint = (LLViewerJoint*)(&mCollisionVolumes[volume_num]);
 
                 joint->setName( info->mName );
         }
@@ -1779,19 +1677,19 @@ BOOL LLVOAvatar::setupBone(LLVOAvatarBoneInfo* info, LLViewerJoint* parent)
         if (info->mIsJoint)
         {
                 joint->setSkinOffset( info->mPivot );
-                sCurJoint++;
+                joint_num++;
         }
         else // collision volume
         {
-                sCurVolume++;
+                volume_num++;
         }
 
         // setup children
-        LLVOAvatarBoneInfo::child_list_t::iterator iter;
+        LLVOAvatarBoneInfo::child_list_t::const_iterator iter;
         for (iter = info->mChildList.begin(); iter != info->mChildList.end(); iter++)
         {
                 LLVOAvatarBoneInfo *child_info = *iter;
-                if (!setupBone(child_info, joint))
+                if (!setupBone(child_info, joint, volume_num, joint_num))
                 {
                         return FALSE;
                 }
@@ -1803,7 +1701,7 @@ BOOL LLVOAvatar::setupBone(LLVOAvatarBoneInfo* info, LLViewerJoint* parent)
 //-----------------------------------------------------------------------------
 // buildSkeleton()
 //-----------------------------------------------------------------------------
-BOOL LLVOAvatar::buildSkeleton(LLVOAvatarSkeletonInfo *info)
+BOOL LLVOAvatar::buildSkeleton(const LLVOAvatarSkeletonInfo *info)
 {
         LLMemType mt(LLMemType::MTYPE_AVATAR);
         
@@ -1828,14 +1726,13 @@ BOOL LLVOAvatar::buildSkeleton(LLVOAvatarSkeletonInfo *info)
                 }
         }
 
-        sCurJoint = 0;
-        sCurVolume = 0;
-
-        LLVOAvatarSkeletonInfo::bone_info_list_t::iterator iter;
+        S32 current_joint_num = 0;
+        S32 current_volume_num = 0;
+        LLVOAvatarSkeletonInfo::bone_info_list_t::const_iterator iter;
         for (iter = info->mBoneInfoList.begin(); iter != info->mBoneInfoList.end(); iter++)
         {
                 LLVOAvatarBoneInfo *info = *iter;
-                if (!setupBone(info, NULL))
+                if (!setupBone(info, NULL, current_volume_num, current_joint_num))
                 {
                         llerrs << "Error parsing bone in skeleton file" << llendl;
                         return FALSE;
@@ -1901,43 +1798,17 @@ void LLVOAvatar::buildCharacter()
         //-------------------------------------------------------------------------
         // clear mesh data
         //-------------------------------------------------------------------------
-        mHairMesh0.setMesh(NULL);
-        mHairMesh1.setMesh(NULL);
-        mHairMesh2.setMesh(NULL);
-        mHairMesh3.setMesh(NULL);
-        mHairMesh4.setMesh(NULL);
-        mHairMesh5.setMesh(NULL);
-
-        mHeadMesh0.setMesh(NULL);
-        mHeadMesh1.setMesh(NULL);
-        mHeadMesh2.setMesh(NULL);
-        mHeadMesh3.setMesh(NULL);
-        mHeadMesh4.setMesh(NULL);
-
-        mEyeLashMesh0.setMesh(NULL);
-
-        mUpperBodyMesh0.setMesh(NULL);
-        mUpperBodyMesh1.setMesh(NULL);
-        mUpperBodyMesh2.setMesh(NULL);
-        mUpperBodyMesh3.setMesh(NULL);
-        mUpperBodyMesh4.setMesh(NULL);
-
-        mLowerBodyMesh0.setMesh(NULL);
-        mLowerBodyMesh1.setMesh(NULL);
-        mLowerBodyMesh2.setMesh(NULL);
-        mLowerBodyMesh3.setMesh(NULL);
-        mLowerBodyMesh4.setMesh(NULL);
-
-        mEyeBallLeftMesh0.setMesh(NULL);
-        mEyeBallLeftMesh1.setMesh(NULL);
-        mEyeBallRightMesh0.setMesh(NULL);
-        mEyeBallRightMesh1.setMesh(NULL);
-
-        mSkirtMesh0.setMesh(NULL);
-        mSkirtMesh1.setMesh(NULL);
-        mSkirtMesh2.setMesh(NULL);
-        mSkirtMesh3.setMesh(NULL);
-        mSkirtMesh4.setMesh(NULL);      
+        for (std::vector<LLViewerJoint*>::iterator jointIter = mMeshLOD.begin();
+                jointIter != mMeshLOD.end(); jointIter++)
+        {
+                LLViewerJoint* joint = (LLViewerJoint*) *jointIter;
+                for (std::vector<LLViewerJointMesh*>::iterator meshIter = joint->mMeshParts.begin();
+                        meshIter != joint->mMeshParts.end(); meshIter++)
+                {
+                        LLViewerJointMesh * mesh = (LLViewerJointMesh *) *meshIter;
+                        mesh->setMesh(NULL);
+                }
+        }
 
         //-------------------------------------------------------------------------
         // (re)load our skeleton and meshes
@@ -2048,7 +1919,12 @@ void LLVOAvatar::buildCharacter()
         }
 
         startDefaultMotions();
-        
+
+        //-------------------------------------------------------------------------
+        // restart any currently active motions
+        //-------------------------------------------------------------------------
+        processAnimationStateChanges();
+
         mIsBuilt = TRUE;
         stop_glerror();
 
@@ -2262,21 +2138,18 @@ void LLVOAvatar::releaseMeshData()
         //llinfos << "Releasing" << llendl;
 
         // cleanup mesh data
-        mHairLOD.setValid(FALSE, TRUE);
-        mHeadLOD.setValid(FALSE, TRUE);
-        mEyeLashLOD.setValid(FALSE, TRUE);
-        mUpperBodyLOD.setValid(FALSE, TRUE);
-        mLowerBodyLOD.setValid(FALSE, TRUE);
-        mEyeBallLeftLOD.setValid(FALSE, TRUE);
-        mEyeBallRightLOD.setValid(FALSE, TRUE);
-        mSkirtLOD.setValid(FALSE, TRUE);
+        for (std::vector<LLViewerJoint*>::iterator iter = mMeshLOD.begin();
+                iter != mMeshLOD.end(); iter++)
+        {
+                LLViewerJoint* joint = (LLViewerJoint*) *iter;
+                joint->setValid(FALSE, TRUE);
+        }
 
         //cleanup data
         if (mDrawable.notNull())
         {
                 LLFace* facep = mDrawable->getFace(0);
                 facep->setSize(0, 0);
-
                 for(S32 i = mNumInitFaces ; i < mDrawable->getNumFaces(); i++)
                 {
                         facep = mDrawable->getFace(i);
@@ -2339,34 +2212,25 @@ void LLVOAvatar::updateMeshData()
         {
                 stop_glerror();
 
-                LLViewerJoint* av_parts[8] ;
-                av_parts[0] = &mEyeBallLeftLOD ;
-                av_parts[1] = &mEyeBallRightLOD ;
-                av_parts[2] = &mEyeLashLOD ;
-                av_parts[3] = &mHeadLOD ;
-                av_parts[4] = &mLowerBodyLOD ;
-                av_parts[5] = &mSkirtLOD ;
-                av_parts[6] = &mUpperBodyLOD ;
-                av_parts[7] = &mHairLOD ;
-                
                 S32 f_num = 0 ;
                 const U32 VERTEX_NUMBER_THRESHOLD = 128 ;//small number of this means each part of an avatar has its own vertex buffer.
+                const S32 num_parts = mMeshLOD.size();
 
                 // this order is determined by number of LODS
                 // if a mesh earlier in this list changed LODs while a later mesh doesn't,
                 // the later mesh's index offset will be inaccurate
-                for(S32 part_index = 0 ; part_index < 8 ;)
+                for(S32 part_index = 0 ; part_index < num_parts ;)
                 {
                         S32 j = part_index ;
                         U32 last_v_num = 0, num_vertices = 0 ;
                         U32 last_i_num = 0, num_indices = 0 ;
 
-                        while(part_index < 8 && num_vertices < VERTEX_NUMBER_THRESHOLD)
+                        while(part_index < num_parts && num_vertices < VERTEX_NUMBER_THRESHOLD)
                         {
                                 last_v_num = num_vertices ;
                                 last_i_num = num_indices ;
 
-                                av_parts[part_index++]->updateFaceSizes(num_vertices, num_indices, mAdjustedPixelArea);
+                                mMeshLOD[part_index++]->updateFaceSizes(num_vertices, num_indices, mAdjustedPixelArea);
                         }
                         if(num_vertices < 1)//skip empty meshes
                         {
@@ -2414,7 +2278,7 @@ void LLVOAvatar::updateMeshData()
 
                         for(S32 k = j ; k < part_index ; k++)
                         {
-                                av_parts[k]->updateFaceData(facep, mAdjustedPixelArea, (k == 7));
+                                mMeshLOD[k]->updateFaceData(facep, mAdjustedPixelArea, k == MESH_ID_HAIR);
                         }
 
                         stop_glerror();
@@ -2538,27 +2402,6 @@ U32 LLVOAvatar::processUpdateMessage(LLMessageSystem *mesgsys,
 
         //llinfos << getRotation() << llendl;
         //llinfos << getPosition() << llendl;
-        if (update_type == OUT_FULL )
-        {
-                if( !mIsSelf || !mFirstTEMessageReceived )
-                {
-//                      dumpAvatarTEs( "PRE   processUpdateMessage()" );
-                        unpackTEMessage(mesgsys, _PREHASH_ObjectData, block_num);
-//                      dumpAvatarTEs( "POST  processUpdateMessage()" );
-
-                        if( !mFirstTEMessageReceived )
-                        {
-                                onFirstTEMessageReceived();
-                        }
-
-                        // Disable updates to composites.  We'll decide whether we need to do
-                        // any updates after we find out whether this update message has any
-                        // "baked" (pre-composited) textures.
-                        setCompositeUpdatesEnabled( FALSE );
-                        updateMeshTextures(); 
-                        setCompositeUpdatesEnabled( TRUE );
-                }
-        }
 
         return retval;
 }
@@ -2568,7 +2411,7 @@ S32 LLVOAvatar::setTETexture(const U8 te, const LLUUID& uuid)
 {
         // The core setTETexture() method requests images, so we need
         // to redirect certain avatar texture requests to different sims.
-        if (isTextureIndexBaked(te))
+        if (isIndexBakedTexture((ETextureIndex)te))
         {
                 LLHost target_host = getObjectHost();
                 return setTETextureCore(te, uuid, target_host);
@@ -3217,69 +3060,69 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
                                 (is_away != mNameAway || is_busy != mNameBusy || is_muted != mNameMute)
                                 || is_appearance != mNameAppearance)
                         {
-                                char line[MAX_STRING];          /* Flawfinder: ignore */
+                                std::string line;
                                 if (!sRenderGroupTitles)
                                 {
                                         // If all group titles are turned off, stack first name
                                         // on a line above last name
-                                        strncpy(line, firstname->getString(), MAX_STRING -1 );          /* Flawfinder: ignore */
-                                        line[MAX_STRING -1] = '\0';
-                                        strcat(line, "\n");
+                                        line += firstname->getString();
+                                        line += "\n";
                                 }
                                 else if (title && title->getString() && title->getString()[0] != '\0')
                                 {
-                                        strncpy(line, title->getString(), MAX_STRING -1 );              /* Flawfinder: ignore */
-                                        line[MAX_STRING -1] = '\0';
-                                        strcat(line, "\n");             /* Flawfinder: ignore */
-                                        strncat(line, firstname->getString(), MAX_STRING - strlen(line) -1 );           /* Flawfinder: ignore */
+                                        line += title->getString();
+                                        LLStringFn::replace_ascii_controlchars(line,LL_UNKNOWN_CHAR);
+                                        line += "\n";
+                                        line += firstname->getString();
                                 }
                                 else
                                 {
-                                        strncpy(line, firstname->getString(), MAX_STRING -1 );          /* Flawfinder: ignore */
-                                        line[MAX_STRING -1] = '\0';
+                                        line += firstname->getString();
                                 }
 
-                                strcat(line, " ");              /* Flawfinder: ignore */
-                                strncat(line, lastname->getString(), MAX_STRING - strlen(line) -1);             /* Flawfinder: ignore */
+                                line += " ";
+                                line += lastname->getString();
                                 BOOL need_comma = FALSE;
 
                                 if (is_away || is_muted || is_busy)
                                 {
-                                        strcat(line, " (");             /* Flawfinder: ignore */
+                                        line += " (";
                                         if (is_away)
                                         {
-                                                strcat(line, "Away");           /* Flawfinder: ignore */
+                                                line += "Away";
                                                 need_comma = TRUE;
                                         }
                                         if (is_busy)
                                         {
                                                 if (need_comma)
                                                 {
-                                                        strcat(line, ", ");             /* Flawfinder: ignore */
+                                                        line += ", ";
                                                 }
-                                                strcat(line, "Busy");           /* Flawfinder: ignore */
+                                                line += "Busy";
                                                 need_comma = TRUE;
                                         }
                                         if (is_muted)
                                         {
                                                 if (need_comma)
                                                 {
-                                                        strcat(line, ", ");             /* Flawfinder: ignore */
+                                                        line += ", ";
                                                 }
-                                                strcat(line, "Muted");          /* Flawfinder: ignore */
+                                                line += "Muted";
                                                 need_comma = TRUE;
                                         }
-                                        strcat(line,")");               /* Flawfinder: ignore */
+                                        line += ")";
                                 }
                                 if (is_appearance)
                                 {
-                                        strcat(line, "\n(Editing Appearance)");         /* Flawfinder: ignore */
+                                        line += "\n";
+                                        line += "(Editing Appearance)";
                                 }
                                 mNameAway = is_away;
                                 mNameBusy = is_busy;
                                 mNameMute = is_muted;
                                 mNameAppearance = is_appearance;
                                 mTitle = title ? title->getString() : "";
+                                LLStringFn::replace_ascii_controlchars(mTitle,LL_UNKNOWN_CHAR);
                                 mNameString = utf8str_to_wstring(line);
                                 new_name = TRUE;
                         }
@@ -3287,7 +3130,7 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
                         if (visible_chat)
                         {
                                 mNameText->setDropShadow(TRUE);
-                                mNameText->setFont(LLFontGL::sSansSerif);
+                                mNameText->setFont(LLFontGL::getFontSansSerif());
                                 mNameText->setTextAlignment(LLHUDText::ALIGN_TEXT_LEFT);
                                 mNameText->setFadeDistance(CHAT_NORMAL_RADIUS * 2.f, 5.f);
                                 if (new_name)
@@ -3364,11 +3207,11 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
                         {
                                 if (gSavedSettings.getBOOL("SmallAvatarNames"))
                                 {
-                                        mNameText->setFont(LLFontGL::sSansSerif);
+                                        mNameText->setFont(LLFontGL::getFontSansSerif());
                                 }
                                 else
                                 {
-                                        mNameText->setFont(LLFontGL::sSansSerifBig);
+                                        mNameText->setFont(LLFontGL::getFontSansSerifBig());
                                 }
                                 mNameText->setTextAlignment(LLHUDText::ALIGN_TEXT_CENTER);
                                 mNameText->setFadeDistance(CHAT_NORMAL_RADIUS, 5.f);
@@ -3575,6 +3418,10 @@ BOOL LLVOAvatar::updateCharacter(LLAgent &agent)
                 { //back 25% of max visible avatars are slow updating impostors
                         mUpdatePeriod = 8;
                 }
+                else if (visible && mVisibilityRank > (U32) LLVOAvatar::sMaxVisible)
+                { //background avatars are REALLY slow updating impostors
+                        mUpdatePeriod = 16;
+                }
                 else if (visible && mImpostorPixelArea <= impostor_area)
                 {  // stuff in between gets an update period based on pixel area
                         mUpdatePeriod = llclamp((S32) sqrtf(impostor_area*4.f/mImpostorPixelArea), 2, 8);
@@ -3760,7 +3607,7 @@ BOOL LLVOAvatar::updateCharacter(LLAgent &agent)
                         F32 root_roll, root_pitch, root_yaw;
                         root_rotation.getEulerAngles(&root_roll, &root_pitch, &root_yaw);
 
-                        if (gDebugAvatarRotation)
+                        if (sDebugAvatarRotation)
                         {
                                 llinfos << "root_roll " << RAD_TO_DEG * root_roll 
                                         << " root_pitch " << RAD_TO_DEG * root_pitch
@@ -3916,7 +3763,7 @@ BOOL LLVOAvatar::updateCharacter(LLAgent &agent)
         // Generate footstep sounds when feet hit the ground
         //-------------------------------------------------------------------------
         const LLUUID AGENT_FOOTSTEP_ANIMS[] = {ANIM_AGENT_WALK, ANIM_AGENT_RUN, ANIM_AGENT_LAND};
-        const S32 NUM_AGENT_FOOTSTEP_ANIMS = sizeof(AGENT_FOOTSTEP_ANIMS) / sizeof(LLUUID);
+        const S32 NUM_AGENT_FOOTSTEP_ANIMS = LL_ARRAY_SIZE(AGENT_FOOTSTEP_ANIMS);
 
         if ( gAudiop && isAnyAnimationSignaled(AGENT_FOOTSTEP_ANIMS, NUM_AGENT_FOOTSTEP_ANIMS) )
         {
@@ -3950,7 +3797,7 @@ BOOL LLVOAvatar::updateCharacter(LLAgent &agent)
 //                                                      AUDIO_STEP_LO_GAIN, AUDIO_STEP_HI_GAIN );
 
                         const F32 STEP_VOLUME = 0.5f;
-                        LLUUID& step_sound_id = getStepSound();
+                        const LLUUID& step_sound_id = getStepSound();
 
                         LLVector3d foot_pos_global = gAgent.getPosGlobalFromAgent(foot_pos_agent);
 
@@ -4184,19 +4031,19 @@ U32 LLVOAvatar::renderSkinned(EAvatarRenderPass pass)
                 if (mNeedsSkin)
                 {
                         //generate animated mesh
-                        mLowerBodyLOD.updateJointGeometry();
-                        mUpperBodyLOD.updateJointGeometry();
+                        mMeshLOD[MESH_ID_LOWER_BODY]->updateJointGeometry();
+                        mMeshLOD[MESH_ID_UPPER_BODY]->updateJointGeometry();
 
                         if( isWearingWearableType( WT_SKIRT ) )
                         {
-                                mSkirtLOD.updateJointGeometry();
+                                mMeshLOD[MESH_ID_SKIRT]->updateJointGeometry();
                         }
 
-                        if (!mIsSelf || gAgent.needsRenderHead())
+                        if (!mIsSelf || gAgent.needsRenderHead() || LLPipeline::sShadowRender)
                         {
-                                mEyeLashLOD.updateJointGeometry();
-                                mHeadLOD.updateJointGeometry();
-                                mHairLOD.updateJointGeometry();                         
+                                mMeshLOD[MESH_ID_EYELASH]->updateJointGeometry();
+                                mMeshLOD[MESH_ID_HEAD]->updateJointGeometry();
+                                mMeshLOD[MESH_ID_HAIR]->updateJointGeometry();
                         }
                         mNeedsSkin = FALSE;
                         
@@ -4284,7 +4131,7 @@ U32 LLVOAvatar::renderSkinned(EAvatarRenderPass pass)
                 gGL.flush();
         }
         //--------------------------------------------------------------------
-        // render all geomety attached to the skeleton
+        // render all geometry attached to the skeleton
         //--------------------------------------------------------------------
         static LLStat render_stat;
 
@@ -4292,19 +4139,52 @@ U32 LLVOAvatar::renderSkinned(EAvatarRenderPass pass)
 
         if (pass == AVATAR_RENDER_PASS_SINGLE)
         {
+                const bool should_alpha_mask = mHasBakedHair && isTextureDefined(TEX_HEAD_BAKED) && isTextureDefined(TEX_UPPER_BAKED) 
+                                                                                && isTextureDefined(TEX_LOWER_BAKED) && mBakedTextureData[BAKED_HEAD].mIsLoaded
+                                                                                && mBakedTextureData[BAKED_UPPER].mIsLoaded && mBakedTextureData[BAKED_LOWER].mIsLoaded
+                                                                                && !LLDrawPoolAlpha::sShowDebugAlpha; // Don't alpha mask if "Highlight Transparent" checked
+
+                LLGLState test(GL_ALPHA_TEST, should_alpha_mask);
+
+                if (should_alpha_mask)
+                {
+                        gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.5f);
+                }
+                
                 BOOL first_pass = TRUE;
-                if (!mIsSelf || gAgent.needsRenderHead())
+                if (!LLDrawPoolAvatar::sSkipOpaque)
                 {
-                        num_indices += mHeadLOD.render(mAdjustedPixelArea);
-                        first_pass = FALSE;
+                        if (!mIsSelf || gAgent.needsRenderHead() || LLPipeline::sShadowRender)
+                        {
+                                if (isTextureVisible(TEX_HEAD_BAKED) || mIsDummy)
+                                {
+                                        num_indices += mMeshLOD[MESH_ID_HEAD]->render(mAdjustedPixelArea, TRUE, mIsDummy);
+                                        first_pass = FALSE;
+                                }
+                        }
+                        if (isTextureVisible(TEX_UPPER_BAKED) || mIsDummy)
+                        {
+                                num_indices += mMeshLOD[MESH_ID_UPPER_BODY]->render(mAdjustedPixelArea, first_pass, mIsDummy);
+                                first_pass = FALSE;
+                        }
+                        
+                        if (isTextureVisible(TEX_LOWER_BAKED) || mIsDummy)
+                        {
+                                num_indices += mMeshLOD[MESH_ID_LOWER_BODY]->render(mAdjustedPixelArea, first_pass, mIsDummy);
+                                first_pass = FALSE;
+                        }
                 }
-                num_indices += mUpperBodyLOD.render(mAdjustedPixelArea, first_pass);
-                num_indices += mLowerBodyLOD.render(mAdjustedPixelArea, FALSE);
 
+                gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
+
+                if (!LLDrawPoolAvatar::sSkipTransparent || LLPipeline::sImpostorRender)
                 {
-                        LLGLEnable blend(GL_BLEND);
-                        LLGLEnable test(GL_ALPHA_TEST);
-                        num_indices += renderTransparent();
+                        if (!mIsDummy)
+                        {
+                                LLGLEnable blend(GL_BLEND);
+                                LLGLEnable test(GL_ALPHA_TEST);
+                        }
+                        num_indices += renderTransparent(first_pass);
                 }
         }
         
@@ -4317,26 +4197,36 @@ U32 LLVOAvatar::renderSkinned(EAvatarRenderPass pass)
         return num_indices;
 }
 
-U32 LLVOAvatar::renderTransparent()
+U32 LLVOAvatar::renderTransparent(BOOL first_pass)
 {
         U32 num_indices = 0;
-        BOOL first_pass = FALSE;
-        if( isWearingWearableType( WT_SKIRT ) )
+        if( isWearingWearableType( WT_SKIRT ) && (mIsDummy || isTextureVisible(TEX_SKIRT_BAKED)) )
         {
                 gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.25f);
-                num_indices += mSkirtLOD.render(mAdjustedPixelArea, FALSE);
+                num_indices += mMeshLOD[MESH_ID_SKIRT]->render(mAdjustedPixelArea, FALSE);
                 first_pass = FALSE;
                 gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
         }
 
-        if (!mIsSelf || gAgent.needsRenderHead())
+        if (!mIsSelf || gAgent.needsRenderHead() || LLPipeline::sShadowRender)
         {
                 if (LLPipeline::sImpostorRender)
                 {
                         gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.5f);
                 }
-                num_indices += mEyeLashLOD.render(mAdjustedPixelArea, first_pass);
-                num_indices += mHairLOD.render(mAdjustedPixelArea, FALSE);
+                
+                if (isTextureVisible(TEX_HEAD_BAKED))
+                {
+                        num_indices += mMeshLOD[MESH_ID_EYELASH]->render(mAdjustedPixelArea, first_pass, mIsDummy);
+                        first_pass = FALSE;
+                }
+                // Can't test for baked hair being defined, since that won't always be the case (not all viewers send baked hair)
+                // TODO: 1.25 will be able to switch this logic back to calling isTextureVisible();
+                if (getTEImage(TEX_HAIR_BAKED)->getID() != IMG_INVISIBLE || LLDrawPoolAlpha::sShowDebugAlpha)
+                {
+                        num_indices += mMeshLOD[MESH_ID_HAIR]->render(mAdjustedPixelArea, first_pass, mIsDummy);
+                        first_pass = FALSE;
+                }
                 if (LLPipeline::sImpostorRender)
                 {
                         gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
@@ -4368,8 +4258,22 @@ U32 LLVOAvatar::renderRigid()
                 return 0;
         }
 
-        num_indices += mEyeBallLeftLOD.render(mAdjustedPixelArea);
-        num_indices += mEyeBallRightLOD.render(mAdjustedPixelArea);
+        if (isTextureVisible(TEX_EYES_BAKED) || mIsDummy)
+        {
+                // If the meshes need to be drawn, enable alpha masking but not blending
+                bool should_alpha_mask = mHasBakedHair && mBakedTextureData[BAKED_EYES].mIsLoaded;
+                LLGLState test(GL_ALPHA_TEST, should_alpha_mask);
+                
+                if (should_alpha_mask)
+                {
+                        gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.5f);
+                }
+
+                num_indices += mMeshLOD[MESH_ID_EYEBALL_LEFT]->render(mAdjustedPixelArea, TRUE, mIsDummy);
+                num_indices += mMeshLOD[MESH_ID_EYEBALL_RIGHT]->render(mAdjustedPixelArea, TRUE, mIsDummy);
+
+                gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
+        }
         
         return num_indices;
 }
@@ -4392,6 +4296,13 @@ U32 LLVOAvatar::renderFootShadows()
         {
                 return 0;
         }
+        
+        // Don't render foot shadows if your lower body is completely invisible.
+        // (non-humanoid avatars rule!)
+        if (! isTextureVisible(TEX_LOWER_BAKED))
+        {
+                return 0;
+        }
 
         // Update the shadow, tractor, and text label geometry.
         if (mDrawable->isState(LLDrawable::REBUILD_SHADOW) && !isImpostor())
@@ -4401,7 +4312,7 @@ U32 LLVOAvatar::renderFootShadows()
         }
 
         U32 foot_mask = LLVertexBuffer::MAP_VERTEX |
-                                        LLVertexBuffer::MAP_TEXCOORD;
+                                        LLVertexBuffer::MAP_TEXCOORD0;
 
         LLGLDepthTest test(GL_TRUE, GL_FALSE);
         //render foot shadows
@@ -4434,23 +4345,6 @@ U32 LLVOAvatar::renderImpostor(LLColor4U color)
         LLGLEnable test(GL_ALPHA_TEST);
         gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.f);
 
-        F32 blend = gFrameTimeSeconds - mFadeTime;
-
-        LLGLState gl_blend(GL_BLEND, blend < 1.f ? TRUE : FALSE);
-        gGL.setSceneBlendType(LLRender::BT_ALPHA);
-
-        F32 alpha;
-        if (mVisibilityRank >= (U32) LLVOAvatar::sMaxVisible)
-        { //fade out
-                alpha = 1.f - llmin(blend, 1.f);
-        }
-        else 
-        { //fade in
-                alpha = llmin(blend, 1.f);
-        }
-
-        color.mV[3] = (U8) (alpha*255);
-        
         gGL.color4ubv(color.mV);
         gGL.getTexUnit(0)->bind(&mImpostor);
         gGL.begin(LLRender::QUADS);
@@ -4479,12 +4373,6 @@ void LLVOAvatar::updateTextures(LLAgent &agent)
         {
                 return;
         }
-        
-        BOOL head_baked = ( getTEImage( TEX_HEAD_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-        BOOL upper_baked = ( getTEImage( TEX_UPPER_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-        BOOL lower_baked = ( getTEImage( TEX_LOWER_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-        BOOL eyes_baked = ( getTEImage( TEX_EYES_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-        BOOL skirt_baked = ( getTEImage( TEX_SKIRT_BAKED )->getID() != IMG_DEFAULT_AVATAR );
 
         if( mIsSelf )
         {
@@ -4495,30 +4383,18 @@ void LLVOAvatar::updateTextures(LLAgent &agent)
                 render_avatar = isVisible() && !mCulled;
         }
 
-        // bind the texture so that they'll be decoded
-        // slightly inefficient, we can short-circuit this
-        // if we have to
-        if( render_avatar && !gGLManager.mIsDisabled )
+        std::vector<bool> layer_baked;
+        for (U32 i = 0; i < mBakedTextureData.size(); i++)
         {
-                if( head_baked && ! mHeadBakedLoaded )
-                {
-                        gGL.getTexUnit(0)->bind(getTEImage( TEX_HEAD_BAKED ));
-                }
-                if( upper_baked && ! mUpperBakedLoaded )
-                {
-                        gGL.getTexUnit(0)->bind(getTEImage( TEX_UPPER_BAKED ));
-                }
-                if( lower_baked && ! mLowerBakedLoaded )
-                {
-                        gGL.getTexUnit(0)->bind(getTEImage( TEX_LOWER_BAKED ));
-                }
-                if( eyes_baked && ! mEyesBakedLoaded )
+                layer_baked.push_back(isTextureDefined(mBakedTextureData[i].mTextureIndex));
+                // bind the texture so that they'll be decoded slightly 
+                // inefficient, we can short-circuit this if we have to
+                if( render_avatar && !gGLManager.mIsDisabled )
                 {
-                        gGL.getTexUnit(0)->bind(getTEImage( TEX_EYES_BAKED ));
-                }
-                if( skirt_baked && ! mSkirtBakedLoaded )
-                {
-                        gGL.getTexUnit(0)->bind(getTEImage( TEX_SKIRT_BAKED ));
+                        if (layer_baked[i] && !mBakedTextureData[i].mIsLoaded)
+                        {
+                                gGL.getTexUnit(0)->bind(getTEImage( mBakedTextureData[i].mTextureIndex ));
+                        }
                 }
         }
 
@@ -4550,9 +4426,9 @@ void LLVOAvatar::updateTextures(LLAgent &agent)
         mMaxPixelArea = 0.f;
         mMinPixelArea = 99999999.f;
         mHasGrey = FALSE; // debug
-        for (U32 i = 0; i < getNumTEs(); i++)
+        for (U32 index = 0; index < getNumTEs(); index++)
         {
-                LLViewerImage *imagep = getTEImage(i);
+                LLViewerImage *imagep = getTEImage(index);
                 if (imagep)
                 {
                         // Debugging code - maybe non-self avatars are downloading textures?
@@ -4564,131 +4440,39 @@ void LLVOAvatar::updateTextures(LLAgent &agent)
                         //      << " desired " << imagep->getDesiredDiscardLevel()
                         //      << llendl;
                         
-                        const LLTextureEntry *te = getTE(i);
+                        const LLTextureEntry *te = getTE(index);
                         F32 texel_area_ratio = fabs(te->mScaleS * te->mScaleT);
                         S32 boost_level = mIsSelf ? LLViewerImage::BOOST_AVATAR_BAKED_SELF : LLViewerImage::BOOST_AVATAR_BAKED;
                         
                         // Spam if this is a baked texture, not set to default image, without valid host info
-                        if (isTextureIndexBaked(i)
+                        if (isIndexBakedTexture((ETextureIndex)index)
                                 && imagep->getID() != IMG_DEFAULT_AVATAR
                                 && !imagep->getTargetHost().isOk())
                         {
-                                llwarns << "LLVOAvatar::updateTextures No host for texture "
+                                LL_WARNS_ONCE("Texture") << "LLVOAvatar::updateTextures No host for texture "
                                         << imagep->getID() << " for avatar "
                                         << (mIsSelf ? "<myself>" : getID().asString()) 
                                         << " on host " << getRegion()->getHost() << llendl;
                         }
-                        
-                        switch( i )
-                        {
-                        // Head
-                        case TEX_HEAD_BODYPAINT:
-                                addLocalTextureStats( LOCTEX_HEAD_BODYPAINT, imagep, texel_area_ratio, render_avatar, head_baked );
-                                break;
-
-                        // Upper
-                        case TEX_UPPER_JACKET:
-                                addLocalTextureStats( LOCTEX_UPPER_JACKET, imagep, texel_area_ratio, render_avatar, upper_baked );
-                                break;
-
-                        case TEX_UPPER_SHIRT:
-                                addLocalTextureStats( LOCTEX_UPPER_SHIRT, imagep, texel_area_ratio, render_avatar, upper_baked );
-                                break;
-
-                        case TEX_UPPER_GLOVES:
-                                addLocalTextureStats( LOCTEX_UPPER_GLOVES, imagep, texel_area_ratio, render_avatar, upper_baked );
-                                break;
-                        
-                        case TEX_UPPER_UNDERSHIRT:
-                                addLocalTextureStats( LOCTEX_UPPER_UNDERSHIRT, imagep, texel_area_ratio, render_avatar, upper_baked );
-                                break;
-
-                        case TEX_UPPER_BODYPAINT:
-                                addLocalTextureStats( LOCTEX_UPPER_BODYPAINT, imagep, texel_area_ratio, render_avatar, upper_baked );
-                                break;
-
-                        // Lower
-                        case TEX_LOWER_JACKET:
-                                addLocalTextureStats( LOCTEX_LOWER_JACKET, imagep, texel_area_ratio, render_avatar, lower_baked );
-                                break;
-
-                        case TEX_LOWER_PANTS:
-                                addLocalTextureStats( LOCTEX_LOWER_PANTS, imagep, texel_area_ratio, render_avatar, lower_baked );
-                                break;
-
-                        case TEX_LOWER_SHOES:
-                                addLocalTextureStats( LOCTEX_LOWER_SHOES, imagep, texel_area_ratio, render_avatar, lower_baked );
-                                break;
-
-                        case TEX_LOWER_SOCKS:
-                                addLocalTextureStats( LOCTEX_LOWER_SOCKS, imagep, texel_area_ratio, render_avatar, lower_baked );
-                                break;
 
-                        case TEX_LOWER_UNDERPANTS:
-                                addLocalTextureStats( LOCTEX_LOWER_UNDERPANTS, imagep, texel_area_ratio, render_avatar, lower_baked );
-                                break;
-
-                        case TEX_LOWER_BODYPAINT:
-                                addLocalTextureStats( LOCTEX_LOWER_BODYPAINT, imagep, texel_area_ratio, render_avatar, lower_baked );
-                                break;
-
-                        // Eyes
-                        case TEX_EYES_IRIS:
-                                addLocalTextureStats( LOCTEX_EYES_IRIS, imagep, texel_area_ratio, render_avatar, eyes_baked );
-                                break;
-
-                        // Skirt
-                        case TEX_SKIRT:
-                                addLocalTextureStats( LOCTEX_SKIRT, imagep, texel_area_ratio, render_avatar, skirt_baked );
-                                break;
-
-                        // Baked
-                        case TEX_HEAD_BAKED:
-                                if (head_baked)
-                                {
-                                        addBakedTextureStats( imagep, mPixelArea, texel_area_ratio, boost_level );
-                                }
-                                break;
-
-                        case TEX_UPPER_BAKED:
-                                if (upper_baked)
-                                {
-                                        addBakedTextureStats( imagep, mPixelArea, texel_area_ratio, boost_level );
-                                }
-                                break;
-                        
-                        case TEX_LOWER_BAKED:
-                                if (lower_baked)
-                                {
-                                        addBakedTextureStats( imagep, mPixelArea, texel_area_ratio, boost_level );
-                                }
-                                break;
-                        
-                        case TEX_EYES_BAKED:
-                                if (eyes_baked)
+                        /* switch(index)
+                                case TEX_HEAD_BODYPAINT:
+                                        addLocalTextureStats( LOCTEX_HEAD_BODYPAINT, imagep, texel_area_ratio, render_avatar, head_baked ); */
+                        const LLVOAvatarDictionary::TextureDictionaryEntry *texture_dict = LLVOAvatarDictionary::getInstance()->getTexture((ETextureIndex)index);
+                        if (texture_dict->mIsUsedByBakedTexture)
+                        {
+                                const EBakedTextureIndex baked_index = texture_dict->mBakedTextureIndex;
+                                if (texture_dict->mIsLocalTexture)
                                 {
-                                        addBakedTextureStats( imagep, mPixelArea, texel_area_ratio, boost_level );
+                                        addLocalTextureStats((ETextureIndex)index, imagep, texel_area_ratio, render_avatar, layer_baked[baked_index]);
                                 }
-                                break;
-
-                        case TEX_SKIRT_BAKED:
-                                if (skirt_baked)
+                                else if (texture_dict->mIsBakedTexture)
                                 {
-                                        addBakedTextureStats( imagep, mPixelArea, texel_area_ratio, boost_level );
+                                        if (layer_baked[baked_index])
+                                        {
+                                                addBakedTextureStats( imagep, mPixelArea, texel_area_ratio, boost_level );
+                                        }
                                 }
-                                break;
-
-                        case TEX_HAIR:
-                                // Hair is neither a local texture used for baking, nor the output
-                                // of the baking process.  It's just a texture that happens to be
-                                // used to draw avatars.  Hence BOOST_AVATAR.  JC
-                                boost_level = mIsSelf ? LLViewerImage::BOOST_AVATAR_SELF : LLViewerImage::BOOST_AVATAR;
-                                addBakedTextureStats( imagep, mPixelArea, texel_area_ratio, boost_level );
-                                break;
-                        
-                        default:
-                                llassert(0);
-                                break;
                         }
                 }
         }
@@ -4705,22 +4489,24 @@ void LLVOAvatar::updateTextures(LLAgent &agent)
 }
 
 
-void LLVOAvatar::addLocalTextureStats( LLVOAvatar::ELocTexIndex idx, LLViewerImage* imagep,
+void LLVOAvatar::addLocalTextureStats( ETextureIndex idx, LLViewerImage* imagep,
                                                                            F32 texel_area_ratio, BOOL render_avatar, BOOL covered_by_baked )
 {
+        if (!isIndexLocalTexture(idx)) return;
+
         if (!covered_by_baked && render_avatar) // render_avatar is always true if mIsSelf
         {
-                if (mLocalTexture[ idx ].notNull() && mLocalTexture[idx]->getID() != IMG_DEFAULT_AVATAR)
+                if (getLocalTextureID(idx) != IMG_DEFAULT_AVATAR)
                 {
                         F32 desired_pixels;
                         if( mIsSelf )
                         {
-                                desired_pixels = llmin(mPixelArea, (F32)LOCTEX_IMAGE_AREA_SELF );
+                                desired_pixels = llmin(mPixelArea, (F32)TEX_IMAGE_AREA_SELF );
                                 imagep->setBoostLevel(LLViewerImage::BOOST_AVATAR_SELF);
                         }
                         else
                         {
-                                desired_pixels = llmin(mPixelArea, (F32)LOCTEX_IMAGE_AREA_OTHER );
+                                desired_pixels = llmin(mPixelArea, (F32)TEX_IMAGE_AREA_OTHER );
                                 imagep->setBoostLevel(LLViewerImage::BOOST_AVATAR);
                         }
                         imagep->addTextureStats( desired_pixels / texel_area_ratio );
@@ -4731,11 +4517,8 @@ void LLVOAvatar::addLocalTextureStats( LLVOAvatar::ELocTexIndex idx, LLViewerIma
                 }
                 else
                 {
-                        if (mLocalTexture[idx]->getID() == IMG_DEFAULT_AVATAR)
-                        {
-                                // texture asset is missing
-                                mHasGrey = TRUE; // for statistics gathering
-                        }
+                        // texture asset is missing
+                        mHasGrey = TRUE; // for statistics gathering
                 }
         }
 }
@@ -4803,7 +4586,7 @@ void LLVOAvatar::resolveHeightGlobal(const LLVector3d &inPos, LLVector3d &outPos
 //-----------------------------------------------------------------------------
 // getStepSound()
 //-----------------------------------------------------------------------------
-LLUUID& LLVOAvatar::getStepSound()
+const LLUUID& LLVOAvatar::getStepSound() const
 {
         if ( mStepOnLand )
         {
@@ -5241,7 +5024,7 @@ F32 LLVOAvatar::getPixelArea() const
 //-----------------------------------------------------------------------------
 LLPolyMesh*     LLVOAvatar::getHeadMesh()
 {
-        return mHeadMesh0.getMesh();
+        return mMeshLOD[MESH_ID_HEAD]->mMeshParts[0]->getMesh();
 }
 
 
@@ -5250,7 +5033,7 @@ LLPolyMesh*	LLVOAvatar::getHeadMesh()
 //-----------------------------------------------------------------------------
 LLPolyMesh*     LLVOAvatar::getUpperBodyMesh()
 {
-        return mUpperBodyMesh0.getMesh();
+        return mMeshLOD[MESH_ID_UPPER_BODY]->mMeshParts[0]->getMesh();
 }
 
 
@@ -5349,7 +5132,7 @@ BOOL LLVOAvatar::loadAvatar()
 //      LLFastTimer t(LLFastTimer::FTM_LOAD_AVATAR);
         
         // avatar_skeleton.xml
-        if( !buildSkeleton(sSkeletonInfo) )
+        if( !buildSkeleton(sAvatarSkeletonInfo) )
         {
                 llwarns << "avatar file: buildSkeleton() failed" << llendl;
                 return FALSE;
@@ -5370,10 +5153,10 @@ BOOL LLVOAvatar::loadAvatar()
         }
         
         // avatar_lad.xml : <global_color>
-        if( sAvatarInfo->mTexSkinColorInfo )
+        if( sAvatarXmlInfo->mTexSkinColorInfo )
         {
                 mTexSkinColor = new LLTexGlobalColor( this );
-                if( !mTexSkinColor->setInfo( sAvatarInfo->mTexSkinColorInfo ) )
+                if( !mTexSkinColor->setInfo( sAvatarXmlInfo->mTexSkinColorInfo ) )
                 {
                         llwarns << "avatar file: mTexSkinColor->setInfo() failed" << llendl;
                         return FALSE;
@@ -5384,10 +5167,10 @@ BOOL LLVOAvatar::loadAvatar()
                 llwarns << "<global_color> name=\"skin_color\" not found" << llendl;
                 return FALSE;
         }
-        if( sAvatarInfo->mTexHairColorInfo )
+        if( sAvatarXmlInfo->mTexHairColorInfo )
         {
                 mTexHairColor = new LLTexGlobalColor( this );
-                if( !mTexHairColor->setInfo( sAvatarInfo->mTexHairColorInfo ) )
+                if( !mTexHairColor->setInfo( sAvatarXmlInfo->mTexHairColorInfo ) )
                 {
                         llwarns << "avatar file: mTexHairColor->setInfo() failed" << llendl;
                         return FALSE;
@@ -5398,10 +5181,10 @@ BOOL LLVOAvatar::loadAvatar()
                 llwarns << "<global_color> name=\"hair_color\" not found" << llendl;
                 return FALSE;
         }
-        if( sAvatarInfo->mTexEyeColorInfo )
+        if( sAvatarXmlInfo->mTexEyeColorInfo )
         {
                 mTexEyeColor = new LLTexGlobalColor( this );
-                if( !mTexEyeColor->setInfo( sAvatarInfo->mTexEyeColorInfo ) )
+                if( !mTexEyeColor->setInfo( sAvatarXmlInfo->mTexEyeColorInfo ) )
                 {
                         llwarns << "avatar file: mTexEyeColor->setInfo() failed" << llendl;
                         return FALSE;
@@ -5414,15 +5197,15 @@ BOOL LLVOAvatar::loadAvatar()
         }
         
         // avatar_lad.xml : <layer_set>
-        if (sAvatarInfo->mLayerInfoList.empty())
+        if (sAvatarXmlInfo->mLayerInfoList.empty())
         {
                 llwarns << "avatar file: missing <layer_set> node" << llendl;
         }
         else
         {
-                LLVOAvatarInfo::layer_info_list_t::iterator iter;
-                for (iter = sAvatarInfo->mLayerInfoList.begin();
-                         iter != sAvatarInfo->mLayerInfoList.end(); iter++)
+                LLVOAvatarXmlInfo::layer_info_list_t::iterator iter;
+                for (iter = sAvatarXmlInfo->mLayerInfoList.begin();
+                         iter != sAvatarXmlInfo->mLayerInfoList.end(); iter++)
                 {
                         LLTexLayerSetInfo *info = *iter;
                         LLTexLayerSet* layer_set = new LLTexLayerSet( this );
@@ -5433,27 +5216,20 @@ BOOL LLVOAvatar::loadAvatar()
                                 llwarns << "avatar file: layer_set->parseData() failed" << llendl;
                                 return FALSE;
                         }
-                        if( layer_set->isBodyRegion( "head" ) )
-                        {
-                                mHeadLayerSet = layer_set;
-                        }
-                        else if( layer_set->isBodyRegion( "upper_body" ) )
-                        {
-                                mUpperBodyLayerSet = layer_set;
-                        }
-                        else if( layer_set->isBodyRegion( "lower_body" ) )
-                        {
-                                mLowerBodyLayerSet = layer_set;
-                        }
-                        else if( layer_set->isBodyRegion( "eyes" ) )
+                        bool found_baked_entry = false;
+                        for (LLVOAvatarDictionary::baked_map_t::const_iterator baked_iter = LLVOAvatarDictionary::getInstance()->getBakedTextures().begin();
+                                 baked_iter != LLVOAvatarDictionary::getInstance()->getBakedTextures().end();
+                                 baked_iter++)
                         {
-                                mEyesLayerSet = layer_set;
-                        }
-                        else if( layer_set->isBodyRegion( "skirt" ) )
-                        {
-                                mSkirtLayerSet = layer_set;
+                                const LLVOAvatarDictionary::BakedDictionaryEntry *baked_dict = baked_iter->second;
+                                if (layer_set->isBodyRegion(baked_dict->mName))
+                                {
+                                        mBakedTextureData[baked_iter->first].mTexLayerSet = layer_set;
+                                        found_baked_entry = true;
+                                        break;
+                                }
                         }
-                        else
+                        if (!found_baked_entry)
                         {
                                 llwarns << "<layer_set> has invalid body_region attribute" << llendl;
                                 delete layer_set;
@@ -5464,9 +5240,9 @@ BOOL LLVOAvatar::loadAvatar()
         
         // avatar_lad.xml : <driver_parameters>
         {
-                LLVOAvatarInfo::driver_info_list_t::iterator iter;
-                for (iter = sAvatarInfo->mDriverInfoList.begin();
-                         iter != sAvatarInfo->mDriverInfoList.end(); iter++)
+                LLVOAvatarXmlInfo::driver_info_list_t::iterator iter;
+                for (iter = sAvatarXmlInfo->mDriverInfoList.begin();
+                         iter != sAvatarXmlInfo->mDriverInfoList.end(); iter++)
                 {
                         LLDriverParamInfo *info = *iter;
                         LLDriverParam* driver_param = new LLDriverParam( this );
@@ -5493,78 +5269,44 @@ BOOL LLVOAvatar::loadSkeletonNode ()
 {
         mRoot.addChild( &mSkeleton[0] );
 
-        mRoot.addChild( &mHeadLOD );
-                mHeadLOD.mUpdateXform = FALSE;
-                mHeadLOD.addChild( &mHeadMesh0 );
-                mHeadLOD.addChild( &mHeadMesh1 );
-                mHeadLOD.addChild( &mHeadMesh2 );
-                mHeadLOD.addChild( &mHeadMesh3 );
-                mHeadLOD.addChild( &mHeadMesh4 );
-        
-        mRoot.addChild( &mEyeLashLOD );
-                mEyeLashLOD.mUpdateXform = FALSE;
-                mEyeLashLOD.addChild( &mEyeLashMesh0 );
-
-        mRoot.addChild( &mUpperBodyLOD );
-                mUpperBodyLOD.mUpdateXform = FALSE;
-                mUpperBodyLOD.addChild( &mUpperBodyMesh0 );
-                mUpperBodyLOD.addChild( &mUpperBodyMesh1 );
-                mUpperBodyLOD.addChild( &mUpperBodyMesh2 );
-                mUpperBodyLOD.addChild( &mUpperBodyMesh3 );
-                mUpperBodyLOD.addChild( &mUpperBodyMesh4 );
-
-        mRoot.addChild( &mLowerBodyLOD );
-                mLowerBodyLOD.mUpdateXform = FALSE;
-                mLowerBodyLOD.addChild( &mLowerBodyMesh0 );
-                mLowerBodyLOD.addChild( &mLowerBodyMesh1 );
-                mLowerBodyLOD.addChild( &mLowerBodyMesh2 );
-                mLowerBodyLOD.addChild( &mLowerBodyMesh3 );
-                mLowerBodyLOD.addChild( &mLowerBodyMesh4 );
-
-        mRoot.addChild( &mSkirtLOD );
-                mSkirtLOD.mUpdateXform = FALSE;
-                mSkirtLOD.addChild( &mSkirtMesh0 );
-                mSkirtLOD.addChild( &mSkirtMesh1 );
-                mSkirtLOD.addChild( &mSkirtMesh2 );
-                mSkirtLOD.addChild( &mSkirtMesh3 );
-                mSkirtLOD.addChild( &mSkirtMesh4 );
+        for (std::vector<LLViewerJoint *>::iterator iter = mMeshLOD.begin();
+                iter != mMeshLOD.end(); iter++)
+        {
+                LLViewerJoint *joint = (LLViewerJoint *) *iter;
+                joint->mUpdateXform = FALSE;
+                joint->setMeshesToChildren();
+        }
+
+        mRoot.addChild(mMeshLOD[MESH_ID_HEAD]);
+        mRoot.addChild(mMeshLOD[MESH_ID_EYELASH]);
+        mRoot.addChild(mMeshLOD[MESH_ID_UPPER_BODY]);
+        mRoot.addChild(mMeshLOD[MESH_ID_LOWER_BODY]);
+        mRoot.addChild(mMeshLOD[MESH_ID_SKIRT]);
+        mRoot.addChild(mMeshLOD[MESH_ID_HEAD]);
 
         LLViewerJoint *skull = (LLViewerJoint*)mRoot.findJoint("mSkull");
         if (skull)
         {
-                skull->addChild( &mHairLOD );
-                        mHairLOD.mUpdateXform = FALSE;
-                        mHairLOD.addChild( &mHairMesh0 );
-                        mHairLOD.addChild( &mHairMesh1 );
-                        mHairLOD.addChild( &mHairMesh2 );
-                        mHairLOD.addChild( &mHairMesh3 );
-                        mHairLOD.addChild( &mHairMesh4 );
-                        mHairLOD.addChild( &mHairMesh5 );
+                skull->addChild(mMeshLOD[MESH_ID_HAIR] );
         }
 
         LLViewerJoint *eyeL = (LLViewerJoint*)mRoot.findJoint("mEyeLeft");
         if (eyeL)
         {
-                eyeL->addChild( &mEyeBallLeftLOD );
-                        mEyeBallLeftLOD.mUpdateXform = FALSE;
-                        mEyeBallLeftLOD.addChild( &mEyeBallLeftMesh0 );
-                        mEyeBallLeftLOD.addChild( &mEyeBallLeftMesh1 );
+                eyeL->addChild( mMeshLOD[MESH_ID_EYEBALL_LEFT] );
         }
 
         LLViewerJoint *eyeR = (LLViewerJoint*)mRoot.findJoint("mEyeRight");
         if (eyeR)
         {
-                eyeR->addChild( &mEyeBallRightLOD );
-                        mEyeBallRightLOD.mUpdateXform = FALSE;
-                        mEyeBallRightLOD.addChild( &mEyeBallRightMesh0 );
-                        mEyeBallRightLOD.addChild( &mEyeBallRightMesh1 );
+                eyeR->addChild( mMeshLOD[MESH_ID_EYEBALL_RIGHT] );
         }
 
         // SKELETAL DISTORTIONS
         {
-                LLVOAvatarInfo::skeletal_distortion_info_list_t::iterator iter;
-                for (iter = sAvatarInfo->mSkeletalDistortionInfoList.begin();
-                         iter != sAvatarInfo->mSkeletalDistortionInfoList.end(); iter++)
+                LLVOAvatarXmlInfo::skeletal_distortion_info_list_t::iterator iter;
+                for (iter = sAvatarXmlInfo->mSkeletalDistortionInfoList.begin();
+                         iter != sAvatarXmlInfo->mSkeletalDistortionInfoList.end(); iter++)
                 {
                         LLPolySkeletalDistortionInfo *info = *iter;
                         LLPolySkeletalDistortion *param = new LLPolySkeletalDistortion(this);
@@ -5582,11 +5324,11 @@ BOOL LLVOAvatar::loadSkeletonNode ()
         
         // ATTACHMENTS
         {
-                LLVOAvatarInfo::attachment_info_list_t::iterator iter;
-                for (iter = sAvatarInfo->mAttachmentInfoList.begin();
-                         iter != sAvatarInfo->mAttachmentInfoList.end(); iter++)
+                LLVOAvatarXmlInfo::attachment_info_list_t::iterator iter;
+                for (iter = sAvatarXmlInfo->mAttachmentInfoList.begin();
+                         iter != sAvatarXmlInfo->mAttachmentInfoList.end(); iter++)
                 {
-                        LLVOAvatarInfo::LLVOAvatarAttachmentInfo *info = *iter;
+                        LLVOAvatarXmlInfo::LLVOAvatarAttachmentInfo *info = *iter;
                         if (!isSelf() && info->mJointName == "mScreen")
                         { //don't process screen joint for other avatars
                                 continue;
@@ -5663,174 +5405,49 @@ BOOL LLVOAvatar::loadSkeletonNode ()
 //-----------------------------------------------------------------------------
 BOOL LLVOAvatar::loadMeshNodes()
 {
-        LLVOAvatarInfo::mesh_info_list_t::iterator iter;
-        for (iter = sAvatarInfo->mMeshInfoList.begin();
-                 iter != sAvatarInfo->mMeshInfoList.end(); iter++)
+        for (LLVOAvatarXmlInfo::mesh_info_list_t::const_iterator meshinfo_iter = sAvatarXmlInfo->mMeshInfoList.begin();
+                 meshinfo_iter != sAvatarXmlInfo->mMeshInfoList.end(); 
+                 meshinfo_iter++)
         {
-                LLVOAvatarInfo::LLVOAvatarMeshInfo *info = *iter;
-                std::string &type = info->mType;
+                const LLVOAvatarXmlInfo::LLVOAvatarMeshInfo *info = *meshinfo_iter;
+                const std::string &type = info->mType;
                 S32 lod = info->mLOD;
 
                 LLViewerJointMesh* mesh = NULL;
-                if (type == "hairMesh")
-                {
-                        switch (lod)
-                        {
-                          case 0:
-                                mesh = &mHairMesh0;
-                                break;
-                          case 1:
-                                mesh = &mHairMesh1;
-                                break;
-                          case 2:
-                                mesh = &mHairMesh2;
-                                break;
-                          case 3:
-                                mesh = &mHairMesh3;
-                                break;
-                          case 4:
-                                mesh = &mHairMesh4;
-                                break;
-                          case 5:
-                                mesh = &mHairMesh5;
-                                break;
-                          default:
-                                llwarns << "Avatar file: <mesh> has invalid lod setting " << lod << llendl;
-                                return FALSE;
-                        }
-                }
-                else if (type == "headMesh")
-                {
-                        switch (lod)
-                        {
+                U8 mesh_id = 0;
+                BOOL found_mesh_id = FALSE;
+
+                /* if (type == "hairMesh")
+                        switch(lod)
                           case 0:
-                                mesh = &mHeadMesh0;
-                                break;
-                          case 1:
-                                mesh = &mHeadMesh1;
-                                break;
-                          case 2:
-                                mesh = &mHeadMesh2;
-                                break;
-                          case 3:
-                                mesh = &mHeadMesh3;
-                                break;
-                          case 4:
-                                mesh = &mHeadMesh4;
-                                break;
-                          default:
-                                llwarns << "Avatar file: <mesh> has invalid lod setting " << lod << llendl;
-                                return FALSE;
-                        }
-                }
-                else if (type == "upperBodyMesh")
+                                mesh = &mHairMesh0; */
+                for (LLVOAvatarDictionary::mesh_map_t::const_iterator mesh_iter = LLVOAvatarDictionary::getInstance()->getMeshes().begin();
+                         mesh_iter != LLVOAvatarDictionary::getInstance()->getMeshes().end();
+                         mesh_iter++)
                 {
-                        switch (lod)
+                        const EMeshIndex mesh_index = mesh_iter->first;
+                        const LLVOAvatarDictionary::MeshDictionaryEntry *mesh_dict = mesh_iter->second;
+                        if (type.compare(mesh_dict->mName) == 0)
                         {
-                          case 0:
-                                mesh = &mUpperBodyMesh0;
+                                mesh_id = mesh_index;
+                                found_mesh_id = TRUE;
                                 break;
-                          case 1:
-                                mesh = &mUpperBodyMesh1;
-                                break;
-                          case 2:
-                                mesh = &mUpperBodyMesh2;
-                                break;
-                          case 3:
-                                mesh = &mUpperBodyMesh3;
-                                break;
-                          case 4:
-                                mesh = &mUpperBodyMesh4;
-                                break;
-                          default:
-                                llwarns << "Avatar file: <mesh> has invalid lod setting " << lod << llendl;
-                                return FALSE;
                         }
                 }
-                else if (type == "lowerBodyMesh")
-                {
-                        switch (lod)
-                        {
-                          case 0:
-                                mesh = &mLowerBodyMesh0;
-                                break;
-                          case 1:
-                                mesh = &mLowerBodyMesh1;
-                                break;
-                          case 2:
-                                mesh = &mLowerBodyMesh2;
-                                break;
-                          case 3:
-                                mesh = &mLowerBodyMesh3;
-                                break;
-                          case 4:
-                                mesh = &mLowerBodyMesh4;
-                                break;
-                          default:
-                                llwarns << "Avatar file: <mesh> has invalid lod setting " << lod << llendl;
-                                return FALSE;
-                        }
-                }       
-                else if (type == "skirtMesh")
-                {
-                        switch (lod)
-                        {
-                          case 0:
-                                mesh = &mSkirtMesh0;
-                                break;
-                          case 1:
-                                mesh = &mSkirtMesh1;
-                                break;
-                          case 2:
-                                mesh = &mSkirtMesh2;
-                                break;
-                          case 3:
-                                mesh = &mSkirtMesh3;
-                                break;
-                          case 4:
-                                mesh = &mSkirtMesh4;
-                                break;
-                          default:
-                                llwarns << "Avatar file: <mesh> has invalid lod setting " << lod << llendl;
-                                return FALSE;
-                        }
-                }
-                else if (type == "eyelashMesh")
-                {
-                        mesh = &mEyeLashMesh0;
-                }
-                else if (type == "eyeBallLeftMesh")
+
+                if (found_mesh_id)
                 {
-                        switch (lod)
+                        if (lod < (S32)mMeshLOD[mesh_id]->mMeshParts.size())
                         {
-                          case 0:
-                                mesh = &mEyeBallLeftMesh0;
-                                break;
-                          case 1:
-                                mesh = &mEyeBallLeftMesh1;
-                                break;
-                          default:
-                                llwarns << "Avatar file: <mesh> has invalid lod setting " << lod << llendl;
-                                return FALSE;
+                                mesh = mMeshLOD[mesh_id]->mMeshParts[lod];
                         }
-                }
-                else if (type == "eyeBallRightMesh")
-                {
-                        switch (lod)
+                        else
                         {
-                          case 0:
-                                mesh = &mEyeBallRightMesh0;
-                                break;
-                          case 1:
-                                mesh = &mEyeBallRightMesh1;
-                                break;
-                          default:
                                 llwarns << "Avatar file: <mesh> has invalid lod setting " << lod << llendl;
                                 return FALSE;
                         }
                 }
-
-                if( !mesh )
+                else 
                 {
                         llwarns << "Ignoring unrecognized mesh type: " << type << llendl;
                         return FALSE;
@@ -5846,15 +5463,16 @@ BOOL LLVOAvatar::loadMeshNodes()
 
                 if (!info->mReferenceMeshName.empty())
                 {
-                        mesh_map_t::iterator iter = mMeshes.find(info->mReferenceMeshName);
-                        if (iter != mMeshes.end())
+                        polymesh_map_t::const_iterator polymesh_iter = mMeshes.find(info->mReferenceMeshName);
+                        if (polymesh_iter != mMeshes.end())
                         {
-                                poly_mesh = LLPolyMesh::getMesh(info->mMeshFileName, iter->second);
+                                poly_mesh = LLPolyMesh::getMesh(info->mMeshFileName, polymesh_iter->second);
                                 poly_mesh->setAvatar(this);
                         }
                         else
                         {
                                 // This should never happen
+                                LL_WARNS("Avatar") << "Could not find avatar mesh: " << info->mReferenceMeshName << LL_ENDL;
                         }
                 }
                 else
@@ -5873,14 +5491,13 @@ BOOL LLVOAvatar::loadMeshNodes()
                 mMeshes.insert(std::make_pair(info->mMeshFileName, poly_mesh));
         
                 mesh->setMesh( poly_mesh );
-
                 mesh->setLOD( info->mMinPixelArea );
 
-                LLVOAvatarInfo::LLVOAvatarMeshInfo::morph_info_list_t::iterator iter;
-                for (iter = info->mPolyMorphTargetInfoList.begin();
-                         iter != info->mPolyMorphTargetInfoList.end(); iter++)
+                for (LLVOAvatarXmlInfo::LLVOAvatarMeshInfo::morph_info_list_t::const_iterator xmlinfo_iter = info->mPolyMorphTargetInfoList.begin();
+                         xmlinfo_iter != info->mPolyMorphTargetInfoList.end(); 
+                         xmlinfo_iter++)
                 {
-                        LLVOAvatarInfo::LLVOAvatarMeshInfo::morph_info_pair_t *info_pair = &(*iter);
+                        const LLVOAvatarXmlInfo::LLVOAvatarMeshInfo::morph_info_pair_t *info_pair = &(*xmlinfo_iter);
                         LLPolyMorphTarget *param = new LLPolyMorphTarget(mesh->getMesh());
                         if (!param->setInfo(info_pair->first))
                         {
@@ -5944,6 +5561,11 @@ void LLVOAvatar::setPixelAreaAndAngle(LLAgent &agent)
 {
         LLMemType mt(LLMemType::MTYPE_AVATAR);
 
+        if (mDrawable.isNull())
+        {
+                return;
+        }
+
         const LLVector3* ext = mDrawable->getSpatialExtents();
         LLVector3 center = (ext[1] + ext[0]) * 0.5f;
         LLVector3 size = (ext[1]-ext[0])*0.5f;
@@ -5965,7 +5587,7 @@ void LLVOAvatar::setPixelAreaAndAngle(LLAgent &agent)
         // We always want to look good to ourselves
         if( mIsSelf )
         {
-                mPixelArea = llmax( mPixelArea, F32(LOCTEX_IMAGE_SIZE_SELF / 16) );
+                mPixelArea = llmax( mPixelArea, F32(TEX_IMAGE_SIZE_SELF / 16) );
         }
 }
 
@@ -6082,7 +5704,7 @@ void LLVOAvatar::updateShadowFaces()
         //
         // render avatar shadows
         //
-        if (mInAir || mUpdatePeriod >= VOAVATAR_IMPOSTOR_PERIOD)
+        if (mInAir || mUpdatePeriod >= IMPOSTOR_PERIOD)
         {
                 face0p->setSize(0, 0);
                 face1p->setSize(0, 0);
@@ -6177,9 +5799,9 @@ void LLVOAvatar::updateShadowFaces()
 //-----------------------------------------------------------------------------
 void LLVOAvatar::updateSexDependentLayerSets( BOOL set_by_user )
 {
-        invalidateComposite( mHeadLayerSet,                     set_by_user );
-        invalidateComposite( mLowerBodyLayerSet,        set_by_user );
-        invalidateComposite( mUpperBodyLayerSet,        set_by_user );
+        invalidateComposite( mBakedTextureData[BAKED_HEAD].mTexLayerSet,  set_by_user );
+        invalidateComposite( mBakedTextureData[BAKED_UPPER].mTexLayerSet,       set_by_user );
+        invalidateComposite( mBakedTextureData[BAKED_LOWER].mTexLayerSet,       set_by_user );
         updateMeshTextures();
 }
 
@@ -6192,74 +5814,32 @@ void LLVOAvatar::dirtyMesh()
 }
 
 //-----------------------------------------------------------------------------
-// requestLayerSetUpdate()
+// hideSkirt()
 //-----------------------------------------------------------------------------
-void LLVOAvatar::requestLayerSetUpdate( LLVOAvatar::ELocTexIndex i )
+void LLVOAvatar::hideSkirt()
 {
-        switch( i )
-        {
-        case LOCTEX_HEAD_BODYPAINT:
-                if( mHeadLayerSet )
-                {
-                        mHeadLayerSet->requestUpdate();
-                }
-                break;
-
-        case LOCTEX_UPPER_BODYPAINT:  
-        case LOCTEX_UPPER_SHIRT:
-        case LOCTEX_UPPER_GLOVES:
-        case LOCTEX_UPPER_UNDERSHIRT:
-                if( mUpperBodyLayerSet )
-                {
-                        mUpperBodyLayerSet->requestUpdate();
-                }
-                break;
-
-        case LOCTEX_LOWER_BODYPAINT:  
-        case LOCTEX_LOWER_PANTS:
-        case LOCTEX_LOWER_SHOES:
-        case LOCTEX_LOWER_SOCKS:
-        case LOCTEX_LOWER_UNDERPANTS:
-                if( mLowerBodyLayerSet )
-                {
-                        mLowerBodyLayerSet->requestUpdate();
-                }
-                break;
-
-        case LOCTEX_EYES_IRIS:
-                if( mEyesLayerSet )
-                {
-                        mEyesLayerSet->requestUpdate();
-                }
-                break;
-
-
-        case LOCTEX_SKIRT:
-                if( mSkirtLayerSet )
-                {
-                        mSkirtLayerSet->requestUpdate();
-                }
-                break;
-
-
-        case LOCTEX_UPPER_JACKET:
-        case LOCTEX_LOWER_JACKET:
-                if( mUpperBodyLayerSet )
-                {
-                        mUpperBodyLayerSet->requestUpdate();
-                }
+        mMeshLOD[MESH_ID_SKIRT]->setVisible(FALSE, TRUE);
+}
 
-                if( mLowerBodyLayerSet )
-                {
-                        mLowerBodyLayerSet->requestUpdate();
-                }
-                break;
 
-        case LOCTEX_NUM_ENTRIES:
-                llerrs << "Bogus texture value " << i << llendl;
-                break;
+//-----------------------------------------------------------------------------
+// requestLayerSetUpdate()
+//-----------------------------------------------------------------------------
+void LLVOAvatar::requestLayerSetUpdate(ETextureIndex index )
+{
+        /* switch(index)
+                case LOCTEX_UPPER_BODYPAINT:  
+                case LOCTEX_UPPER_SHIRT:
+                        if( mUpperBodyLayerSet )
+                                mUpperBodyLayerSet->requestUpdate(); */
+        const LLVOAvatarDictionary::TextureDictionaryEntry *texture_dict = LLVOAvatarDictionary::getInstance()->getTexture(index);
+        if (!texture_dict->mIsLocalTexture || !texture_dict->mIsUsedByBakedTexture)
+                return;
+        const EBakedTextureIndex baked_index = texture_dict->mBakedTextureIndex;
+        if (mBakedTextureData[baked_index].mTexLayerSet)
+        {
+                mBakedTextureData[baked_index].mTexLayerSet->requestUpdate();
         }
-
 }
 
 void LLVOAvatar::setParent(LLViewerObject* parent)
@@ -6348,15 +5928,21 @@ BOOL LLVOAvatar::attachObject(LLViewerObject *viewer_object)
 //-----------------------------------------------------------------------------
 void LLVOAvatar::lazyAttach()
 {
+        std::vector<LLPointer<LLViewerObject> > still_pending;
+        
         for (U32 i = 0; i < mPendingAttachment.size(); i++)
         {
                 if (mPendingAttachment[i]->mDrawable)
                 {
                         attachObject(mPendingAttachment[i]);
                 }
+                else
+                {
+                        still_pending.push_back(mPendingAttachment[i]);
+                }
         }
 
-        mPendingAttachment.clear();
+        mPendingAttachment = still_pending;
 }
 
 void LLVOAvatar::resetHUDAttachments()
@@ -6614,6 +6200,7 @@ const std::string LLVOAvatar::getAttachedPointName(const LLUUID& inv_item_id)
 // static 
 // onLocalTextureLoaded()
 //-----------------------------------------------------------------------------
+
 void LLVOAvatar::onLocalTextureLoaded( BOOL success, LLViewerImage *src_vi, LLImageRaw* src_raw, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata )
 {
         //llinfos << "onLocalTextureLoaded: " << src_vi->getID() << llendl;
@@ -6623,37 +6210,47 @@ void LLVOAvatar::onLocalTextureLoaded( BOOL success, LLViewerImage *src_vi, LLIm
         if (success)
         {
                 LLVOAvatar *self = (LLVOAvatar *)gObjectList.findObject(data->mAvatarID);
-                LLVOAvatar::ELocTexIndex idx = data->mIndex;
-                if( self &&
-                        (!self->mLocalTextureBaked[ idx ]) &&
-                        (self->mLocalTexture[ idx ].notNull()) &&
-                        (self->mLocalTexture[ idx ]->getID() == src_id) &&
-                        (discard_level < self->mLocalTextureDiscard[idx]))
-                {
-                        self->mLocalTextureDiscard[idx] = discard_level;
-                        self->requestLayerSetUpdate( idx );
-                        if( self->mIsSelf && gAgent.cameraCustomizeAvatar() )
-                        {
-                                LLVisualParamHint::requestHintUpdates();
+                if (self)
+                {
+                        ETextureIndex index = data->mIndex;
+                        if (!self->isIndexLocalTexture(index)) return;
+                        LocalTextureData &local_tex_data = self->mLocalTextureData[index];
+                        if(!local_tex_data.mIsBakedReady &&
+                           local_tex_data.mImage.notNull() &&
+                           (local_tex_data.mImage->getID() == src_id) &&
+                           discard_level < local_tex_data.mDiscard)
+                        {
+                                local_tex_data.mDiscard = discard_level;
+                                if ( self->isSelf() && !gAgent.cameraCustomizeAvatar() )
+                                {
+                                        self->requestLayerSetUpdate( index );
+                                }
+                                else if( self->isSelf() && gAgent.cameraCustomizeAvatar() )
+                                {
+                                        LLVisualParamHint::requestHintUpdates();
+                                }
+                                self->updateMeshTextures();
                         }
-                        self->updateMeshTextures();
                 }
         }
         else if (final)
         {
                 LLVOAvatar *self = (LLVOAvatar *)gObjectList.findObject(data->mAvatarID);
-                LLVOAvatar::ELocTexIndex idx = data->mIndex;
-                // Failed: asset is missing
-                if( self &&
-                        (!self->mLocalTextureBaked[ idx ]) &&
-                        (self->mLocalTexture[ idx ].notNull()) &&
-                        (self->mLocalTexture[ idx ]->getID() == src_id))
+                if (self)
                 {
-                        self->mLocalTextureDiscard[idx] = 0; // we check that it's missing later
-                        self->requestLayerSetUpdate( idx );
-                        self->updateMeshTextures();
+                        ETextureIndex index = data->mIndex;
+                        if (!self->isIndexLocalTexture(index)) return;
+                        LocalTextureData &local_tex_data = self->mLocalTextureData[index];
+                        // Failed: asset is missing
+                        if(!local_tex_data.mIsBakedReady &&
+                           local_tex_data.mImage.notNull() &&
+                           local_tex_data.mImage->getID() == src_id)
+                        {
+                                local_tex_data.mDiscard = 0;
+                                self->requestLayerSetUpdate( index );
+                                self->updateMeshTextures();
+                        }
                 }
-                
         }
 
         if( final || !success )
@@ -6664,29 +6261,13 @@ void LLVOAvatar::onLocalTextureLoaded( BOOL success, LLViewerImage *src_vi, LLIm
 
 void LLVOAvatar::updateComposites()
 {
-        if( mHeadLayerSet )
-        {
-                mHeadLayerSet->updateComposite();
-        }
-
-        if( mUpperBodyLayerSet )
+        for (U32 i = 0; i < mBakedTextureData.size(); i++)
         {
-                mUpperBodyLayerSet->updateComposite();
-        }
-
-        if( mLowerBodyLayerSet )
-        {
-                mLowerBodyLayerSet->updateComposite();
-        }
-
-        if( mEyesLayerSet )
-        {
-                mEyesLayerSet->updateComposite();
-        }
-
-        if( mSkirtLayerSet && isWearingWearableType( WT_SKIRT ))
-        {
-                mSkirtLayerSet->updateComposite();
+                if ( mBakedTextureData[i].mTexLayerSet 
+                        && ((i != BAKED_SKIRT) || isWearingWearableType( WT_SKIRT )) )
+                {
+                        mBakedTextureData[i].mTexLayerSet->updateComposite();
+                }
         }
 }
 
@@ -6738,6 +6319,10 @@ void LLVOAvatar::invalidateComposite( LLTexLayerSet* layerset, BOOL set_by_user
         {
                 layer_name = "eyes";
         }
+        else if (layerset == mHairLayerSet)
+        {
+                layer_name = "hair";
+        }
         else if (layerset == mSkirtLayerSet)
         {
                 layer_name = "skirt";
@@ -6756,47 +6341,52 @@ void LLVOAvatar::invalidateComposite( LLTexLayerSet* layerset, BOOL set_by_user
                 llassert( mIsSelf );
 
                 ETextureIndex baked_te = getBakedTE( layerset );
-                if( gAgent.cameraCustomizeAvatar() )
-                {
-                        mSavedTE[ baked_te ].setNull();  
-                }
-                else
-                {
-                        setTEImage( baked_te, gImageList.getImage(IMG_DEFAULT_AVATAR) );
-                        layerset->requestUpload();
-                }
+                setTEImage( baked_te, gImageList.getImage(IMG_DEFAULT_AVATAR) );
+                layerset->requestUpload();
         }
 }
 
+void LLVOAvatar::invalidateAll()
+{
+        for (U32 i = 0; i < mBakedTextureData.size(); i++)
+        {
+                invalidateComposite(mBakedTextureData[i].mTexLayerSet, TRUE);
+        }
+        updateMeshTextures();
+}
 
 void LLVOAvatar::onGlobalColorChanged( LLTexGlobalColor* global_color, BOOL set_by_user )
 {
         if( global_color == mTexSkinColor )
         {
 //              llinfos << "invalidateComposite cause: onGlobalColorChanged( skin color )" << llendl; 
-                invalidateComposite( mHeadLayerSet,                     set_by_user );
-                invalidateComposite( mUpperBodyLayerSet,        set_by_user );
-                invalidateComposite( mLowerBodyLayerSet,        set_by_user );
+                invalidateComposite( mBakedTextureData[BAKED_HEAD].mTexLayerSet,  set_by_user );
+                invalidateComposite( mBakedTextureData[BAKED_UPPER].mTexLayerSet,       set_by_user );
+                invalidateComposite( mBakedTextureData[BAKED_LOWER].mTexLayerSet,       set_by_user );
         }
         else
         if( global_color == mTexHairColor )
         {
 //              llinfos << "invalidateComposite cause: onGlobalColorChanged( hair color )" << llendl; 
-                invalidateComposite( mHeadLayerSet, set_by_user );
-
-                LLColor4 color = mTexHairColor->getColor();
-                mHairMesh0.setColor( color.mV[VX], color.mV[VY], color.mV[VZ], color.mV[VW] );
-                mHairMesh1.setColor( color.mV[VX], color.mV[VY], color.mV[VZ], color.mV[VW] );
-                mHairMesh2.setColor( color.mV[VX], color.mV[VY], color.mV[VZ], color.mV[VW] );
-                mHairMesh3.setColor( color.mV[VX], color.mV[VY], color.mV[VZ], color.mV[VW] );
-                mHairMesh4.setColor( color.mV[VX], color.mV[VY], color.mV[VZ], color.mV[VW] );
-                mHairMesh5.setColor( color.mV[VX], color.mV[VY], color.mV[VZ], color.mV[VW] );
+                invalidateComposite( mBakedTextureData[BAKED_HEAD].mTexLayerSet,  set_by_user );
+                invalidateComposite( mBakedTextureData[BAKED_HAIR].mTexLayerSet,  set_by_user );
+                
+                // ! BACKWARDS COMPATIBILITY !
+                // Fix for dealing with avatars from viewers that don't bake hair.
+                if (!isTextureDefined(mBakedTextureData[BAKED_HAIR].mTextureIndex))
+                {
+                        LLColor4 color = mTexHairColor->getColor();
+                        for (U32 i = 0; i < mBakedTextureData[BAKED_HAIR].mMeshes.size(); i++)
+                        {
+                                mBakedTextureData[BAKED_HAIR].mMeshes[i]->setColor( color.mV[VX], color.mV[VY], color.mV[VZ], color.mV[VW] );
+                        }
+                }
         }
         else
         if( global_color == mTexEyeColor )
         {
 //              llinfos << "invalidateComposite cause: onGlobalColorChanged( eyecolor )" << llendl; 
-                invalidateComposite( mEyesLayerSet, set_by_user );
+                invalidateComposite( mBakedTextureData[BAKED_EYES].mTexLayerSet,  set_by_user );
         }
         updateMeshTextures();
 }
@@ -6805,9 +6395,9 @@ void LLVOAvatar::forceBakeAllTextures(bool slam_for_debug)
 {
         llinfos << "TAT: forced full rebake. " << llendl;
 
-        for (S32 i = 0; i < BAKED_TEXTURE_COUNT; i++)
+        for (U32 i = 0; i < mBakedTextureData.size(); i++)
         {
-                ETextureIndex baked_index = sBakedTextureIndices[i];
+                ETextureIndex baked_index = mBakedTextureData[i].mTextureIndex;
                 LLTexLayerSet* layer_set = getLayerSet(baked_index);
                 if (layer_set)
                 {
@@ -6844,20 +6434,30 @@ void LLVOAvatar::processRebakeAvatarTextures(LLMessageSystem* msg, void**)
         // If this is a texture corresponding to one of our baked entries, 
         // just rebake that layer set.
         BOOL found = FALSE;
-        for (S32 i = 0; i < BAKED_TEXTURE_COUNT; i++)
+
+        /* ETextureIndex baked_texture_indices[BAKED_NUM_INDICES] =
+                        TEX_HEAD_BAKED,
+                        TEX_UPPER_BAKED, */
+        for (LLVOAvatarDictionary::texture_map_t::const_iterator iter = LLVOAvatarDictionary::getInstance()->getTextures().begin();
+                 iter != LLVOAvatarDictionary::getInstance()->getTextures().end();
+                 iter++)
         {
-                ETextureIndex baked_index = sBakedTextureIndices[i];
-                if (texture_id == self->getTEImage(baked_index)->getID())
+                const ETextureIndex index = iter->first;
+                const LLVOAvatarDictionary::TextureDictionaryEntry *text_dict = iter->second;
+                if (text_dict->mIsBakedTexture)
                 {
-                        LLTexLayerSet* layer_set = self->getLayerSet(baked_index);
-                        if (layer_set)
+                        if (texture_id == self->getTEImage(index)->getID())
                         {
-                                llinfos << "TAT: rebake - matched entry " << (S32)baked_index << llendl;
-                                // Apparently set_by_user == force upload
-                                BOOL set_by_user = TRUE;
-                                self->invalidateComposite(layer_set, set_by_user);
-                                found = TRUE;
-                                LLViewerStats::getInstance()->incStat(LLViewerStats::ST_TEX_REBAKES);
+                                LLTexLayerSet* layer_set = self->getLayerSet(index);
+                                if (layer_set)
+                                {
+                                        llinfos << "TAT: rebake - matched entry " << (S32)index << llendl;
+                                        // Apparently set_by_user == force upload
+                                        BOOL set_by_user = TRUE;
+                                        self->invalidateComposite(layer_set, set_by_user);
+                                        found = TRUE;
+                                        LLViewerStats::getInstance()->incStat(LLViewerStats::ST_TEX_REBAKES);
+                                }
                         }
                 }
         }
@@ -6875,48 +6475,48 @@ void LLVOAvatar::processRebakeAvatarTextures(LLMessageSystem* msg, void**)
 }
 
 
-BOOL LLVOAvatar::getLocalTextureRaw(S32 index, LLImageRaw* image_raw)
+BOOL LLVOAvatar::getLocalTextureRaw(ETextureIndex index, LLImageRaw* image_raw)
 {
+        if (!isIndexLocalTexture(index)) return FALSE;
+
     BOOL success = FALSE;
 
-        if( (0 <= index) && (index < LOCTEX_NUM_ENTRIES) )
+        if (getLocalTextureID(index) == IMG_DEFAULT_AVATAR)
+        {
+                success = TRUE;
+        }
+        else
         {
-                if (mLocalTexture[ index ].isNull() || mLocalTexture[ index ]->getID() == IMG_DEFAULT_AVATAR )
+                LocalTextureData &local_tex_data = mLocalTextureData[index];
+                if(local_tex_data.mImage->readBackRaw(-1, image_raw, false))
                 {
                         success = TRUE;
                 }
                 else
                 {
-                        if( mLocalTexture[ index ]->readBackRaw(-1, image_raw, false) )
-                        {
-                                success = TRUE;
-                        }
-                        else
-                        {
-                                // No data loaded yet
-                                setLocalTexture( (ELocTexIndex)index, getTEImage( index ), FALSE );
-                        }
+                        // No data loaded yet
+                        setLocalTexture( (ETextureIndex)index, getTEImage( index ), FALSE );
                 }
         }
         return success;
 }
 
-BOOL LLVOAvatar::getLocalTextureGL(S32 index, LLImageGL** image_gl_pp)
+BOOL LLVOAvatar::getLocalTextureGL(ETextureIndex index, LLImageGL** image_gl_pp)
 {
+        if (!isIndexLocalTexture(index)) return FALSE;
+
         BOOL success = FALSE;
         *image_gl_pp = NULL;
 
-        if( (0 <= index) && (index < LOCTEX_NUM_ENTRIES) )
+        if (getLocalTextureID(index) == IMG_DEFAULT_AVATAR)
         {
-                if( mLocalTexture[ index ].isNull() || mLocalTexture[ index ]->getID() == IMG_DEFAULT_AVATAR)
-                {
-                        success = TRUE;
-                }
-                else
-                {
-                        *image_gl_pp = mLocalTexture[ index ];
-                        success = TRUE;
-                }
+                success = TRUE;
+        }
+        else
+        {
+                LocalTextureData &local_tex_data = mLocalTextureData[index];
+                *image_gl_pp = local_tex_data.mImage;
+                success = TRUE;
         }
 
         if( !success )
@@ -6926,11 +6526,13 @@ BOOL LLVOAvatar::getLocalTextureGL(S32 index, LLImageGL** image_gl_pp)
         return success;
 }
 
-const LLUUID& LLVOAvatar::getLocalTextureID( S32 index )
+const LLUUID& LLVOAvatar::getLocalTextureID(ETextureIndex index)
 {
-        if (index >= 0 && mLocalTexture[index].notNull())
+        if (!isIndexLocalTexture(index)) return IMG_DEFAULT_AVATAR;
+        
+        if (mLocalTextureData[index].mImage.notNull())
         {
-                return mLocalTexture[index]->getID();
+                return mLocalTextureData[index].mImage->getID();
         }
         else
         {
@@ -6956,8 +6558,7 @@ void LLVOAvatar::dumpTotalLocalTextureByteCount()
 BOOL LLVOAvatar::isVisible()
 {
         return mDrawable.notNull()
-                && (mDrawable->isVisible() || mIsDummy)
-                && (mVisibilityRank < (U32) sMaxVisible || gFrameTimeSeconds - mFadeTime < 1.f); 
+                && (mDrawable->isVisible() || mIsDummy);
 }
 
 
@@ -6976,8 +6577,15 @@ BOOL LLVOAvatar::updateIsFullyLoaded()
                 loading = TRUE;
         }
 
-        // are our texture settings still default?
-        if ((getTEImage( TEX_HAIR )->getID() == IMG_DEFAULT))
+        // 
+        if (mIsSelf)
+        {
+                if (!isTextureDefined(TEX_HAIR))
+                {
+                        loading = TRUE;
+                }
+        }
+        else if (!isTextureDefined(TEX_LOWER_BAKED) || !isTextureDefined(TEX_UPPER_BAKED) || !isTextureDefined(TEX_HEAD_BAKED))
         {
                 loading = TRUE;
         }
@@ -6997,14 +6605,14 @@ BOOL LLVOAvatar::updateIsFullyLoaded()
         // texture info for our shirt/pants, stay unloaded:
         if (!mPreviousFullyLoaded)
         {
-                if ((!isLocalTextureDataAvailable(mLowerBodyLayerSet)) &&
-                        (getTEImage(TEX_LOWER_BAKED)->getID() == IMG_DEFAULT_AVATAR))
+                if ((!isLocalTextureDataAvailable(mBakedTextureData[BAKED_LOWER].mTexLayerSet)) &&
+                        (!isTextureDefined(TEX_LOWER_BAKED)))
                 {
                         loading = TRUE;
                 }
 
-                if ((!isLocalTextureDataAvailable(mUpperBodyLayerSet)) &&
-                        (getTEImage(TEX_UPPER_BAKED)->getID() == IMG_DEFAULT_AVATAR))
+                if ((!isLocalTextureDataAvailable(mBakedTextureData[BAKED_UPPER].mTexLayerSet)) &&
+                        (!isTextureDefined(TEX_UPPER_BAKED)))
                 {
                         loading = TRUE;
                 }
@@ -7056,9 +6664,10 @@ LLMotion*		LLVOAvatar::findMotion(const LLUUID& id)
 void LLVOAvatar::getLocalTextureByteCount( S32* gl_bytes )
 {
         *gl_bytes = 0;
-        for( S32 i = 0; i < LOCTEX_NUM_ENTRIES; i++ )
+        for( S32 i = 0; i < TEX_NUM_INDICES; i++ )
         {
-                LLViewerImage* image_gl = mLocalTexture[i];
+                if (!isIndexLocalTexture((ETextureIndex)i)) continue;
+                LLViewerImage* image_gl = mLocalTextureData[(ETextureIndex)i].mImage;
                 if( image_gl )
                 {
                         S32 bytes = (S32)image_gl->getWidth() * image_gl->getHeight() * image_gl->getComponents();
@@ -7121,7 +6730,7 @@ LLGLuint LLVOAvatar::getScratchTexName( LLGLenum format, U32* texture_bytes )
         default:        llassert(0);    components = 4; internal_format = GL_RGBA8;                             break;
         }
 
-        *texture_bytes = components * VOAVATAR_SCRATCH_TEX_WIDTH * VOAVATAR_SCRATCH_TEX_HEIGHT;
+        *texture_bytes = components * SCRATCH_TEX_WIDTH * SCRATCH_TEX_HEIGHT;
         
         if( LLVOAvatar::sScratchTexNames.checkData( format ) )
         {
@@ -7132,23 +6741,21 @@ LLGLuint LLVOAvatar::getScratchTexName( LLGLenum format, U32* texture_bytes )
 
                 LLGLSUIDefault gls_ui;
 
-                GLuint name = 0;
-                glGenTextures(1, &name );
+                U32 name = 0;
+                LLImageGL::generateTextures(1, &name );
                 stop_glerror();
 
                 gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, name);
                 stop_glerror();
 
-                glTexImage2D(
+                LLImageGL::setManualImage(
                         GL_TEXTURE_2D, 0, internal_format, 
-                        VOAVATAR_SCRATCH_TEX_WIDTH, VOAVATAR_SCRATCH_TEX_HEIGHT,
-                        0, format, GL_UNSIGNED_BYTE, NULL );
+                        SCRATCH_TEX_WIDTH, SCRATCH_TEX_HEIGHT,
+                        format, GL_UNSIGNED_BYTE, NULL );
                 stop_glerror();
 
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-                glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
-                glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+                gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR);
+                gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
                 stop_glerror();
 
                 gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
@@ -7175,7 +6782,7 @@ void LLVOAvatar::setLocTexTE( U8 te, LLViewerImage* image, BOOL set_by_user )
                 return;
         }
 
-        if( te >= TEX_NUM_ENTRIES )
+        if( te >= TEX_NUM_INDICES )
         {
                 llassert(0);
                 return;
@@ -7186,7 +6793,7 @@ void LLVOAvatar::setLocTexTE( U8 te, LLViewerImage* image, BOOL set_by_user )
                 return;
         }
 
-        if (isTextureIndexBaked(te))
+        if (isIndexBakedTexture((ETextureIndex)te))
         {
                 llassert(0);
                 return;
@@ -7209,32 +6816,13 @@ void LLVOAvatar::setLocTexTE( U8 te, LLViewerImage* image, BOOL set_by_user )
 
 void LLVOAvatar::setupComposites()
 {
-        // Don't invalidate the baked textures we had on start-up.
-        BOOL head_baked =  ( getTEImage( TEX_HEAD_BAKED  )->getID() != IMG_DEFAULT_AVATAR );
-        BOOL upper_baked = ( getTEImage( TEX_UPPER_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-        BOOL lower_baked = ( getTEImage( TEX_LOWER_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-        BOOL eyes_baked =  ( getTEImage( TEX_EYES_BAKED  )->getID() != IMG_DEFAULT_AVATAR );
-        BOOL skirt_baked = ( getTEImage( TEX_SKIRT_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-        
-        if (mHeadLayerSet)
+        for (U32 i = 0; i < mBakedTextureData.size(); i++)
         {
-                mHeadLayerSet->setUpdatesEnabled(               !head_baked  );
-        }
-        if (mUpperBodyLayerSet)
-        {
-                mUpperBodyLayerSet->setUpdatesEnabled(  !upper_baked );
-        }
-        if (mLowerBodyLayerSet)
-        {
-                mLowerBodyLayerSet->setUpdatesEnabled(  !lower_baked );
-        }
-        if (mEyesLayerSet)
-        {
-                mEyesLayerSet->setUpdatesEnabled(               !eyes_baked  );
-        }
-        if (mSkirtLayerSet)
-        {
-                mSkirtLayerSet->setUpdatesEnabled(              !skirt_baked  );
+                bool layer_baked = isTextureDefined(mBakedTextureData[i].mTextureIndex);
+                if (mBakedTextureData[i].mTexLayerSet)
+                {
+                        mBakedTextureData[i].mTexLayerSet->setUpdatesEnabled( !layer_baked );
+                }
         }
 }
 
@@ -7244,447 +6832,193 @@ void LLVOAvatar::setupComposites()
 //-----------------------------------------------------------------------------
 void LLVOAvatar::updateMeshTextures()
 {
-//      llinfos << "updateMeshTextures" << llendl;
-        if (gNoRender)
-        {
-                return;
-        }
+    // llinfos << "updateMeshTextures" << llendl;
+        if (gNoRender) return;
+
         // if user has never specified a texture, assign the default
-        LLViewerImage* default_tex = gImageList.getImage(IMG_DEFAULT);
-        U8 num_TEs = getNumTEs();
-        for (U32 i=0; i<num_TEs; i++)
+        for (U32 i=0; i < getNumTEs(); i++)
         {
-                LLViewerImage* te_image = getTEImage(i);
-                if( (NULL == te_image) || te_image->getID().isNull() || (te_image->getID() == IMG_DEFAULT) )
+                const LLViewerImage* te_image = getTEImage(i);
+                if(!te_image || te_image->getID().isNull() || (te_image->getID() == IMG_DEFAULT))
                 {
-                        if( TEX_HAIR == i )
-                        {
-                                setTEImage(i, default_tex );
-                        }
-                        else
-                        {
-                                setTEImage(i, gImageList.getImage(IMG_DEFAULT_AVATAR)); // a special texture that's never rendered.
-                        }
+                        setTEImage(i, gImageList.getImage(i == TEX_HAIR ? IMG_DEFAULT : IMG_DEFAULT_AVATAR)); // IMG_DEFAULT_AVATAR = a special texture that's never rendered.
                 }
         }
 
-        // During face edit mode, we don't use baked textures
-        BOOL self_customize = mIsSelf && gAgent.cameraCustomizeAvatar();
+        const BOOL self_customizing = mIsSelf && gAgent.cameraCustomizeAvatar(); // During face edit mode, we don't use baked textures
+        const BOOL other_culled = !mIsSelf && mCulled;
 
-        BOOL head_baked = (getTEImage( TEX_HEAD_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-        BOOL upper_baked = (getTEImage( TEX_UPPER_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-        BOOL lower_baked = (getTEImage( TEX_LOWER_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-        BOOL eyes_baked = (getTEImage( TEX_EYES_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-        BOOL skirt_baked = (getTEImage( TEX_SKIRT_BAKED )->getID() != IMG_DEFAULT_AVATAR );
+        std::vector<bool> is_layer_baked;
+        is_layer_baked.resize(mBakedTextureData.size(), false);
 
-        // Nothing should be baked if we're in customize avatar mode.
-        llassert( !( self_customize && 
-                ( head_baked || upper_baked || lower_baked || eyes_baked ) ) );
+        std::vector<bool> use_lkg_baked_layer; // lkg = "last known good"
+        use_lkg_baked_layer.resize(mBakedTextureData.size(), false);
 
-        BOOL use_lkg_head_baked =  FALSE;
-        BOOL use_lkg_upper_baked = FALSE;
-        BOOL use_lkg_lower_baked = FALSE;
-        BOOL use_lkg_eyes_baked =  FALSE;
-        BOOL use_lkg_skirt_baked =  FALSE;
-
-        BOOL other_culled = !mIsSelf && mCulled;
-        if( other_culled )
+        for (U32 i=0; i < mBakedTextureData.size(); i++)
         {
-                use_lkg_head_baked =  !head_baked  && (mLastHeadBakedID != IMG_DEFAULT_AVATAR);
-                use_lkg_upper_baked = !upper_baked && (mLastUpperBodyBakedID != IMG_DEFAULT_AVATAR);
-                use_lkg_lower_baked = !lower_baked && (mLastLowerBodyBakedID != IMG_DEFAULT_AVATAR);
-                use_lkg_eyes_baked =  !eyes_baked  && (mLastEyesBakedID != IMG_DEFAULT_AVATAR);
-                use_lkg_skirt_baked = !skirt_baked && (mLastSkirtBakedID != IMG_DEFAULT_AVATAR);
-
-                if( mHeadLayerSet )
-                {
-                        mHeadLayerSet->destroyComposite();
-                }
+                is_layer_baked[i] = isTextureDefined(mBakedTextureData[i].mTextureIndex);
 
-                if( mUpperBodyLayerSet )
+                if (!other_culled)
                 {
-                        mUpperBodyLayerSet->destroyComposite();
-                }
-
-                if( mLowerBodyLayerSet )
-                {
-                        mLowerBodyLayerSet->destroyComposite();
-                }
-
-                if( mEyesLayerSet )
-                {
-                        mEyesLayerSet->destroyComposite();
-                }
-
-                if( mSkirtLayerSet )
-                {
-                        mSkirtLayerSet->destroyComposite();
-                }
-
-        }
-        else
-        if( !self_customize )
-        {
-                // When you're changing clothes and you're not in Appearance mode,
-                // use the last-known good baked texture until you finish the first
-                // render of the new layerset.
-                use_lkg_head_baked =  !head_baked  && (mLastHeadBakedID      != IMG_DEFAULT_AVATAR) && mHeadLayerSet      && !mHeadLayerSet->getComposite()->isInitialized();
-                use_lkg_upper_baked = !upper_baked && (mLastUpperBodyBakedID != IMG_DEFAULT_AVATAR) && mUpperBodyLayerSet && !mUpperBodyLayerSet->getComposite()->isInitialized();
-                use_lkg_lower_baked = !lower_baked && (mLastLowerBodyBakedID != IMG_DEFAULT_AVATAR) && mLowerBodyLayerSet && !mLowerBodyLayerSet->getComposite()->isInitialized();
-                use_lkg_eyes_baked =  !eyes_baked  && (mLastEyesBakedID      != IMG_DEFAULT_AVATAR) && mEyesLayerSet      && !mEyesLayerSet->getComposite()->isInitialized();
-                use_lkg_skirt_baked = !skirt_baked && (mLastSkirtBakedID     != IMG_DEFAULT_AVATAR) && mSkirtLayerSet     && !mSkirtLayerSet->getComposite()->isInitialized();
-
-                if( use_lkg_head_baked ) 
-                {
-                        mHeadLayerSet->setUpdatesEnabled( TRUE );
-                }
-
-                if( use_lkg_upper_baked ) 
-                {
-                        mUpperBodyLayerSet->setUpdatesEnabled( TRUE );
-                }
-
-                if( use_lkg_lower_baked )
-                {
-                        mLowerBodyLayerSet->setUpdatesEnabled( TRUE );
+                        // When an avatar is changing clothes and not in Appearance mode,
+                        // use the last-known good baked texture until it finish the first
+                        // render of the new layerset.
+                        use_lkg_baked_layer[i] = (!is_layer_baked[i] 
+                                                                          && (mBakedTextureData[i].mLastTextureIndex != IMG_DEFAULT_AVATAR) 
+                                                                          && mBakedTextureData[i].mTexLayerSet 
+                                                                          && !mBakedTextureData[i].mTexLayerSet->getComposite()->isInitialized());
+                        if (use_lkg_baked_layer[i])
+                        {
+                                mBakedTextureData[i].mTexLayerSet->setUpdatesEnabled(TRUE);
+                        }
                 }
-
-                if( use_lkg_eyes_baked )  
+                else
                 {
-                        mEyesLayerSet->setUpdatesEnabled( TRUE );
+                        use_lkg_baked_layer[i] = (!is_layer_baked[i] 
+                                                                          && mBakedTextureData[i].mLastTextureIndex != IMG_DEFAULT_AVATAR);
+                        if (mBakedTextureData[i].mTexLayerSet)
+                        {
+                                mBakedTextureData[i].mTexLayerSet->destroyComposite();
+                        }
                 }
 
-                if( use_lkg_skirt_baked )  
-                {
-                        mSkirtLayerSet->setUpdatesEnabled( TRUE );
-                }
         }
 
         // Baked textures should be requested from the sim this avatar is on. JC
-        LLHost target_host = getObjectHost();
+        const LLHost target_host = getObjectHost();
         if (!target_host.isOk())
         {
                 llwarns << "updateMeshTextures: invalid host for object: " << getID() << llendl;
         }
-                
-        // Head
-        if( use_lkg_head_baked )
-        {
-                LLViewerImage* baked = gImageList.getImageFromHost( mLastHeadBakedID, target_host );
-                mHeadMesh0.setTexture( baked );
-                mHeadMesh1.setTexture( baked );
-                mHeadMesh2.setTexture( baked );
-                mHeadMesh3.setTexture( baked );
-                mHeadMesh4.setTexture( baked );
-                mEyeLashMesh0.setTexture( baked );
-        }
-        else
-        if( !self_customize && head_baked )
+        
+        for (U32 i=0; i < mBakedTextureData.size(); i++)
         {
-                LLViewerImage* baked = getTEImage( TEX_HEAD_BAKED );
-                if( baked->getID() == mLastHeadBakedID )
+                if (use_lkg_baked_layer[i] && !self_customizing )
                 {
-                        // Even though the file may not be finished loading, we'll consider it loaded and use it (rather than doing compositing).
-                        useBakedTexture( baked->getID() );
-                }
-                else
-                {
-                        mHeadBakedLoaded = FALSE;
-                        mHeadMaskDiscard = -1;
-                        baked->setLoadedCallback(onBakedTextureMasksLoaded, MORPH_MASK_REQUESTED_DISCARD, TRUE, TRUE, new LLTextureMaskData( mID ));    
-                        baked->setLoadedCallback(onBakedTextureLoaded, SWITCH_TO_BAKED_DISCARD, FALSE, FALSE, new LLUUID( mID ) );
+                        LLViewerImage* baked_img = gImageList.getImageFromHost( mBakedTextureData[i].mLastTextureIndex, target_host );
+                        for (U32 k=0; k < mBakedTextureData[i].mMeshes.size(); k++)
+                        {
+                                mBakedTextureData[i].mMeshes[k]->setTexture( baked_img );
+                        }
                 }
-        }
-        else
-        if( mHeadLayerSet && !other_culled )
-        {
-                mHeadLayerSet->createComposite();
-                mHeadLayerSet->setUpdatesEnabled( TRUE );
-                mHeadMesh0.setLayerSet( mHeadLayerSet );
-                mHeadMesh1.setLayerSet( mHeadLayerSet );
-                mHeadMesh2.setLayerSet( mHeadLayerSet );
-                mHeadMesh3.setLayerSet( mHeadLayerSet );
-                mHeadMesh4.setLayerSet( mHeadLayerSet );
-                mEyeLashMesh0.setLayerSet( mHeadLayerSet );
-        }
-        else
-        {
-                mHeadMesh0.setTexture( default_tex );
-                mHeadMesh1.setTexture( default_tex );
-                mHeadMesh2.setTexture( default_tex );
-                mHeadMesh3.setTexture( default_tex );
-                mHeadMesh4.setTexture( default_tex );
-                mEyeLashMesh0.setTexture( default_tex );
-        }
-
-        // Upper body
-        if( use_lkg_upper_baked )
-        {
-                LLViewerImage* baked = gImageList.getImageFromHost( mLastUpperBodyBakedID, target_host );
-                mUpperBodyMesh0.setTexture( baked );
-                mUpperBodyMesh1.setTexture( baked );
-                mUpperBodyMesh2.setTexture( baked );
-                mUpperBodyMesh3.setTexture( baked );
-                mUpperBodyMesh4.setTexture( baked );
-        }
-        else
-        if( !self_customize && upper_baked )
-        {
-                LLViewerImage* baked = getTEImage( TEX_UPPER_BAKED );
-
-                if( baked->getID() == mLastUpperBodyBakedID )
+                else if (!self_customizing && is_layer_baked[i])
                 {
-                        // Even though the file may not be finished loading, we'll consider it loaded and use it (rather than doing compositing).
-                        useBakedTexture( baked->getID() );
+                        LLViewerImage* baked_img = getTEImage( mBakedTextureData[i].mTextureIndex );
+                        if( baked_img->getID() == mBakedTextureData[i].mLastTextureIndex )
+                        {
+                                // Even though the file may not be finished loading, we'll consider it loaded and use it (rather than doing compositing).
+                                useBakedTexture( baked_img->getID() );
+                        }
+                        else
+                        {
+                                mBakedTextureData[i].mIsLoaded = FALSE;
+                                if ( (i == BAKED_HEAD) || (i == BAKED_UPPER) || (i == BAKED_LOWER) )
+                                {
+                                        baked_img->setLoadedCallback(onBakedTextureMasksLoaded, MORPH_MASK_REQUESTED_DISCARD, TRUE, TRUE, new LLTextureMaskData( mID ));        
+                                }
+                                baked_img->setLoadedCallback(onBakedTextureLoaded, SWITCH_TO_BAKED_DISCARD, FALSE, FALSE, new LLUUID( mID ) );
+                        }
                 }
-                else
+                else if (mBakedTextureData[i].mTexLayerSet 
+                                 && !other_culled 
+                                 && (i != BAKED_HAIR || is_layer_baked[i] || mIsSelf)) // ! BACKWARDS COMPATIBILITY ! workaround for old viewers.
                 {
-                        mUpperBakedLoaded = FALSE;
-                        mUpperMaskDiscard = -1;
-                        baked->setLoadedCallback(onBakedTextureMasksLoaded, MORPH_MASK_REQUESTED_DISCARD, TRUE, TRUE, new LLTextureMaskData( mID ));
-                        baked->setLoadedCallback(onBakedTextureLoaded, SWITCH_TO_BAKED_DISCARD, FALSE, FALSE, new LLUUID( mID ) );
+                        mBakedTextureData[i].mTexLayerSet->createComposite();
+                        mBakedTextureData[i].mTexLayerSet->setUpdatesEnabled( TRUE );
+                        for (U32 k=0; k < mBakedTextureData[i].mMeshes.size(); k++)
+                        {
+                                mBakedTextureData[i].mMeshes[k]->setLayerSet( mBakedTextureData[i].mTexLayerSet );
+                        }
                 }
         }
-        else
-        if( mUpperBodyLayerSet && !other_culled )
-        {
-                mUpperBodyLayerSet->createComposite();
-                mUpperBodyLayerSet->setUpdatesEnabled( TRUE );
-                mUpperBodyMesh0.setLayerSet( mUpperBodyLayerSet );
-                mUpperBodyMesh1.setLayerSet( mUpperBodyLayerSet );
-                mUpperBodyMesh2.setLayerSet( mUpperBodyLayerSet );
-                mUpperBodyMesh3.setLayerSet( mUpperBodyLayerSet );
-                mUpperBodyMesh4.setLayerSet( mUpperBodyLayerSet );
-        }
-        else
-        {
-                mUpperBodyMesh0.setTexture( default_tex );
-                mUpperBodyMesh1.setTexture(     default_tex );
-                mUpperBodyMesh2.setTexture(     default_tex );
-                mUpperBodyMesh3.setTexture(     default_tex );
-                mUpperBodyMesh4.setTexture(     default_tex );
-        }
-
-        // Lower body
-        if( use_lkg_lower_baked )
-        {
-                LLViewerImage* baked = gImageList.getImageFromHost( mLastLowerBodyBakedID, target_host );
-                mLowerBodyMesh0.setTexture( baked );
-                mLowerBodyMesh1.setTexture( baked );
-                mLowerBodyMesh2.setTexture( baked );
-                mLowerBodyMesh3.setTexture( baked );
-                mLowerBodyMesh4.setTexture( baked );
-        }
-        else
-        if( !self_customize && lower_baked )
+        
+        // ! BACKWARDS COMPATIBILITY !
+        // Workaround for viewing avatars from old viewers that haven't baked hair textures.
+        // if (!isTextureDefined(mBakedTextureData[BAKED_HAIR].mTextureIndex))
+        if (!is_layer_baked[BAKED_HAIR])
         {
-                LLViewerImage* baked = getTEImage( TEX_LOWER_BAKED );
-                if( baked->getID() == mLastLowerBodyBakedID )
-                {
-                        // Even though the file may not be finished loading, we'll consider it loaded and use it (rather than doing compositing).
-                        useBakedTexture( baked->getID() );
-                }
-                else
+                const LLColor4 color = mTexHairColor ? mTexHairColor->getColor() : LLColor4(1,1,1,1);
+                LLViewerImage* hair_img = getTEImage( TEX_HAIR );
+                for (U32 i = 0; i < mBakedTextureData[BAKED_HAIR].mMeshes.size(); i++)
                 {
-                        mLowerBakedLoaded = FALSE;
-                        mLowerMaskDiscard = -1;
-                        baked->setLoadedCallback(onBakedTextureMasksLoaded, MORPH_MASK_REQUESTED_DISCARD, TRUE, TRUE, new LLTextureMaskData( mID ));
-                        baked->setLoadedCallback(onBakedTextureLoaded, SWITCH_TO_BAKED_DISCARD, FALSE, FALSE, new LLUUID( mID ) );
+                        mBakedTextureData[BAKED_HAIR].mMeshes[i]->setColor( color.mV[VX], color.mV[VY], color.mV[VZ], color.mV[VW] );
+                        mBakedTextureData[BAKED_HAIR].mMeshes[i]->setTexture( hair_img );
                 }
-        }
-        else
-        if( mLowerBodyLayerSet && !other_culled )
-        {
-                mLowerBodyLayerSet->createComposite();
-                mLowerBodyLayerSet->setUpdatesEnabled( TRUE );
-                mLowerBodyMesh0.setLayerSet( mLowerBodyLayerSet );
-                mLowerBodyMesh1.setLayerSet( mLowerBodyLayerSet );
-                mLowerBodyMesh2.setLayerSet( mLowerBodyLayerSet );
-                mLowerBodyMesh3.setLayerSet( mLowerBodyLayerSet );
-                mLowerBodyMesh4.setLayerSet( mLowerBodyLayerSet );
-        }
-        else
-        {
-                mLowerBodyMesh0.setTexture(     default_tex );
-                mLowerBodyMesh1.setTexture(     default_tex );
-                mLowerBodyMesh2.setTexture(     default_tex );
-                mLowerBodyMesh3.setTexture(     default_tex );
-                mLowerBodyMesh4.setTexture(     default_tex );
-        }
-
-        // Eyes
-        if( use_lkg_eyes_baked )
-        {
-                LLViewerImage* baked = gImageList.getImageFromHost( mLastEyesBakedID, target_host );
-                mEyeBallLeftMesh0.setTexture(  baked );
-                mEyeBallLeftMesh1.setTexture(  baked );
-                mEyeBallRightMesh0.setTexture( baked );
-                mEyeBallRightMesh1.setTexture( baked );
-        }
-        else
-        if( !self_customize && eyes_baked )
+                mHasBakedHair = FALSE;
+        } 
+        else 
         {
-                LLViewerImage* baked = getTEImage( TEX_EYES_BAKED );
-                if( baked->getID() == mLastEyesBakedID )
+                for (U32 i = 0; i < mBakedTextureData[BAKED_HAIR].mMeshes.size(); i++)
                 {
-                        // Even though the file may not be finished loading, we'll consider it loaded and use it (rather than doing compositing).
-                        useBakedTexture( baked->getID() );
+                        mBakedTextureData[BAKED_HAIR].mMeshes[i]->setColor( 1.f, 1.f, 1.f, 1.f );
                 }
-                else
-                {
-                        mEyesBakedLoaded = FALSE;
-                        baked->setLoadedCallback(onBakedTextureLoaded, SWITCH_TO_BAKED_DISCARD, FALSE, FALSE, new LLUUID( mID ) );
-                }
-        }
-        else
-        if( mEyesLayerSet && !other_culled )
-        {
-                mEyesLayerSet->createComposite();
-                mEyesLayerSet->setUpdatesEnabled( TRUE );
-                mEyeBallLeftMesh0.setLayerSet( mEyesLayerSet );
-                mEyeBallLeftMesh1.setLayerSet( mEyesLayerSet );
-                mEyeBallRightMesh0.setLayerSet( mEyesLayerSet );
-                mEyeBallRightMesh1.setLayerSet( mEyesLayerSet );
-        }
-        else
-        {
-                mEyeBallLeftMesh0.setTexture( default_tex );
-                mEyeBallLeftMesh1.setTexture( default_tex );
-                mEyeBallRightMesh0.setTexture( default_tex );
-                mEyeBallRightMesh1.setTexture( default_tex );
+                mHasBakedHair = TRUE;
         }
-
-        // Skirt
-        if( use_lkg_skirt_baked )
-        {
-                LLViewerImage* baked = gImageList.getImageFromHost( mLastSkirtBakedID, target_host );
-                mSkirtMesh0.setTexture(  baked );
-                mSkirtMesh1.setTexture(  baked );
-                mSkirtMesh2.setTexture(  baked );
-                mSkirtMesh3.setTexture(  baked );
-                mSkirtMesh4.setTexture(  baked );
-        }
-        else
-        if( !self_customize && skirt_baked )
-        {
-                LLViewerImage* baked = getTEImage( TEX_SKIRT_BAKED );
-                if( baked->getID() == mLastSkirtBakedID )
-                {
-                        // Even though the file may not be finished loading, we'll consider it loaded and use it (rather than doing compositing).
-                        useBakedTexture( baked->getID() );
-                }
-                else
+        
+        /* // Head
+           BOOL head_baked_ready = (is_layer_baked[BAKED_HEAD] && mBakedTextureData[BAKED_HEAD].mIsLoaded) || other_culled;
+           setLocalTexture( TEX_HEAD_BODYPAINT, getTEImage( TEX_HEAD_BODYPAINT ), head_baked_ready ); */
+        for (LLVOAvatarDictionary::baked_map_t::const_iterator baked_iter = LLVOAvatarDictionary::getInstance()->getBakedTextures().begin();
+                 baked_iter != LLVOAvatarDictionary::getInstance()->getBakedTextures().end();
+                 baked_iter++)
+        {
+                const EBakedTextureIndex baked_index = baked_iter->first;
+                const LLVOAvatarDictionary::BakedDictionaryEntry *baked_dict = baked_iter->second;
+                
+                for (texture_vec_t::const_iterator local_tex_iter = baked_dict->mLocalTextures.begin();
+                         local_tex_iter != baked_dict->mLocalTextures.end();
+                         local_tex_iter++)
                 {
-                        mSkirtBakedLoaded = FALSE;
-                        baked->setLoadedCallback(onBakedTextureLoaded, SWITCH_TO_BAKED_DISCARD, FALSE, FALSE, new LLUUID( mID ) );
+                        const ETextureIndex texture_index = *local_tex_iter;
+                        const BOOL is_baked_ready = (is_layer_baked[baked_index] && mBakedTextureData[baked_index].mIsLoaded) || other_culled;
+                        setLocalTexture(texture_index, getTEImage(texture_index), is_baked_ready );
                 }
         }
-        else
-        if( mSkirtLayerSet && !other_culled)
-        {
-                mSkirtLayerSet->createComposite();
-                mSkirtLayerSet->setUpdatesEnabled( TRUE );
-                mSkirtMesh0.setLayerSet( mSkirtLayerSet );
-                mSkirtMesh1.setLayerSet( mSkirtLayerSet );
-                mSkirtMesh2.setLayerSet( mSkirtLayerSet );
-                mSkirtMesh3.setLayerSet( mSkirtLayerSet );
-                mSkirtMesh4.setLayerSet( mSkirtLayerSet );
-        }
-        else
-        {
-                mSkirtMesh0.setTexture( default_tex );
-                mSkirtMesh1.setTexture( default_tex );
-                mSkirtMesh2.setTexture( default_tex );
-                mSkirtMesh3.setTexture( default_tex );
-                mSkirtMesh4.setTexture( default_tex );
-        }
-
-        mHairMesh0.setTexture(                                          getTEImage( TEX_HAIR ) );
-        mHairMesh1.setTexture(                                          getTEImage( TEX_HAIR ) );
-        mHairMesh2.setTexture(                                          getTEImage( TEX_HAIR ) );
-        mHairMesh3.setTexture(                                          getTEImage( TEX_HAIR ) );
-        mHairMesh4.setTexture(                                          getTEImage( TEX_HAIR ) );
-        mHairMesh5.setTexture(                                          getTEImage( TEX_HAIR ) );
-
-        if( mTexHairColor )
-        {
-                LLColor4 color = mTexHairColor->getColor();
-                mHairMesh0.setColor( color.mV[VX], color.mV[VY], color.mV[VZ], color.mV[VW] );
-                mHairMesh1.setColor( color.mV[VX], color.mV[VY], color.mV[VZ], color.mV[VW] );
-                mHairMesh2.setColor( color.mV[VX], color.mV[VY], color.mV[VZ], color.mV[VW] );
-                mHairMesh3.setColor( color.mV[VX], color.mV[VY], color.mV[VZ], color.mV[VW] );
-                mHairMesh4.setColor( color.mV[VX], color.mV[VY], color.mV[VZ], color.mV[VW] );
-                mHairMesh5.setColor( color.mV[VX], color.mV[VY], color.mV[VZ], color.mV[VW] );
-        }
-
-        // Head
-        BOOL head_baked_ready = (head_baked && mHeadBakedLoaded) || other_culled;
-        setLocalTexture( LOCTEX_HEAD_BODYPAINT,         getTEImage( TEX_HEAD_BODYPAINT ),       head_baked_ready );
-
-        // Upper body
-        BOOL upper_baked_ready = (upper_baked && mUpperBakedLoaded) || other_culled;
-        setLocalTexture( LOCTEX_UPPER_SHIRT,            getTEImage( TEX_UPPER_SHIRT ),          upper_baked_ready );
-        setLocalTexture( LOCTEX_UPPER_BODYPAINT,        getTEImage( TEX_UPPER_BODYPAINT ),      upper_baked_ready );
-        setLocalTexture( LOCTEX_UPPER_JACKET,           getTEImage( TEX_UPPER_JACKET ),         upper_baked_ready );
-        setLocalTexture( LOCTEX_UPPER_GLOVES,           getTEImage( TEX_UPPER_GLOVES ),         upper_baked_ready );
-        setLocalTexture( LOCTEX_UPPER_UNDERSHIRT,       getTEImage( TEX_UPPER_UNDERSHIRT ),     upper_baked_ready );
-
-        // Lower body
-        BOOL lower_baked_ready = (lower_baked && mLowerBakedLoaded) || other_culled;
-        setLocalTexture( LOCTEX_LOWER_PANTS,            getTEImage( TEX_LOWER_PANTS ),          lower_baked_ready );
-        setLocalTexture( LOCTEX_LOWER_BODYPAINT,        getTEImage( TEX_LOWER_BODYPAINT ),      lower_baked_ready );
-        setLocalTexture( LOCTEX_LOWER_SHOES,            getTEImage( TEX_LOWER_SHOES ),          lower_baked_ready );
-        setLocalTexture( LOCTEX_LOWER_SOCKS,            getTEImage( TEX_LOWER_SOCKS ),          lower_baked_ready );
-        setLocalTexture( LOCTEX_LOWER_JACKET,           getTEImage( TEX_LOWER_JACKET ),         lower_baked_ready );
-        setLocalTexture( LOCTEX_LOWER_UNDERPANTS,       getTEImage( TEX_LOWER_UNDERPANTS ),     lower_baked_ready );
-
-        // Eyes
-        BOOL eyes_baked_ready = (eyes_baked && mEyesBakedLoaded) || other_culled;
-        setLocalTexture( LOCTEX_EYES_IRIS,                      getTEImage( TEX_EYES_IRIS ),            eyes_baked_ready );
-
-        // Skirt
-        BOOL skirt_baked_ready = (skirt_baked && mSkirtBakedLoaded) || other_culled;
-        setLocalTexture( LOCTEX_SKIRT,                          getTEImage( TEX_SKIRT ),                        skirt_baked_ready );
-
         removeMissingBakedTextures();
 }
 
 //-----------------------------------------------------------------------------
 // setLocalTexture()
 //-----------------------------------------------------------------------------
-void LLVOAvatar::setLocalTexture( ELocTexIndex idx, LLViewerImage* tex, BOOL baked_version_ready )
+void LLVOAvatar::setLocalTexture( ETextureIndex index, LLViewerImage* tex, BOOL baked_version_ready )
 {
+        if (!isIndexLocalTexture(index)) return;
+
         S32 desired_discard = mIsSelf ? 0 : 2;
+        LocalTextureData &local_tex_data = mLocalTextureData[index];
         if (!baked_version_ready)
         {
-                if (tex != mLocalTexture[idx] || mLocalTextureBaked[idx])
+                if (tex != local_tex_data.mImage || local_tex_data.mIsBakedReady)
                 {
-                        mLocalTextureDiscard[idx] = MAX_DISCARD_LEVEL+1;
+                        local_tex_data.mDiscard = MAX_DISCARD_LEVEL+1;
                 }
                 if (tex->getID() != IMG_DEFAULT_AVATAR)
                 {
-                        if (mLocalTextureDiscard[idx] > desired_discard)
+                        if (local_tex_data.mDiscard > desired_discard)
                         {
                                 S32 tex_discard = tex->getDiscardLevel();
                                 if (tex_discard >= 0 && tex_discard <= desired_discard)
                                 {
-                                        mLocalTextureDiscard[idx] = tex_discard;
-                                        requestLayerSetUpdate( idx );
-                                        if( mIsSelf && gAgent.cameraCustomizeAvatar() )
+                                        local_tex_data.mDiscard = tex_discard;
+                                        if( mIsSelf && !gAgent.cameraCustomizeAvatar() )
+                                        {
+                                                requestLayerSetUpdate( index );
+                                        }
+                                        else if( mIsSelf && gAgent.cameraCustomizeAvatar() )
                                         {
                                                 LLVisualParamHint::requestHintUpdates();
                                         }
                                 }
                                 else
                                 {
-                                        tex->setLoadedCallback( onLocalTextureLoaded, desired_discard, TRUE, FALSE, new LLAvatarTexData(getID(), idx) );
+                                        tex->setLoadedCallback( onLocalTextureLoaded, desired_discard, TRUE, FALSE, new LLAvatarTexData(getID(), index) );
                                 }
                         }
                         tex->setMinDiscardLevel(desired_discard);
                 }
         }
-        mLocalTextureBaked[idx] = baked_version_ready;
-        mLocalTexture[idx] = tex;
+        local_tex_data.mIsBakedReady = baked_version_ready;
+        local_tex_data.mImage = tex;
 }
 
 //-----------------------------------------------------------------------------
@@ -7692,35 +7026,13 @@ void LLVOAvatar::setLocalTexture( ELocTexIndex idx, LLViewerImage* tex, BOOL bak
 //-----------------------------------------------------------------------------
 void LLVOAvatar::requestLayerSetUploads()
 {
-        BOOL upper_baked = (getTEImage( TEX_UPPER_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-        BOOL lower_baked = (getTEImage( TEX_LOWER_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-        BOOL head_baked = (getTEImage( TEX_HEAD_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-        BOOL eyes_baked = (getTEImage( TEX_EYES_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-        BOOL skirt_baked = (getTEImage( TEX_SKIRT_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-
-        if( !head_baked && mHeadLayerSet )
+        for (U32 i = 0; i < mBakedTextureData.size(); i++)
         {
-                mHeadLayerSet->requestUpload();
-        }
-
-        if( !upper_baked && mUpperBodyLayerSet )
-        {
-                mUpperBodyLayerSet->requestUpload();
-        }
-
-        if( !lower_baked && mLowerBodyLayerSet )
-        {
-                mLowerBodyLayerSet->requestUpload();
-        }
-
-        if( !eyes_baked && mEyesLayerSet )
-        {
-                mEyesLayerSet->requestUpload();
-        }
-
-        if( !skirt_baked && mSkirtLayerSet )
-        {
-                mSkirtLayerSet->requestUpload();
+                bool layer_baked = isTextureDefined(mBakedTextureData[i].mTextureIndex);
+                if ( !layer_baked && mBakedTextureData[i].mTexLayerSet )
+                {
+                        mBakedTextureData[i].mTexLayerSet->requestUpload();
+                }
         }
 }
 
@@ -7730,31 +7042,13 @@ void LLVOAvatar::requestLayerSetUploads()
 //-----------------------------------------------------------------------------
 void LLVOAvatar::setCompositeUpdatesEnabled( BOOL b )
 {
-        if( mHeadLayerSet )
-        {
-                mHeadLayerSet->setUpdatesEnabled( b );
-        }
-        
-        if( mUpperBodyLayerSet )
-        {
-                mUpperBodyLayerSet->setUpdatesEnabled( b );
-        }
-
-        if( mLowerBodyLayerSet )
+        for (U32 i = 0; i < mBakedTextureData.size(); i++)
         {
-                mLowerBodyLayerSet->setUpdatesEnabled( b );
-        }
-
-        if( mEyesLayerSet )
-        {
-                mEyesLayerSet->setUpdatesEnabled( b );
-        }
-
-        if( mSkirtLayerSet )
-        {
-                mSkirtLayerSet->setUpdatesEnabled( b );
+                if (mBakedTextureData[i].mTexLayerSet )
+                {
+                        mBakedTextureData[i].mTexLayerSet->setUpdatesEnabled( b );
+                }
         }
-
 }
 
 void LLVOAvatar::addChat(const LLChat& chat)
@@ -7786,14 +7080,16 @@ void LLVOAvatar::clearChat()
         mChats.clear();
 }
 
-S32 LLVOAvatar::getLocalDiscardLevel( S32 index )
+S32 LLVOAvatar::getLocalDiscardLevel( ETextureIndex index )
 {
+        if (!isIndexLocalTexture(index)) return FALSE;
+
+        LocalTextureData &local_tex_data = mLocalTextureData[index];
         if (index >= 0
-                && mLocalTexture[index].notNull()
-                && (mLocalTexture[index]->getID() != IMG_DEFAULT_AVATAR)
-                && !mLocalTexture[index]->isMissingAsset())
+                && getLocalTextureID(index) != IMG_DEFAULT_AVATAR
+                && !local_tex_data.mImage->isMissingAsset())
         {
-                return mLocalTexture[index]->getDiscardLevel();
+                return local_tex_data.mImage->getDiscardLevel();
         }
         else
         {
@@ -7804,39 +7100,27 @@ S32 LLVOAvatar::getLocalDiscardLevel( S32 index )
 
 //-----------------------------------------------------------------------------
 // isLocalTextureDataFinal()
-// Returns true is the highest quality discard level exists for every texture
+// Returns true if the highest quality discard level exists for every texture
 // in the layerset.
 //-----------------------------------------------------------------------------
 BOOL LLVOAvatar::isLocalTextureDataFinal( LLTexLayerSet* layerset )
 {
-        if( layerset == mHeadLayerSet )
+        for (U32 i = 0; i < mBakedTextureData.size(); i++)
         {
-                return getLocalDiscardLevel( LOCTEX_HEAD_BODYPAINT ) == 0;
-        }
-        else if( layerset == mUpperBodyLayerSet )
-        {
-                return getLocalDiscardLevel( LOCTEX_UPPER_SHIRT ) == 0 &&
-                        getLocalDiscardLevel( LOCTEX_UPPER_BODYPAINT ) == 0 &&
-                        getLocalDiscardLevel( LOCTEX_UPPER_JACKET ) == 0 && 
-                        getLocalDiscardLevel( LOCTEX_UPPER_GLOVES ) == 0 && 
-                        getLocalDiscardLevel( LOCTEX_UPPER_UNDERSHIRT ) == 0;
-        }
-        else if( layerset == mLowerBodyLayerSet )
-        {
-                return getLocalDiscardLevel( LOCTEX_LOWER_PANTS ) == 0 &&
-                        getLocalDiscardLevel( LOCTEX_LOWER_BODYPAINT ) == 0 && 
-                        getLocalDiscardLevel( LOCTEX_LOWER_SHOES ) == 0 && 
-                        getLocalDiscardLevel( LOCTEX_LOWER_SOCKS ) == 0 && 
-                        getLocalDiscardLevel( LOCTEX_LOWER_JACKET ) == 0 && 
-                        getLocalDiscardLevel( LOCTEX_LOWER_UNDERPANTS ) == 0;
-        }
-        else if( layerset == mEyesLayerSet )
-        {
-                return getLocalDiscardLevel( LOCTEX_EYES_IRIS ) == 0;
-        }
-        else if( layerset == mSkirtLayerSet )
-        {
-                return getLocalDiscardLevel( LOCTEX_SKIRT ) == 0;
+                if (layerset == mBakedTextureData[i].mTexLayerSet)
+                {
+                        const LLVOAvatarDictionary::BakedDictionaryEntry *baked_dict = LLVOAvatarDictionary::getInstance()->getBakedTexture((EBakedTextureIndex)i);
+                        for (texture_vec_t::const_iterator local_tex_iter = baked_dict->mLocalTextures.begin();
+                                 local_tex_iter != baked_dict->mLocalTextures.end();
+                                 local_tex_iter++)
+                        {
+                                if (getLocalDiscardLevel(*local_tex_iter) != 0)
+                                {
+                                        return FALSE;
+                                }
+                        }
+                        return TRUE;
+                }
         }
 
         llassert(0);
@@ -7845,41 +7129,31 @@ BOOL LLVOAvatar::isLocalTextureDataFinal( LLTexLayerSet* layerset )
 
 //-----------------------------------------------------------------------------
 // isLocalTextureDataAvailable()
-// Returns true is at least the lowest quality discard level exists for every texture
+// Returns true if at least the lowest quality discard level exists for every texture
 // in the layerset.
 //-----------------------------------------------------------------------------
 BOOL LLVOAvatar::isLocalTextureDataAvailable( LLTexLayerSet* layerset )
 {
-        if( layerset == mHeadLayerSet )
+        /* if( layerset == mBakedTextureData[BAKED_HEAD].mTexLayerSet )
+           return getLocalDiscardLevel( TEX_HEAD_BODYPAINT ) >= 0; */
+        for (LLVOAvatarDictionary::baked_map_t::const_iterator baked_iter = LLVOAvatarDictionary::getInstance()->getBakedTextures().begin();
+                 baked_iter != LLVOAvatarDictionary::getInstance()->getBakedTextures().end();
+                 baked_iter++)
         {
-                return getLocalDiscardLevel( LOCTEX_HEAD_BODYPAINT ) >= 0;
-        }
-        else if( layerset == mUpperBodyLayerSet )
-        {
-                return getLocalDiscardLevel( LOCTEX_UPPER_SHIRT ) >= 0 &&
-                        getLocalDiscardLevel( LOCTEX_UPPER_BODYPAINT ) >= 0 &&
-                        getLocalDiscardLevel( LOCTEX_UPPER_JACKET ) >= 0 && 
-                        getLocalDiscardLevel( LOCTEX_UPPER_GLOVES ) >= 0 && 
-                        getLocalDiscardLevel( LOCTEX_UPPER_UNDERSHIRT ) >= 0;
-        }
-        else if( layerset == mLowerBodyLayerSet )
-        {
-                return getLocalDiscardLevel( LOCTEX_LOWER_PANTS ) >= 0 &&
-                        getLocalDiscardLevel( LOCTEX_LOWER_BODYPAINT ) >= 0 && 
-                        getLocalDiscardLevel( LOCTEX_LOWER_SHOES ) >= 0 && 
-                        getLocalDiscardLevel( LOCTEX_LOWER_SOCKS ) >= 0 && 
-                        getLocalDiscardLevel( LOCTEX_LOWER_JACKET ) >= 0 && 
-                        getLocalDiscardLevel( LOCTEX_LOWER_UNDERPANTS ) >= 0;
-        }
-        else if( layerset == mEyesLayerSet )
-        {
-                return getLocalDiscardLevel( LOCTEX_EYES_IRIS ) >= 0;
-        }
-        else if( layerset == mSkirtLayerSet )
-        {
-                return getLocalDiscardLevel( LOCTEX_SKIRT ) >= 0;
+                const EBakedTextureIndex baked_index = baked_iter->first;
+                if (layerset == mBakedTextureData[baked_index].mTexLayerSet)
+                {
+                        bool ret = true;
+                        const LLVOAvatarDictionary::BakedDictionaryEntry *baked_dict = baked_iter->second;
+                        for (texture_vec_t::const_iterator local_tex_iter = baked_dict->mLocalTextures.begin();
+                                 local_tex_iter != baked_dict->mLocalTextures.end();
+                                 local_tex_iter++)
+                        {
+                                ret &= (getLocalDiscardLevel(*local_tex_iter) >= 0);
+                        }
+                        return ret;
+                }
         }
-
         llassert(0);
         return FALSE;
 }
@@ -7889,31 +7163,14 @@ BOOL LLVOAvatar::isLocalTextureDataAvailable( LLTexLayerSet* layerset )
 // getBakedTE()
 // Used by the LayerSet.  (Layer sets don't in general know what textures depend on them.)
 //-----------------------------------------------------------------------------
-LLVOAvatar::ETextureIndex LLVOAvatar::getBakedTE( LLTexLayerSet* layerset )
+ETextureIndex LLVOAvatar::getBakedTE( LLTexLayerSet* layerset )
 {
-        if( layerset == mHeadLayerSet )
+        for (U32 i = 0; i < mBakedTextureData.size(); i++)
         {
-                return TEX_HEAD_BAKED;
-        }
-        else
-        if( layerset == mUpperBodyLayerSet )
-        {
-                return TEX_UPPER_BAKED;
-        }
-        else
-        if( layerset == mLowerBodyLayerSet )
-        {
-                return TEX_LOWER_BAKED;
-        }
-        else
-        if( layerset == mEyesLayerSet )
-        {
-                return TEX_EYES_BAKED;
-        }
-        else
-        if( layerset == mSkirtLayerSet )
-        {
-                return TEX_SKIRT_BAKED;
+                if (layerset == mBakedTextureData[i].mTexLayerSet )
+                {
+                        return mBakedTextureData[i].mTextureIndex;
+                }
         }
 
         llassert(0);
@@ -7932,28 +7189,21 @@ void LLVOAvatar::setNewBakedTexture( ETextureIndex te, const LLUUID& uuid )
         updateMeshTextures();
         dirtyMesh();
 
+
         LLVOAvatar::cullAvatarsByPixelArea();
 
-        switch( te )
+        /* switch(te)
+                case TEX_HEAD_BAKED:
+                        llinfos << "New baked texture: HEAD" << llendl; */
+        const LLVOAvatarDictionary::TextureDictionaryEntry *text_dict = LLVOAvatarDictionary::getInstance()->getTexture(te);
+        if (text_dict->mIsBakedTexture)
+        {
+                llinfos << "New baked texture: " << text_dict->mName << " UUID: " << uuid <<llendl;
+                mBakedTextureData[text_dict->mBakedTextureIndex].mTexLayerSet->requestUpdate();
+        }
+        else
         {
-        case TEX_HEAD_BAKED:
-                llinfos << "New baked texture: HEAD" << llendl;
-                break;
-        case TEX_UPPER_BAKED:
-                llinfos << "New baked texture: UPPER" << llendl;
-                break;
-        case TEX_LOWER_BAKED:
-                llinfos << "New baked texture: LOWER" << llendl;
-                break;
-        case TEX_EYES_BAKED:
-                llinfos << "New baked texture: EYES" << llendl;
-                break;
-        case TEX_SKIRT_BAKED:
-                llinfos << "New baked texture: SKIRT" << llendl;
-                break;
-        default:
                 llwarns << "New baked texture: unknown te " << te << llendl;
-                break;
         }
         
         //      dumpAvatarTEs( "setNewBakedTexture() send" );
@@ -7966,28 +7216,15 @@ void LLVOAvatar::setNewBakedTexture( ETextureIndex te, const LLUUID& uuid )
 
 bool LLVOAvatar::hasPendingBakedUploads()
 {
-        bool head_pending = (mHeadLayerSet && mHeadLayerSet->getComposite()->uploadPending());
-        bool upper_pending = (mUpperBodyLayerSet && mUpperBodyLayerSet->getComposite()->uploadPending());
-        bool lower_pending = (mLowerBodyLayerSet && mLowerBodyLayerSet->getComposite()->uploadPending());
-        bool eyes_pending = (mEyesLayerSet && mEyesLayerSet->getComposite()->uploadPending());
-        bool skirt_pending = (mSkirtLayerSet && mSkirtLayerSet->getComposite()->uploadPending());
-
-        //llinfos << "TAT: LLVOAvatar::hasPendingBakedUploads()"
-        //      << " head_pending " << head_pending
-        //      << " upper_pending " << upper_pending
-        //      << " lower_pending " << lower_pending
-        //      << " eyes_pending " << eyes_pending
-        //      << " skirt_pending " << skirt_pending
-        //      << llendl;
-
-        if (head_pending || upper_pending || lower_pending || eyes_pending || skirt_pending)
+        for (U32 i = 0; i < mBakedTextureData.size(); i++)
         {
-                return true;
-        }
-        else
-        {
-                return false;
+                bool upload_pending = (mBakedTextureData[i].mTexLayerSet && mBakedTextureData[i].mTexLayerSet->getComposite()->uploadPending());
+                if (upload_pending)
+                {
+                        return true;
+                }
         }
+        return false;
 }
 
 //-----------------------------------------------------------------------------
@@ -7998,56 +7235,50 @@ void LLVOAvatar::setCachedBakedTexture( ETextureIndex te, const LLUUID& uuid )
 {
         setTETexture( te, uuid );
 
-        switch(te)
+        /* switch(te)
+                case TEX_HEAD_BAKED:
+                        if( mHeadLayerSet )
+                                mHeadLayerSet->cancelUpload(); */
+        for (U32 i = 0; i < mBakedTextureData.size(); i++)
         {
-        case TEX_HEAD_BAKED:
-                if( mHeadLayerSet )
-                {
-                        mHeadLayerSet->cancelUpload();
-                }               
-                break;
-        case TEX_UPPER_BAKED:
-                if( mUpperBodyLayerSet )
+                if ( mBakedTextureData[i].mTextureIndex == te && mBakedTextureData[i].mTexLayerSet)
                 {
-                        mUpperBodyLayerSet->cancelUpload();
+                        mBakedTextureData[i].mTexLayerSet->cancelUpload();
                 }
-                break;
-        case TEX_LOWER_BAKED:
-                if( mLowerBodyLayerSet )
+        }
+}
+
+//-----------------------------------------------------------------------------
+// releaseUnneccesaryTextures()
+// release any component texture UUIDs for which we have a baked texture
+//-----------------------------------------------------------------------------
+void LLVOAvatar::releaseUnnecessaryTextures()
+{
+        // Backwards Compat: detect if the baked hair texture actually wasn't sent, and if so set to default
+        if (isTextureDefined(TEX_HAIR_BAKED) && getTEImage(TEX_HAIR_BAKED)->getID() == getTEImage(TEX_SKIRT_BAKED)->getID())
+        {
+                if (getTEImage(TEX_HAIR_BAKED)->getID() != IMG_INVISIBLE)
                 {
-                        mLowerBodyLayerSet->cancelUpload();
+                        // Regression case of messaging system. Expected 21 textures, received 20. last texture is not valid so set to default
+                        setTETexture(TEX_HAIR_BAKED, IMG_DEFAULT_AVATAR);
                 }
-                break;
-        case TEX_EYES_BAKED:
-                if( mEyesLayerSet )
+        }
+
+        for (U8 baked_index = 0; baked_index < BAKED_NUM_INDICES; baked_index++)
+        {
+                const LLVOAvatarDictionary::BakedDictionaryEntry * bakedDicEntry = LLVOAvatarDictionary::getInstance()->getBakedTexture((EBakedTextureIndex)baked_index);
+                // skip if this is a skirt and av is not wearing one, or if we don't have a baked texture UUID
+                if (!isTextureDefined(bakedDicEntry->mTextureIndex)
+                        && ( (baked_index != BAKED_SKIRT) || isWearingWearableType(WT_SKIRT) ))
                 {
-                        mEyesLayerSet->cancelUpload();
+                        continue;
                 }
-                break;
-        case TEX_SKIRT_BAKED:
-                if( mSkirtLayerSet )
+
+                for (U8 texture = 0; texture < bakedDicEntry->mLocalTextures.size(); texture++)
                 {
-                        mSkirtLayerSet->cancelUpload();
+                        const U8 te = (ETextureIndex)bakedDicEntry->mLocalTextures[texture];
+                        setTETexture(te, IMG_DEFAULT_AVATAR);
                 }
-                break;
-
-                case TEX_HEAD_BODYPAINT:
-                case TEX_UPPER_SHIRT:
-                case TEX_LOWER_PANTS:
-                case TEX_EYES_IRIS:
-                case TEX_HAIR:
-                case TEX_UPPER_BODYPAINT:
-                case TEX_LOWER_BODYPAINT:
-                case TEX_LOWER_SHOES:
-                case TEX_LOWER_SOCKS:
-                case TEX_UPPER_JACKET:
-                case TEX_LOWER_JACKET:
-                case TEX_UPPER_GLOVES:
-                case TEX_UPPER_UNDERSHIRT:
-                case TEX_LOWER_UNDERPANTS:
-                case TEX_SKIRT:
-                case TEX_NUM_ENTRIES:
-                        break;
         }
 }
 
@@ -8057,21 +7288,9 @@ void LLVOAvatar::setCachedBakedTexture( ETextureIndex te, const LLUUID& uuid )
 //-----------------------------------------------------------------------------
 void LLVOAvatar::onCustomizeStart()
 {
-        LLVOAvatar* avatar = gAgent.getAvatarObject();
-        if( avatar )
-        {
-                for( S32 i = 0; i < BAKED_TEXTURE_COUNT; i++ )
-                {
-                        S32 tex_index = sBakedTextureIndices[i];
-                        avatar->mSavedTE[ tex_index ] = avatar->getTEImage(tex_index)->getID();
-                        avatar->setTEImage( tex_index, gImageList.getImage(IMG_DEFAULT_AVATAR) );
-                }
-
-                avatar->updateMeshTextures();
-
-//              avatar->dumpAvatarTEs( "onCustomizeStart() send" );
-                gAgent.sendAgentSetAppearance();
-        }
+        // We're no longer doing any baking or invalidating on entering 
+        // appearance editing mode. Leaving function in place in case 
+        // further changes require us to do something at this point - Nyx
 }
 
 //-----------------------------------------------------------------------------
@@ -8080,29 +7299,31 @@ void LLVOAvatar::onCustomizeStart()
 //-----------------------------------------------------------------------------
 void LLVOAvatar::onCustomizeEnd()
 {
-        LLVOAvatar* avatar = gAgent.getAvatarObject();
-        if( !avatar ) return;
+        LLVOAvatar *avatarp = gAgent.getAvatarObject();
+        if (avatarp)
+        {
+                avatarp->invalidateAll();
+                avatarp->requestLayerSetUploads();
+        }
+}
 
-        LLHost target_host = avatar->getObjectHost();
-                for( S32 i = 0; i < BAKED_TEXTURE_COUNT; i++ )
+void LLVOAvatar::onChangeSelfInvisible(BOOL newvalue)
+{
+        LLVOAvatar *avatarp = gAgent.getAvatarObject();
+        if (avatarp)
+        {
+                if (newvalue)
                 {
-                        S32 tex_index = sBakedTextureIndices[i];
-                        const LLUUID& saved = avatar->mSavedTE[ tex_index ];
-                        if( !saved.isNull() )
-                        {
-                        avatar->setTEImage( tex_index, gImageList.getImageFromHost( saved, target_host ) );
-                        }
+                        // we have just requested to set the avatar's baked textures to invisible
+                        avatarp->setInvisible(TRUE);
                 }
-
-                avatar->updateMeshTextures();
-
-                if( !LLApp::isExiting())
+                else
                 {
-                        avatar->requestLayerSetUploads();
+                        avatarp->setInvisible(FALSE);
                 }
-
-                gAgent.sendAgentSetAppearance();
         }
+}
+
 
 BOOL LLVOAvatar::teToColorParams( ETextureIndex te, const char* param_name[3] )
 {
@@ -8182,7 +7403,7 @@ void LLVOAvatar::setClothesColor( ETextureIndex te, const LLColor4& new_color, B
         }
 }
 
-LLColor4  LLVOAvatar::getClothesColor( ETextureIndex te )
+LLColor4 LLVOAvatar::getClothesColor( ETextureIndex te )
 {
         LLColor4 color;
         const char* param_name[3];
@@ -8199,56 +7420,36 @@ LLColor4  LLVOAvatar::getClothesColor( ETextureIndex te )
 
 
 void LLVOAvatar::dumpAvatarTEs( const std::string& context )
-{
+{       
+        /* const char* te_name[] = {
+                        "TEX_HEAD_BODYPAINT   ",
+                        "TEX_UPPER_SHIRT      ", */
         llinfos << (mIsSelf ? "Self: " : "Other: ") << context << llendl;
-        for( S32 i=0; i<TEX_NUM_ENTRIES; i++ )
+        for (LLVOAvatarDictionary::texture_map_t::const_iterator iter = LLVOAvatarDictionary::getInstance()->getTextures().begin();
+                 iter != LLVOAvatarDictionary::getInstance()->getTextures().end();
+                 iter++)
         {
-                const char* te_name[] = {
-                        "TEX_HEAD_BODYPAINT   ",
-                        "TEX_UPPER_SHIRT      ",
-                        "TEX_LOWER_PANTS      ",
-                        "TEX_EYES_IRIS        ",
-                        "TEX_HAIR             ",
-                        "TEX_UPPER_BODYPAINT  ",
-                        "TEX_LOWER_BODYPAINT  ",
-                        "TEX_LOWER_SHOES      ",
-                        "TEX_HEAD_BAKED       ",
-                        "TEX_UPPER_BAKED      ",
-                        "TEX_LOWER_BAKED      ",
-                        "TEX_EYES_BAKED       ",
-                        "TEX_LOWER_SOCKS      ",
-                        "TEX_UPPER_JACKET     ",
-                        "TEX_LOWER_JACKET     ",
-                        "TEX_UPPER_GLOVES     ",
-                        "TEX_UPPER_UNDERSHIRT ",
-                        "TEX_LOWER_UNDERPANTS ",
-                        "TEX_SKIRT            ",
-                        "TEX_SKIRT_BAKED      "
-                };
-
-                LLViewerImage* te_image = getTEImage(i);
+                const LLVOAvatarDictionary::TextureDictionaryEntry *text_dict = iter->second;
+                const LLViewerImage* te_image = getTEImage(iter->first);
                 if( !te_image )
                 {
-                        llinfos << "       " << te_name[i] << ": null ptr" << llendl;
+                        llinfos << "       " << text_dict->mName << ": null ptr" << llendl;
                 }
-                else
-                if( te_image->getID().isNull() )
+                else if( te_image->getID().isNull() )
                 {
-                        llinfos << "       " << te_name[i] << ": null UUID" << llendl;
+                        llinfos << "       " << text_dict->mName << ": null UUID" << llendl;
                 }
-                else
-                if( te_image->getID() == IMG_DEFAULT )
+                else if( te_image->getID() == IMG_DEFAULT )
                 {
-                        llinfos << "       " << te_name[i] << ": IMG_DEFAULT" << llendl;
+                        llinfos << "       " << text_dict->mName << ": IMG_DEFAULT" << llendl;
                 }
-                else
-                if( te_image->getID() == IMG_DEFAULT_AVATAR )
+                else if( te_image->getID() == IMG_DEFAULT_AVATAR )
                 {
-                        llinfos << "       " << te_name[i] << ": IMG_DEFAULT_AVATAR" << llendl;
+                        llinfos << "       " << text_dict->mName << ": IMG_DEFAULT_AVATAR" << llendl;
                 }
                 else
                 {
-                        llinfos << "       " << te_name[i] << ": " << te_image->getID() << llendl;
+                        llinfos << "       " << text_dict->mName << ": " << te_image->getID() << llendl;
                 }
         }
 }
@@ -8291,80 +7492,56 @@ void LLVOAvatar::updateAttachmentVisibility(U32 camera_mode)
 
 // Given a texture entry, determine which wearable type owns it.
 // static
-LLUUID LLVOAvatar::getDefaultTEImageID( S32 te )
+LLUUID LLVOAvatar::getDefaultTEImageID(ETextureIndex index )
 {
-        switch( te )
+        /* switch( index )
+                case TEX_UPPER_SHIRT:           return LLUUID( gSavedSettings.getString("UIImgDefaultShirtUUID") ); */
+        const LLVOAvatarDictionary::TextureDictionaryEntry *text_dict = LLVOAvatarDictionary::getInstance()->getTexture(index);
+        const std::string &default_image_name = text_dict->mDefaultImageName;
+        if (default_image_name == "")
         {
-        case TEX_UPPER_SHIRT:           return LLUUID( gSavedSettings.getString("UIImgDefaultShirtUUID") );
-        case TEX_LOWER_PANTS:           return LLUUID( gSavedSettings.getString("UIImgDefaultPantsUUID") );
-        case TEX_EYES_IRIS:                     return LLUUID( gSavedSettings.getString("UIImgDefaultEyesUUID") );
-        case TEX_HAIR:                          return LLUUID( gSavedSettings.getString("UIImgDefaultHairUUID") );
-        case TEX_LOWER_SHOES:           return LLUUID( gSavedSettings.getString("UIImgDefaultShoesUUID") );
-        case TEX_LOWER_SOCKS:           return LLUUID( gSavedSettings.getString("UIImgDefaultSocksUUID") );
-        case TEX_UPPER_GLOVES:          return LLUUID( gSavedSettings.getString("UIImgDefaultGlovesUUID") );
-        
-        case TEX_UPPER_JACKET:
-        case TEX_LOWER_JACKET:          return LLUUID( gSavedSettings.getString("UIImgDefaultJacketUUID") );
-
-        case TEX_UPPER_UNDERSHIRT:
-        case TEX_LOWER_UNDERPANTS:      return LLUUID( gSavedSettings.getString("UIImgDefaultUnderwearUUID") );
+                return IMG_DEFAULT_AVATAR;
+        }
+        else
+        {
+                return LLUUID(gSavedSettings.getString(default_image_name));
+        }
+}
 
-        case TEX_SKIRT:                         return LLUUID( gSavedSettings.getString("UIImgDefaultSkirtUUID") );
 
-        default:                                        return IMG_DEFAULT_AVATAR;
+void LLVOAvatar::setInvisible(BOOL newvalue)
+{
+        if (newvalue)
+        {
+                setCompositeUpdatesEnabled(FALSE);
+                for (U32 i = 0; i < mBakedTextureData.size(); i++ )
+                {
+                        setNewBakedTexture(mBakedTextureData[i].mTextureIndex, IMG_INVISIBLE);
+                }
+                gAgent.sendAgentSetAppearance();
+        }
+        else
+        {
+                setCompositeUpdatesEnabled(TRUE);
+                invalidateAll();
+                requestLayerSetUploads();
+                gAgent.sendAgentSetAppearance();
         }
 }
 
-
+LLColor4 LLVOAvatar::getDummyColor()
+{
+        return DUMMY_COLOR;
+}
 
 // Given a texture entry, determine which wearable type owns it.
 // static
-EWearableType LLVOAvatar::getTEWearableType( S32 te )
+EWearableType LLVOAvatar::getTEWearableType(ETextureIndex index )
 {
-        switch( te )
-        {
-        case TEX_UPPER_SHIRT:
-                return WT_SHIRT;
-
-        case TEX_LOWER_PANTS:
-                return WT_PANTS;
-
-        case TEX_EYES_IRIS:
-                return WT_EYES;
-
-        case TEX_HAIR:
-                return WT_HAIR;
-        
-        case TEX_HEAD_BODYPAINT:
-        case TEX_UPPER_BODYPAINT:
-        case TEX_LOWER_BODYPAINT:
-                return WT_SKIN;
-
-        case TEX_LOWER_SHOES:
-                return WT_SHOES;
-
-        case TEX_LOWER_SOCKS:
-                return WT_SOCKS;
-
-        case TEX_UPPER_JACKET:
-        case TEX_LOWER_JACKET:
-                return WT_JACKET;
-
-        case TEX_UPPER_GLOVES:
-                return WT_GLOVES;
-
-        case TEX_UPPER_UNDERSHIRT:
-                return WT_UNDERSHIRT;
-
-        case TEX_LOWER_UNDERPANTS:
-                return WT_UNDERPANTS;
-
-        case TEX_SKIRT:
-                return WT_SKIRT;
-
-        default:
-                return WT_INVALID;
-        }
+        /* switch(index)
+                case TEX_UPPER_SHIRT:
+                        return WT_SHIRT; */
+        return LLVOAvatarDictionary::getInstance()->getTexture(index)->mWearableType;
 }
 
 // Unlike most wearable functions, this works for both self and other.
@@ -8372,57 +7549,102 @@ BOOL LLVOAvatar::isWearingWearableType( EWearableType type )
 {
         if (mIsDummy) return TRUE;
 
-        ETextureIndex indicator_te;
         switch( type )
         {
-                case WT_SHIRT:
-                        indicator_te = TEX_UPPER_SHIRT;
-                        break;
-
-                case WT_PANTS: 
-                        indicator_te = TEX_LOWER_PANTS;
-                        break;
-
-                case WT_SHOES:
-                        indicator_te = TEX_LOWER_SHOES;
-                        break;
-
-                case WT_SOCKS:
-                        indicator_te = TEX_LOWER_SOCKS;
-                        break;
-
-                case WT_JACKET:
-                        indicator_te = TEX_UPPER_JACKET;
-                        // Note: no need to test both upper and lower jacket
-                        break;
-
-                case WT_GLOVES:
-                        indicator_te = TEX_UPPER_GLOVES;
-                        break;
-
-                case WT_UNDERSHIRT:
-                        indicator_te = TEX_UPPER_UNDERSHIRT;
-                        break;
-
-                case WT_UNDERPANTS:
-                        indicator_te = TEX_LOWER_UNDERPANTS;
-                        break;
-
-                case WT_SKIRT:
-                        indicator_te = TEX_SKIRT;
-                        break;
-                
                 case WT_SHAPE:
                 case WT_SKIN:
                 case WT_HAIR:
                 case WT_EYES:
                         return TRUE;  // everyone has all bodyparts
-
                 default:
+                        break; // Do nothing
+        }
+
+        /* switch(type)
+                case WT_SHIRT:
+                        indicator_te = TEX_UPPER_SHIRT; */
+        for (LLVOAvatarDictionary::texture_map_t::const_iterator tex_iter = LLVOAvatarDictionary::getInstance()->getTextures().begin();
+                 tex_iter != LLVOAvatarDictionary::getInstance()->getTextures().end();
+                 tex_iter++)
+        {
+                const LLVOAvatarDefines::ETextureIndex index = tex_iter->first;
+                const LLVOAvatarDictionary::TextureDictionaryEntry *text_dict = tex_iter->second;
+                if (text_dict->mWearableType == type)
+                {
+                        // If you're checking your own clothing, check the component texture
+                        if (mIsSelf)
+                        {
+                                if (isTextureDefined(index))
+                                {
+                                        return TRUE;
+                                }
+                                else
+                                {
+                                        return FALSE;
+                                }
+                        }
+
+                        // If you're checking another avatar's clothing, you don't have component textures.
+                        // Thus, you must check to see if the corresponding baked texture is defined.
+                        // NOTE: this is a poor substitute if you actually want to know about individual pieces of clothing
+                        // this works for detecting a skirt (most important), but is ineffective at any piece of clothing that
+                        // gets baked into a texture that always exists (upper or lower).
+                        const std::string name = text_dict->mName;
+                        for (LLVOAvatarDictionary::baked_map_t::const_iterator iter = LLVOAvatarDictionary::getInstance()->getBakedTextures().begin();
+                                iter != LLVOAvatarDictionary::getInstance()->getBakedTextures().end();
+                                iter++)
+                        {
+                                const LLVOAvatarDictionary::BakedDictionaryEntry *baked_dict = iter->second;
+                                if (baked_dict->mName == name)
+                                {
+                                        if (isTextureDefined(baked_dict->mTextureIndex))
+                                        {
+                                                return TRUE;
+                                        }
+                                        else
+                                        {
+                                                return FALSE;
+                                        }
+                                }
+                        }
                         return FALSE;
+                }
         }
+        return FALSE;
+}
 
-        return ( getTEImage(indicator_te)->getID() != IMG_DEFAULT_AVATAR );
+//-----------------------------------------------------------------------------
+// updatedWearable( EWearableType type )
+// forces an update to any baked textures relevant to type.
+// Should be called only on saving the wearable
+//-----------------------------------------------------------------------------
+void LLVOAvatar::wearableUpdated( EWearableType type )
+{
+        for (LLVOAvatarDictionary::wearable_map_t::const_iterator wearable_iter = LLVOAvatarDictionary::getInstance()->getWearables().begin();
+                wearable_iter != LLVOAvatarDictionary::getInstance()->getWearables().end();
+                wearable_iter++)
+        {
+                const LLVOAvatarDictionary::WearableDictionaryEntry *wearable_dict = wearable_iter->second;
+                const LLVOAvatarDefines::EBakedTextureIndex index = wearable_iter->first;
+                if (wearable_dict)
+                {
+                        for (LLVOAvatarDefines::wearables_vec_t::const_iterator type_iter = wearable_dict->mWearablesVec.begin();
+                                type_iter != wearable_dict->mWearablesVec.end();
+                                type_iter++)
+                        {
+                                const EWearableType comp_type = *type_iter;
+                                if (comp_type == type)
+                                {
+                                        if (mBakedTextureData[index].mTexLayerSet)
+                                        {
+                                                mBakedTextureData[index].mTexLayerSet->requestUpdate();
+                                                mBakedTextureData[index].mTexLayerSet->requestUpload();
+                                        }
+                                        break;  
+                                }
+                        }
+                }
+        }
 }
 
 
@@ -8447,12 +7669,12 @@ void LLVOAvatar::clampAttachmentPositions()
         }
 }
 
-BOOL LLVOAvatar::hasHUDAttachment()
+BOOL LLVOAvatar::hasHUDAttachment() const
 {
-        for (attachment_map_t::iterator iter = mAttachmentPoints.begin(); 
+        for (attachment_map_t::const_iterator iter = mAttachmentPoints.begin(); 
                  iter != mAttachmentPoints.end(); )
         {
-                attachment_map_t::iterator curiter = iter++;
+                attachment_map_t::const_iterator curiter = iter++;
                 LLViewerJointAttachment* attachment = curiter->second;
                 if (attachment->getIsHUDAttachment() && attachment->getObject())
                 {
@@ -8462,13 +7684,13 @@ BOOL LLVOAvatar::hasHUDAttachment()
         return FALSE;
 }
 
-LLBBox LLVOAvatar::getHUDBBox()
+LLBBox LLVOAvatar::getHUDBBox() const
 {
         LLBBox bbox;
-        for (attachment_map_t::iterator iter = mAttachmentPoints.begin(); 
+        for (attachment_map_t::const_iterator iter = mAttachmentPoints.begin(); 
                  iter != mAttachmentPoints.end(); )
         {
-                attachment_map_t::iterator curiter = iter++;
+                attachment_map_t::const_iterator curiter = iter++;
                 LLViewerJointAttachment* attachment = curiter->second;
                 if (attachment->getIsHUDAttachment() && attachment->getObject())
                 {
@@ -8504,50 +7726,23 @@ void LLVOAvatar::onFirstTEMessageReceived()
         {
                 mFirstTEMessageReceived = TRUE;
 
-                BOOL head_baked = ( getTEImage( TEX_HEAD_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-                BOOL upper_baked = ( getTEImage( TEX_UPPER_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-                BOOL lower_baked = ( getTEImage( TEX_LOWER_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-                BOOL eyes_baked = ( getTEImage( TEX_EYES_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-                BOOL skirt_baked = ( getTEImage( TEX_SKIRT_BAKED )->getID() != IMG_DEFAULT_AVATAR );
-
-                // Use any baked textures that we have even if they haven't downloaded yet.
-                // (That is, don't do a transition from unbaked to baked.)
-                if( head_baked )
-                {
-                        mLastHeadBakedID = getTEImage( TEX_HEAD_BAKED )->getID();
-                        LLViewerImage* image = getTEImage( TEX_HEAD_BAKED );
-                        image->setLoadedCallback( onBakedTextureMasksLoaded, MORPH_MASK_REQUESTED_DISCARD, TRUE, TRUE, new LLTextureMaskData( mID ));   
-                        image->setLoadedCallback( onInitialBakedTextureLoaded, MAX_DISCARD_LEVEL, FALSE, FALSE, new LLUUID( mID ) );
-                }
-
-                if( upper_baked )
+                for (U32 i = 0; i < mBakedTextureData.size(); i++)
                 {
-                        mLastUpperBodyBakedID = getTEImage( TEX_UPPER_BAKED )->getID();
-                        LLViewerImage* image = getTEImage( TEX_UPPER_BAKED );
-                        image->setLoadedCallback( onBakedTextureMasksLoaded, MORPH_MASK_REQUESTED_DISCARD, TRUE, TRUE, new LLTextureMaskData( mID ));   
-                        image->setLoadedCallback( onInitialBakedTextureLoaded, MAX_DISCARD_LEVEL, FALSE, FALSE, new LLUUID( mID ) );
-                }
-                
-                if( lower_baked )
-                {
-                        mLastLowerBodyBakedID = getTEImage( TEX_LOWER_BAKED )->getID();
-                        LLViewerImage* image = getTEImage( TEX_LOWER_BAKED );
-                        image->setLoadedCallback( onBakedTextureMasksLoaded, MORPH_MASK_REQUESTED_DISCARD, TRUE, TRUE, new LLTextureMaskData( mID ));   
-                        image->setLoadedCallback( onInitialBakedTextureLoaded, MAX_DISCARD_LEVEL, FALSE, FALSE, new LLUUID( mID ) );
-                }
-
-                if( eyes_baked )
-                {
-                        mLastEyesBakedID = getTEImage( TEX_EYES_BAKED )->getID();
-                        LLViewerImage* image = getTEImage( TEX_EYES_BAKED );
-                        image->setLoadedCallback( onInitialBakedTextureLoaded, MAX_DISCARD_LEVEL, FALSE, FALSE, new LLUUID( mID ) );
-                }
+                        bool layer_baked = isTextureDefined(mBakedTextureData[i].mTextureIndex);
 
-                if( skirt_baked )
-                {
-                        mLastSkirtBakedID = getTEImage( TEX_SKIRT_BAKED )->getID();
-                        LLViewerImage* image = getTEImage( TEX_SKIRT_BAKED );
-                        image->setLoadedCallback( onInitialBakedTextureLoaded, MAX_DISCARD_LEVEL, FALSE, FALSE, new LLUUID( mID ) );
+                        // Use any baked textures that we have even if they haven't downloaded yet.
+                        // (That is, don't do a transition from unbaked to baked.)
+                        if (layer_baked)
+                        {
+                                LLViewerImage* image = getTEImage( mBakedTextureData[i].mTextureIndex );
+                                mBakedTextureData[i].mLastTextureIndex = image->getID();
+                                // If we have more than one texture for the other baked layers, we'll want to call this for them too.
+                                if ( (i == BAKED_HEAD) || (i == BAKED_UPPER) || (i == BAKED_LOWER) )
+                                {
+                                        image->setLoadedCallback( onBakedTextureMasksLoaded, MORPH_MASK_REQUESTED_DISCARD, TRUE, TRUE, new LLTextureMaskData( mID ));
+                                }
+                                image->setLoadedCallback( onInitialBakedTextureLoaded, MAX_DISCARD_LEVEL, FALSE, FALSE, new LLUUID( mID ) );
+                        }
                 }
 
                 updateMeshTextures();
@@ -8594,11 +7789,13 @@ void LLVOAvatar::processAvatarAppearance( LLMessageSystem* mesgsys )
         unpackTEMessage(mesgsys, _PREHASH_ObjectData);
 //      dumpAvatarTEs( "POST processAvatarAppearance()" );
 
-//      llinfos << "Received AvatarAppearance: " << (mIsSelf ? "(self): " : "(other): " ) << 
-//              (( getTEImage( TEX_HEAD_BAKED )->getID() != IMG_DEFAULT_AVATAR )  ? "HEAD " : "head " ) <<
-//              (( getTEImage( TEX_UPPER_BAKED )->getID() != IMG_DEFAULT_AVATAR ) ? "UPPER " : "upper " ) <<
-//              (( getTEImage( TEX_LOWER_BAKED )->getID() != IMG_DEFAULT_AVATAR ) ? "LOWER " : "lower " ) <<
-//              (( getTEImage( TEX_EYES_BAKED )->getID() != IMG_DEFAULT_AVATAR )  ? "EYES" : "eyes" ) << llendl;
+        //llinfos << "Received AvatarAppearance: " << (mIsSelf ? "(self): " : "(other): ")  << std::endl <<
+        //      (isTextureDefined(TEX_HEAD_BAKED)  ? "HEAD " : "head " ) << (getTEImage(TEX_HEAD_BAKED)->getID()) << std::endl <<
+        //      (isTextureDefined(TEX_UPPER_BAKED) ? "UPPER " : "upper " ) << (getTEImage(TEX_UPPER_BAKED)->getID()) << std::endl <<
+        //      (isTextureDefined(TEX_LOWER_BAKED) ? "LOWER " : "lower " ) << (getTEImage(TEX_LOWER_BAKED)->getID()) << std::endl <<
+        //      (isTextureDefined(TEX_SKIRT_BAKED) ? "SKIRT " : "skirt " ) << (getTEImage(TEX_SKIRT_BAKED)->getID()) << std::endl <<
+        //      (isTextureDefined(TEX_HAIR_BAKED) ? "HAIR" : "hair " ) << (getTEImage(TEX_HAIR_BAKED)->getID()) << std::endl <<
+        //      (isTextureDefined(TEX_EYES_BAKED)  ? "EYES" : "eyes" ) << (getTEImage(TEX_EYES_BAKED)->getID()) << llendl ;
  
         if( !mFirstTEMessageReceived )
         {
@@ -8606,6 +7803,12 @@ void LLVOAvatar::processAvatarAppearance( LLMessageSystem* mesgsys )
         }
 
         setCompositeUpdatesEnabled( FALSE );
+
+        if (!mIsSelf)
+        {
+                releaseUnnecessaryTextures();
+        }
+        
         updateMeshTextures(); // enables updates for laysets without baked textures.
 
         // parse visual params
@@ -8653,7 +7856,6 @@ void LLVOAvatar::processAvatarAppearance( LLMessageSystem* mesgsys )
                                                 param->setAnimationTarget(newWeight, FALSE);
                                         }
                                 }
-                                
                                 param = getNextVisualParam();
                         }
                 }
@@ -8727,28 +7929,20 @@ void LLVOAvatar::getAnimNames( LLDynamicArray<std::string>* names )
 
 void LLVOAvatar::onBakedTextureMasksLoaded( BOOL success, LLViewerImage *src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata )
 {
-        //llinfos << "onBakedTextureMasksLoaded: " << src_vi->getID() << llendl;
-        LLMemType mt(LLMemType::MTYPE_AVATAR);
-        
-        LLUUID id = src_vi->getID();
+        if (!userdata) return;
 
-        if (!userdata)
-        {
-                return;
-        }
+        //llinfos << "onBakedTextureMasksLoaded: " << src_vi->getID() << llendl;
+        const LLMemType mt(LLMemType::MTYPE_AVATAR);
+        const LLUUID id = src_vi->getID();
  
         LLTextureMaskData* maskData = (LLTextureMaskData*) userdata;
         LLVOAvatar* self = (LLVOAvatar*) gObjectList.findObject( maskData->mAvatarID );
 
         // if discard level is 2 less than last discard level we processed, or we hit 0,
         // then generate morph masks
-        if( self && success && (discard_level < maskData->mLastDiscardLevel - 2 || discard_level == 0) )
+        if(self && success && (discard_level < maskData->mLastDiscardLevel - 2 || discard_level == 0))
         {
-                LLViewerImage* head_baked =             self->getTEImage( TEX_HEAD_BAKED );
-                LLViewerImage* upper_baked =    self->getTEImage( TEX_UPPER_BAKED );
-                LLViewerImage* lower_baked =    self->getTEImage( TEX_LOWER_BAKED );
-        
-                if( aux_src && aux_src->getComponents() == 1 )
+                if(aux_src && aux_src->getComponents() == 1)
                 {
                         if (!aux_src->getData())
                         {
@@ -8757,85 +7951,63 @@ void LLVOAvatar::onBakedTextureMasksLoaded( BOOL success, LLViewerImage *src_vi,
                         }
 
                         U32 gl_name;
-                        glGenTextures(1, (GLuint*) &gl_name );
+                        LLImageGL::generateTextures(1, &gl_name );
                         stop_glerror();
 
                         gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, gl_name);
                         stop_glerror();
 
-                        glTexImage2D(
+                        LLImageGL::setManualImage(
                                 GL_TEXTURE_2D, 0, GL_ALPHA8, 
                                 aux_src->getWidth(), aux_src->getHeight(),
-                                0, GL_ALPHA, GL_UNSIGNED_BYTE, aux_src->getData());
+                                GL_ALPHA, GL_UNSIGNED_BYTE, aux_src->getData());
                         stop_glerror();
 
-                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+                        gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR);
 
-                        if( id == head_baked->getID() )
-                        {
-                                if (self->mHeadLayerSet)
-                                {
-                                        //llinfos << "onBakedTextureMasksLoaded for head " << id << " discard = " << discard_level << llendl;
-                                        self->mHeadLayerSet->applyMorphMask(aux_src->getData(), aux_src->getWidth(), aux_src->getHeight(), 1);
-                                        maskData->mLastDiscardLevel = discard_level;
-                                        self->mHeadMaskDiscard = discard_level;
-                                        if (self->mHeadMaskTexName)
-                                        {
-                                                glDeleteTextures(1, (GLuint*) &self->mHeadMaskTexName);
-                                        }
-                                        self->mHeadMaskTexName = gl_name;
-                                }
-                                else
-                                {
-                                        llwarns << "onBakedTextureMasksLoaded: no mHeadLayerSet." << llendl;
-                                }
-                        }
-                        else
-                        if( id == upper_baked->getID() )
+                        /* if( id == head_baked->getID() )
+                             if (self->mBakedTextureData[BAKED_HEAD].mTexLayerSet)
+                                     //llinfos << "onBakedTextureMasksLoaded for head " << id << " discard = " << discard_level << llendl;
+                                         self->mBakedTextureData[BAKED_HEAD].mTexLayerSet->applyMorphMask(aux_src->getData(), aux_src->getWidth(), aux_src->getHeight(), 1);
+                                         maskData->mLastDiscardLevel = discard_level; */
+                        bool found_texture_id = false;
+                        for (LLVOAvatarDictionary::texture_map_t::const_iterator iter = LLVOAvatarDictionary::getInstance()->getTextures().begin();
+                                 iter != LLVOAvatarDictionary::getInstance()->getTextures().end();
+                                 iter++)
                         {
-                                if ( self->mUpperBodyLayerSet)
-                                {
-                                        //llinfos << "onBakedTextureMasksLoaded for upper body " << id << " discard = " << discard_level << llendl;
-                                        self->mUpperBodyLayerSet->applyMorphMask(aux_src->getData(), aux_src->getWidth(), aux_src->getHeight(), 1);
-                                        maskData->mLastDiscardLevel = discard_level;
-                                        self->mUpperMaskDiscard = discard_level;
-                                        if (self->mUpperMaskTexName)
-                                        {
-                                                glDeleteTextures(1, (GLuint*) &self->mUpperMaskTexName);
-                                        }
-                                        self->mUpperMaskTexName = gl_name;
-                                }
-                                else
-                                {
-                                        llwarns << "onBakedTextureMasksLoaded: no mHeadLayerSet." << llendl;
-                                }
-                        }
-                        else
-                        if( id == lower_baked->getID() )
-                        {
-                                if ( self->mLowerBodyLayerSet )
+
+                                const LLVOAvatarDictionary::TextureDictionaryEntry *text_dict = iter->second;
+                                if (text_dict->mIsUsedByBakedTexture)
                                 {
-                                        //llinfos << "onBakedTextureMasksLoaded for lower body " << id << " discard = " << discard_level << llendl;
-                                        self->mLowerBodyLayerSet->applyMorphMask(aux_src->getData(), aux_src->getWidth(), aux_src->getHeight(), 1);
-                                        maskData->mLastDiscardLevel = discard_level;
-                                        self->mLowerMaskDiscard = discard_level;
-                                        if (self->mLowerMaskTexName)
+                                        const ETextureIndex texture_index = iter->first;
+                                        const LLViewerImage *baked_img = self->getTEImage(texture_index);
+                                        if (id == baked_img->getID())
                                         {
-                                                glDeleteTextures(1, (GLuint*) &self->mLowerMaskTexName);
+                                                const EBakedTextureIndex baked_index = text_dict->mBakedTextureIndex;
+                                                if (self->mBakedTextureData[baked_index].mTexLayerSet)
+                                                {
+                                                        //llinfos << "onBakedTextureMasksLoaded for " << text_dict->mName << " " << id << " discard = " << discard_level << llendl;
+                                                        self->mBakedTextureData[baked_index].mTexLayerSet->applyMorphMask(aux_src->getData(), aux_src->getWidth(), aux_src->getHeight(), 1);
+                                                        maskData->mLastDiscardLevel = discard_level;
+                                                        if (self->mBakedTextureData[baked_index].mMaskTexName)
+                                                        {
+                                                                LLImageGL::deleteTextures(1, &(self->mBakedTextureData[baked_index].mMaskTexName));
+                                                        }
+                                                        self->mBakedTextureData[baked_index].mMaskTexName = gl_name;
+                                                }
+                                                else
+                                                {
+                                                        llwarns << "onBakedTextureMasksLoaded: no LayerSet for " << text_dict->mName << "." << llendl;
+                                                }
+                                                found_texture_id = true;
+                                                break;
                                         }
-                                        self->mLowerMaskTexName = gl_name;
-                                }
-                                else
-                                {
-                                        llwarns << "onBakedTextureMasksLoaded: no mHeadLayerSet." << llendl;
                                 }
                         }
-                        else
+                        if (!found_texture_id)
                         {
                                 llinfos << "onBakedTextureMasksLoaded(): unexpected image id: " << id << llendl;
                         }
-
                         self->dirtyMesh();
                 }
                 else
@@ -8850,7 +8022,6 @@ void LLVOAvatar::onBakedTextureMasksLoaded( BOOL success, LLViewerImage *src_vi,
         {
                 delete maskData;
         }
-
 }
 
 // static
@@ -8897,109 +8068,34 @@ void LLVOAvatar::onBakedTextureLoaded(BOOL success, LLViewerImage *src_vi, LLIma
 // Called when baked texture is loaded and also when we start up with a baked texture
 void LLVOAvatar::useBakedTexture( const LLUUID& id )
 {
-//      llinfos << "useBakedTexture" << llendl;
-        LLViewerImage* head_baked =             getTEImage( TEX_HEAD_BAKED );
-        LLViewerImage* upper_baked =    getTEImage( TEX_UPPER_BAKED );
-        LLViewerImage* lower_baked =    getTEImage( TEX_LOWER_BAKED );
-        LLViewerImage* eyes_baked =             getTEImage( TEX_EYES_BAKED );
-        LLViewerImage* skirt_baked =    getTEImage( TEX_SKIRT_BAKED );
-
-        if( id == head_baked->getID() )
-        {
-                mHeadBakedLoaded = TRUE;
-                
-                mLastHeadBakedID = id;
-                mHeadMesh0.setTexture( head_baked );
-                mHeadMesh1.setTexture( head_baked );
-                mHeadMesh2.setTexture( head_baked );
-                mHeadMesh3.setTexture( head_baked );
-                mHeadMesh4.setTexture( head_baked );
-                mEyeLashMesh0.setTexture( head_baked );
-                if( mHeadLayerSet )
-                {
-                        mHeadLayerSet->destroyComposite();
-                }
-                setLocalTexture( LOCTEX_HEAD_BODYPAINT,         getTEImage( TEX_HEAD_BODYPAINT ),       TRUE );
-        }
-        else
-        if( id == upper_baked->getID() )
+        /* if(id == head_baked->getID())
+                 mHeadBakedLoaded = TRUE;
+                 mLastHeadBakedID = id;
+                 mHeadMesh0.setTexture( head_baked );
+                 mHeadMesh1.setTexture( head_baked ); */
+        for (U32 i = 0; i < mBakedTextureData.size(); i++)
         {
-                mUpperBakedLoaded = TRUE;
-
-                mLastUpperBodyBakedID = id;
-                mUpperBodyMesh0.setTexture( upper_baked );
-                mUpperBodyMesh1.setTexture( upper_baked );
-                mUpperBodyMesh2.setTexture( upper_baked );
-                mUpperBodyMesh3.setTexture( upper_baked );
-                mUpperBodyMesh4.setTexture( upper_baked );
-                if( mUpperBodyLayerSet )
+                LLViewerImage* image_baked = getTEImage( mBakedTextureData[i].mTextureIndex );
+                if (id == image_baked->getID())
                 {
-                        mUpperBodyLayerSet->destroyComposite();
-                }
-
-                setLocalTexture( LOCTEX_UPPER_SHIRT,            getTEImage( TEX_UPPER_SHIRT ),          TRUE );
-                setLocalTexture( LOCTEX_UPPER_BODYPAINT,        getTEImage( TEX_UPPER_BODYPAINT ),      TRUE );
-                setLocalTexture( LOCTEX_UPPER_JACKET,           getTEImage( TEX_UPPER_JACKET ),         TRUE );
-                setLocalTexture( LOCTEX_UPPER_GLOVES,           getTEImage( TEX_UPPER_GLOVES ),         TRUE );
-                setLocalTexture( LOCTEX_UPPER_UNDERSHIRT,       getTEImage( TEX_UPPER_UNDERSHIRT ),     TRUE );
-        }
-        else
-        if( id == lower_baked->getID() )
-        {
-                mLowerBakedLoaded = TRUE;
-
-                mLastLowerBodyBakedID = id;
-                mLowerBodyMesh0.setTexture( lower_baked );
-                mLowerBodyMesh1.setTexture( lower_baked );
-                mLowerBodyMesh2.setTexture( lower_baked );
-                mLowerBodyMesh3.setTexture( lower_baked );
-                mLowerBodyMesh4.setTexture( lower_baked );
-                if( mLowerBodyLayerSet )
-                {
-                        mLowerBodyLayerSet->destroyComposite();
-                }
-
-                setLocalTexture( LOCTEX_LOWER_PANTS,            getTEImage( TEX_LOWER_PANTS ),          TRUE );
-                setLocalTexture( LOCTEX_LOWER_BODYPAINT,        getTEImage( TEX_LOWER_BODYPAINT ),      TRUE );
-                setLocalTexture( LOCTEX_LOWER_SHOES,            getTEImage( TEX_LOWER_SHOES ),          TRUE );
-                setLocalTexture( LOCTEX_LOWER_SOCKS,            getTEImage( TEX_LOWER_SOCKS ),          TRUE );
-                setLocalTexture( LOCTEX_LOWER_JACKET,           getTEImage( TEX_LOWER_JACKET ),         TRUE );
-                setLocalTexture( LOCTEX_LOWER_UNDERPANTS,       getTEImage( TEX_LOWER_UNDERPANTS ),     TRUE );
-        }
-        else
-        if( id == eyes_baked->getID() )
-        {
-                mEyesBakedLoaded = TRUE;
-
-                mLastEyesBakedID = id;
-                mEyeBallLeftMesh0.setTexture(  eyes_baked );
-                mEyeBallLeftMesh1.setTexture(  eyes_baked );
-                mEyeBallRightMesh0.setTexture( eyes_baked );
-                mEyeBallRightMesh1.setTexture( eyes_baked );
-                if( mEyesLayerSet )
-                {
-                        mEyesLayerSet->destroyComposite();
-                }
-
-                setLocalTexture( LOCTEX_EYES_IRIS,                      getTEImage( TEX_EYES_IRIS ), TRUE );
-        }
-        else
-        if( id == skirt_baked->getID() )
-        {
-                mSkirtBakedLoaded = TRUE;
-
-                mLastSkirtBakedID = id;
-                mSkirtMesh0.setTexture( skirt_baked );
-                mSkirtMesh1.setTexture( skirt_baked );
-                mSkirtMesh2.setTexture( skirt_baked );
-                mSkirtMesh3.setTexture( skirt_baked );
-                mSkirtMesh4.setTexture( skirt_baked );
-                if( mSkirtLayerSet )
-                {
-                        mSkirtLayerSet->destroyComposite();
+                        mBakedTextureData[i].mIsLoaded = true;
+                        mBakedTextureData[i].mLastTextureIndex = id;
+                        for (U32 k = 0; k < mBakedTextureData[i].mMeshes.size(); k++)
+                        {
+                                mBakedTextureData[i].mMeshes[k]->setTexture( image_baked );
+                        }
+                        if (mBakedTextureData[i].mTexLayerSet)
+                        {
+                                mBakedTextureData[i].mTexLayerSet->destroyComposite();
+                        }
+                        const LLVOAvatarDictionary::BakedDictionaryEntry *baked_dict = LLVOAvatarDictionary::getInstance()->getBakedTexture((EBakedTextureIndex)i);
+                        for (texture_vec_t::const_iterator local_tex_iter = baked_dict->mLocalTextures.begin();
+                                 local_tex_iter != baked_dict->mLocalTextures.end();
+                                 local_tex_iter++)
+                        {
+                                setLocalTexture(*local_tex_iter, getTEImage(*local_tex_iter), TRUE);
+                        }
                 }
-
-                setLocalTexture( LOCTEX_SKIRT,                          getTEImage( TEX_SKIRT ), TRUE );
         }
 
         dirtyMesh();
@@ -9009,7 +8105,9 @@ void LLVOAvatar::useBakedTexture( const LLUUID& id )
 void LLVOAvatar::dumpArchetypeXML( void* )
 {
         LLVOAvatar* avatar = gAgent.getAvatarObject();
-        apr_file_t* file = ll_apr_file_open(gDirUtilp->getExpandedFilename(LL_PATH_CHARACTER,"new archetype.xml"), LL_APR_WB );
+        LLAPRFile outfile ;
+        outfile.open(gDirUtilp->getExpandedFilename(LL_PATH_CHARACTER,"new archetype.xml"), LL_APR_WB );
+        apr_file_t* file = outfile.getFileHandle() ;
         if( !file )
         {
                 return;
@@ -9036,11 +8134,11 @@ void LLVOAvatar::dumpArchetypeXML( void* )
                         }
                 }
 
-                for( S32 te = 0; te < TEX_NUM_ENTRIES; te++ )
+                for(U8 te = 0; te < TEX_NUM_INDICES; te++)
                 {
-                        if( LLVOAvatar::getTEWearableType( te ) == type )
+                        if( LLVOAvatar::getTEWearableType((ETextureIndex)te) == type )
                         {
-                                LLViewerImage* te_image = avatar->getTEImage( te );
+                                LLViewerImage* te_image = avatar->getTEImage((ETextureIndex)te);
                                 if( te_image )
                                 {
                                         std::string uuid_str;
@@ -9052,7 +8150,6 @@ void LLVOAvatar::dumpArchetypeXML( void* )
         }
         apr_file_printf( file, "\t</archetype>\n" );
         apr_file_printf( file, "\n</linden_genepool>\n" );
-        apr_file_close( file );
 }
 
 
@@ -9068,33 +8165,7 @@ void LLVOAvatar::setVisibilityRank(U32 rank)
                 return;
         }
 
-        BOOL stale = gFrameTimeSeconds - mLastFadeTime > 10.f;
-        
-        //only raise visibility rank or trigger a fade out every 10 seconds
-        if (mVisibilityRank >= (U32) LLVOAvatar::sMaxVisible && rank < (U32) LLVOAvatar::sMaxVisible ||
-                (stale && mVisibilityRank < (U32) LLVOAvatar::sMaxVisible && rank >= (U32) LLVOAvatar::sMaxVisible))
-        { //remember the time we became visible/invisible based on visibility rank
-                mVisibilityRank = rank;
-                mLastFadeTime = gFrameTimeSeconds;
-                mLastFadeDistance = mDrawable->mDistanceWRTCamera;
-
-                F32 blend = gFrameTimeSeconds - mFadeTime;
-                mFadeTime = gFrameTimeSeconds;
-                if (blend < 1.f)
-                { //move the blend time back if a blend is already in progress (prevent flashes)
-                        mFadeTime -= 1.f-blend;
-                }
-        }
-        else if (stale)
-        {
-                mLastFadeTime = gFrameTimeSeconds;
-                mLastFadeDistance = mDrawable->mDistanceWRTCamera;
-                mVisibilityRank = rank;
-        }
-        else
-        {
-                mVisibilityRank = llmin(mVisibilityRank, rank);
-        }
+        mVisibilityRank = rank;
 }
 
 // Assumes LLVOAvatar::sInstances has already been sorted.
@@ -9120,39 +8191,39 @@ S32 LLVOAvatar::getUnbakedPixelAreaRank()
         return 0;
 }
 
+struct CompareScreenAreaGreater
+{
+        bool operator()(const LLCharacter* const& lhs, const LLCharacter* const& rhs)
+        {
+                return lhs->getPixelArea() > rhs->getPixelArea();
+        }
+};
+
 // static
 void LLVOAvatar::cullAvatarsByPixelArea()
 {
         std::sort(LLCharacter::sInstances.begin(), LLCharacter::sInstances.end(), CompareScreenAreaGreater());
         
         // Update the avatars that have changed status
-        S32 comp_rank = 1;
         U32 rank = 0;
         for (std::vector<LLCharacter*>::iterator iter = LLCharacter::sInstances.begin();
                 iter != LLCharacter::sInstances.end(); ++iter)
         {
                 LLVOAvatar* inst = (LLVOAvatar*) *iter;
                 BOOL culled;
-                if( inst->isDead() )
-                {
-                        culled = TRUE;
-                }
-                else if( inst->isSelf() || inst->isFullyBaked() )
+                if (inst->isSelf() || inst->isFullyBaked())
                 {
                         culled = FALSE;
                 }
-                else
+                else 
                 {
-                        culled = (comp_rank > LLVOAvatar::sMaxOtherAvatarsToComposite) || (inst->mPixelArea < MIN_PIXEL_AREA_FOR_COMPOSITE);
-                        comp_rank++;
+                        culled = TRUE;
                 }
 
-                if( inst->mCulled != culled )
+                if (inst->mCulled != culled)
                 {
                         inst->mCulled = culled;
-
                         lldebugs << "avatar " << inst->getID() << (culled ? " start culled" : " start not culled" ) << llendl;
-
                         inst->updateMeshTextures();
                 }
 
@@ -9167,9 +8238,9 @@ void LLVOAvatar::cullAvatarsByPixelArea()
         }
 
         S32 grey_avatars = 0;
-        if( LLVOAvatar::areAllNearbyInstancesBaked(grey_avatars) )
+        if ( LLVOAvatar::areAllNearbyInstancesBaked(grey_avatars) )
         {
-                LLVOAvatar::deleteCachedImages();
+                LLVOAvatar::deleteCachedImages(false);
         }
         else
         {
@@ -9201,52 +8272,31 @@ const LLUUID& LLVOAvatar::grabLocalTexture(ETextureIndex index)
 BOOL LLVOAvatar::canGrabLocalTexture(ETextureIndex index)
 {
         // Check if the texture hasn't been baked yet.
-        if ( getTEImage( index )->getID() == IMG_DEFAULT_AVATAR )
+        if (!isTextureDefined(index))
         {
                 lldebugs << "getTEImage( " << (U32) index << " )->getID() == IMG_DEFAULT_AVATAR" << llendl;
                 return FALSE;
         }
 
+        if (gAgent.isGodlike())
+                return TRUE;
+
         // Check permissions of textures that show up in the
         // baked texture.  We don't want people copying people's
         // work via baked textures.
-        std::vector<ETextureIndex> textures;
-        switch (index)
-        {
-        case TEX_EYES_BAKED:
-                textures.push_back(TEX_EYES_IRIS);
-                break;
-        case TEX_HEAD_BAKED:
-                textures.push_back(TEX_HEAD_BODYPAINT);
-                break;
-        case TEX_UPPER_BAKED:
-                textures.push_back(TEX_UPPER_BODYPAINT);
-                textures.push_back(TEX_UPPER_UNDERSHIRT);
-                textures.push_back(TEX_UPPER_SHIRT);
-                textures.push_back(TEX_UPPER_JACKET);
-                textures.push_back(TEX_UPPER_GLOVES);
-                break;
-        case TEX_LOWER_BAKED:
-                textures.push_back(TEX_LOWER_BODYPAINT);
-                textures.push_back(TEX_LOWER_UNDERPANTS);
-                textures.push_back(TEX_LOWER_PANTS);
-                textures.push_back(TEX_LOWER_JACKET);
-                textures.push_back(TEX_LOWER_SOCKS);
-                textures.push_back(TEX_LOWER_SHOES);
-                break;
-        case TEX_SKIRT_BAKED:
-                textures.push_back(TEX_SKIRT);
-                break;
-        default:
-                return FALSE;
-                break;
-        }
-
-        std::vector<ETextureIndex>::iterator iter = textures.begin();
-        std::vector<ETextureIndex>::iterator end  = textures.end();
-        for (; iter != end; ++iter)
-        {
-                ETextureIndex t_index = (*iter);
+        /* switch(index)
+                case TEX_EYES_BAKED:
+                        textures.push_back(TEX_EYES_IRIS); */
+        const LLVOAvatarDictionary::TextureDictionaryEntry *text_dict = LLVOAvatarDictionary::getInstance()->getTexture(index);
+        if (!text_dict->mIsUsedByBakedTexture) return FALSE;
+
+        const EBakedTextureIndex baked_index = text_dict->mBakedTextureIndex;
+        const LLVOAvatarDictionary::BakedDictionaryEntry *baked_dict = LLVOAvatarDictionary::getInstance()->getBakedTexture(baked_index);
+        for (texture_vec_t::const_iterator iter = baked_dict->mLocalTextures.begin();
+                 iter != baked_dict->mLocalTextures.end();
+                 iter++)
+        {
+                const ETextureIndex t_index = (*iter);
                 lldebugs << "Checking index " << (U32) t_index << llendl;
                 const LLUUID& texture_id = getTEImage( t_index )->getID();
                 if (texture_id != IMG_DEFAULT_AVATAR)
@@ -9293,62 +8343,43 @@ void LLVOAvatar::dumpLocalTextures()
 {
         llinfos << "Local Textures:" << llendl;
 
-        const char* names[] = {
-                "Shirt     ",
-                "UpperTatoo",
-                "Pants     ",
-                "LowerTatoo",
-                "Head Tatoo",
-                "Shoes     ",
-                "Socks     ",
-                "Upper Jckt",
-                "Lower Jckt",
-                "Gloves    ",
-                "Undershirt",
-                "Underpants",
-                "Iris      ",
-                "Skirt      "};
-
-        ETextureIndex baked_equiv[] = {
+        /* ETextureIndex baked_equiv[] = {
                 TEX_UPPER_BAKED,
-                TEX_UPPER_BAKED,
-                TEX_LOWER_BAKED,
-                TEX_LOWER_BAKED,
-                TEX_HEAD_BAKED,
-                TEX_LOWER_BAKED,
-                TEX_LOWER_BAKED,
-                TEX_UPPER_BAKED,
-                TEX_LOWER_BAKED,
-                TEX_UPPER_BAKED,
-                TEX_UPPER_BAKED,
-                TEX_LOWER_BAKED,
-                TEX_EYES_BAKED,
-                TEX_SKIRT_BAKED };
+           if (isTextureDefined(baked_equiv[i])) */
+        for (LLVOAvatarDictionary::texture_map_t::const_iterator iter = LLVOAvatarDictionary::getInstance()->getTextures().begin();
+                 iter != LLVOAvatarDictionary::getInstance()->getTextures().end();
+                 iter++)
+        {
+                const LLVOAvatarDictionary::TextureDictionaryEntry *text_dict = iter->second;
+                if (!text_dict->mIsLocalTexture || !text_dict->mIsUsedByBakedTexture)
+                        continue;
 
+                const EBakedTextureIndex baked_index = text_dict->mBakedTextureIndex;
+                const ETextureIndex baked_equiv = LLVOAvatarDictionary::getInstance()->getBakedTexture(baked_index)->mTextureIndex;
 
-        for( S32 i = 0; i < LOCTEX_NUM_ENTRIES; i++ )
-        {
-                if( getTEImage( baked_equiv[i] )->getID() != IMG_DEFAULT_AVATAR )
+                const std::string &name = text_dict->mName;
+                const LocalTextureData &local_tex_data = mLocalTextureData[iter->first];
+                if (isTextureDefined(baked_equiv))
                 {
 #if LL_RELEASE_FOR_DOWNLOAD
                         // End users don't get to trivially see avatar texture IDs, makes textures
                         // easier to steal. JC
-                        llinfos << "LocTex " << names[i] << ": Baked " << llendl;
+                        llinfos << "LocTex " << name << ": Baked " << llendl;
 #else
-                        llinfos << "LocTex " << names[i] << ": Baked " << getTEImage( baked_equiv[i] )->getID() << llendl;
+                        llinfos << "LocTex " << name << ": Baked " << getTEImage( baked_equiv )->getID() << llendl;
 #endif
                 }
-                else if (mLocalTexture[i].notNull())
+                else if (local_tex_data.mImage.notNull())
                 {
-                        if( mLocalTexture[i]->getID() == IMG_DEFAULT_AVATAR )
+                        if( local_tex_data.mImage->getID() == IMG_DEFAULT_AVATAR )
                         {
-                                llinfos << "LocTex " << names[i] << ": None" << llendl;
+                                llinfos << "LocTex " << name << ": None" << llendl;
                         }
                         else
                         {
-                                LLViewerImage* image = mLocalTexture[i];
+                                const LLViewerImage* image = local_tex_data.mImage;
 
-                                llinfos << "LocTex " << names[i] << ": "
+                                llinfos << "LocTex " << name << ": "
                                                 << "Discard " << image->getDiscardLevel() << ", "
                                                 << "(" << image->getWidth() << ", " << image->getHeight() << ") " 
 #if !LL_RELEASE_FOR_DOWNLOAD
@@ -9362,7 +8393,7 @@ void LLVOAvatar::dumpLocalTextures()
                 }
                 else
                 {
-                        llinfos << "LocTex " << names[i] << ": No LLViewerImage" << llendl;
+                        llinfos << "LocTex " << name << ": No LLViewerImage" << llendl;
                 }
         }
 }
@@ -9381,30 +8412,25 @@ void LLVOAvatar::startAppearanceAnimation(BOOL set_by_user, BOOL play_sound)
 
 void LLVOAvatar::removeMissingBakedTextures()
 {       
-        if (!mIsSelf)
-        {
-                return;
-        }
-        BOOL removed = FALSE;
+        if (!mIsSelf) return;
 
-        for( S32 i = 0; i < BAKED_TEXTURE_COUNT; i++ )
+        BOOL removed = FALSE;
+        for (U32 i = 0; i < mBakedTextureData.size(); i++)
         {
-                S32 te = sBakedTextureIndices[i];
-
-                if( getTEImage( te )->isMissingAsset() )
+                const S32 te = mBakedTextureData[i].mTextureIndex;
+                if (getTEImage(te)->isMissingAsset())
                 {
-                        setTEImage( te, gImageList.getImage(IMG_DEFAULT_AVATAR) );
+                        setTEImage(te, gImageList.getImage(IMG_DEFAULT_AVATAR));
                         removed = TRUE;
                 }
         }
 
-        if( removed )
+        if (removed)
         {
-                invalidateComposite( mEyesLayerSet,                     FALSE );
-                invalidateComposite( mHeadLayerSet,                     FALSE );
-                invalidateComposite( mUpperBodyLayerSet,        FALSE );
-                invalidateComposite( mLowerBodyLayerSet,        FALSE );
-                invalidateComposite( mSkirtLayerSet,            FALSE );
+                for(U32 i = 0; i < mBakedTextureData.size(); i++)
+                {
+                        invalidateComposite(mBakedTextureData[i].mTexLayerSet, FALSE);
+                }
                 updateMeshTextures();
                 requestLayerSetUploads();
         }
@@ -9412,15 +8438,15 @@ void LLVOAvatar::removeMissingBakedTextures()
 
 
 //-----------------------------------------------------------------------------
-// LLVOAvatarInfo
+// LLVOAvatarXmlInfo
 //-----------------------------------------------------------------------------
 
-LLVOAvatarInfo::LLVOAvatarInfo()
+LLVOAvatarXmlInfo::LLVOAvatarXmlInfo()
         : mTexSkinColorInfo(0), mTexHairColorInfo(0), mTexEyeColorInfo(0)
 {
 }
 
-LLVOAvatarInfo::~LLVOAvatarInfo()
+LLVOAvatarXmlInfo::~LLVOAvatarXmlInfo()
 {
         std::for_each(mMeshInfoList.begin(), mMeshInfoList.end(), DeletePointer());
         std::for_each(mSkeletalDistortionInfoList.begin(), mSkeletalDistortionInfoList.end(), DeletePointer());         
@@ -9541,7 +8567,7 @@ BOOL LLVOAvatarSkeletonInfo::parseXml(LLXmlTreeNode* node)
 //-----------------------------------------------------------------------------
 // parseXmlSkeletonNode(): parses <skeleton> nodes from XML tree
 //-----------------------------------------------------------------------------
-BOOL LLVOAvatarInfo::parseXmlSkeletonNode(LLXmlTreeNode* root)
+BOOL LLVOAvatarXmlInfo::parseXmlSkeletonNode(LLXmlTreeNode* root)
 {
         LLXmlTreeNode* node = root->getChildByName( "skeleton" );
         if( !node )
@@ -9647,7 +8673,7 @@ BOOL LLVOAvatarInfo::parseXmlSkeletonNode(LLXmlTreeNode* root)
 //-----------------------------------------------------------------------------
 // parseXmlMeshNodes(): parses <mesh> nodes from XML tree
 //-----------------------------------------------------------------------------
-BOOL LLVOAvatarInfo::parseXmlMeshNodes(LLXmlTreeNode* root)
+BOOL LLVOAvatarXmlInfo::parseXmlMeshNodes(LLXmlTreeNode* root)
 {
         for (LLXmlTreeNode* node = root->getChildByName( "mesh" );
                  node;
@@ -9737,7 +8763,7 @@ BOOL LLVOAvatarInfo::parseXmlMeshNodes(LLXmlTreeNode* root)
 //-----------------------------------------------------------------------------
 // parseXmlColorNodes(): parses <global_color> nodes from XML tree
 //-----------------------------------------------------------------------------
-BOOL LLVOAvatarInfo::parseXmlColorNodes(LLXmlTreeNode* root)
+BOOL LLVOAvatarXmlInfo::parseXmlColorNodes(LLXmlTreeNode* root)
 {
         for (LLXmlTreeNode* color_node = root->getChildByName( "global_color" );
                  color_node;
@@ -9799,7 +8825,7 @@ BOOL LLVOAvatarInfo::parseXmlColorNodes(LLXmlTreeNode* root)
 //-----------------------------------------------------------------------------
 // parseXmlLayerNodes(): parses <layer_set> nodes from XML tree
 //-----------------------------------------------------------------------------
-BOOL LLVOAvatarInfo::parseXmlLayerNodes(LLXmlTreeNode* root)
+BOOL LLVOAvatarXmlInfo::parseXmlLayerNodes(LLXmlTreeNode* root)
 {
         for (LLXmlTreeNode* layer_node = root->getChildByName( "layer_set" );
                  layer_node;
@@ -9823,7 +8849,7 @@ BOOL LLVOAvatarInfo::parseXmlLayerNodes(LLXmlTreeNode* root)
 //-----------------------------------------------------------------------------
 // parseXmlDriverNodes(): parses <driver_parameters> nodes from XML tree
 //-----------------------------------------------------------------------------
-BOOL LLVOAvatarInfo::parseXmlDriverNodes(LLXmlTreeNode* root)
+BOOL LLVOAvatarXmlInfo::parseXmlDriverNodes(LLXmlTreeNode* root)
 {
         LLXmlTreeNode* driver = root->getChildByName( "driver_parameters" );
         if( driver )
@@ -9901,41 +8927,17 @@ std::string LLVOAvatar::getFullname() const
 
 LLTexLayerSet* LLVOAvatar::getLayerSet(ETextureIndex index) const
 {
-        switch( index )
+        /* switch(index)
+                case TEX_HEAD_BAKED:
+                case TEX_HEAD_BODYPAINT:
+                        return mHeadLayerSet; */
+        const LLVOAvatarDictionary::TextureDictionaryEntry *text_dict = LLVOAvatarDictionary::getInstance()->getTexture(index);
+        if (text_dict->mIsUsedByBakedTexture)
         {
-        case TEX_HEAD_BAKED:
-        case TEX_HEAD_BODYPAINT:
-                return mHeadLayerSet;
-
-        case TEX_UPPER_BAKED:
-        case TEX_UPPER_SHIRT:
-        case TEX_UPPER_BODYPAINT:
-        case TEX_UPPER_JACKET:
-        case TEX_UPPER_GLOVES:
-        case TEX_UPPER_UNDERSHIRT:
-                return mUpperBodyLayerSet;
-
-        case TEX_LOWER_BAKED:
-        case TEX_LOWER_PANTS:
-        case TEX_LOWER_BODYPAINT:
-        case TEX_LOWER_SHOES:
-        case TEX_LOWER_SOCKS:
-        case TEX_LOWER_JACKET:
-        case TEX_LOWER_UNDERPANTS:
-                return mLowerBodyLayerSet;
-        
-        case TEX_EYES_BAKED:
-        case TEX_EYES_IRIS:
-                return mEyesLayerSet;
-
-        case TEX_SKIRT_BAKED:
-        case TEX_SKIRT:
-                return mSkirtLayerSet;
-
-        case TEX_HAIR:
-        default:
-                return NULL;
+                const EBakedTextureIndex baked_index = text_dict->mBakedTextureIndex;
+                return mBakedTextureData[baked_index].mTexLayerSet;
         }
+        return NULL;
 }
 
 LLHost LLVOAvatar::getObjectHost() const
@@ -9956,15 +8958,15 @@ void LLVOAvatar::updateFreezeCounter(S32 counter)
 {
         if(counter)
         {
-                sFreezeCounter = counter ;
+                sFreezeCounter = counter;
         }
         else if(sFreezeCounter > 0)
         {
-                sFreezeCounter-- ;
+                sFreezeCounter--;
         }
         else
         {
-                sFreezeCounter = 0 ;
+                sFreezeCounter = 0;
         }
 }
 
@@ -10016,13 +9018,13 @@ void LLVOAvatar::updateImpostors()
 
 BOOL LLVOAvatar::isImpostor() const
 {
-        return (sUseImpostors && mUpdatePeriod >= VOAVATAR_IMPOSTOR_PERIOD) ? TRUE : FALSE;
+        return (sUseImpostors && mUpdatePeriod >= IMPOSTOR_PERIOD) ? TRUE : FALSE;
 }
 
 
 BOOL LLVOAvatar::needsImpostorUpdate() const
 {
-        return mNeedsImpostorUpdate ;
+        return mNeedsImpostorUpdate;
 }
 
 const LLVector3& LLVOAvatar::getImpostorOffset() const
@@ -10045,7 +9047,7 @@ void LLVOAvatar::cacheImpostorValues()
         getImpostorValues(mImpostorExtents, mImpostorAngle, mImpostorDistance);
 }
 
-void LLVOAvatar::getImpostorValues(LLVector3* extents, LLVector3& angle, F32& distance)
+void LLVOAvatar::getImpostorValues(LLVector3* extents, LLVector3& angle, F32& distance) const
 {
         const LLVector3* ext = mDrawable->getSpatialExtents();
         extents[0] = ext[0];
@@ -10059,6 +9061,85 @@ void LLVOAvatar::getImpostorValues(LLVector3* extents, LLVector3& angle, F32& di
         angle.mV[2] = da;
 }
 
+void LLVOAvatar::idleUpdateRenderCost()
+{
+        if (!gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_SHAME))
+        {
+                return;
+        }
+
+        U32 shame = 1;
+
+        std::set<LLUUID> textures;
+
+        attachment_map_t::const_iterator iter;
+        for (iter = mAttachmentPoints.begin(); 
+                iter != mAttachmentPoints.end();
+                ++iter)
+        {
+                LLViewerJointAttachment* attachment = iter->second;
+                LLViewerObject* object = attachment->getObject();
+                if (object && !object->isHUDAttachment())
+                {
+                        LLDrawable* drawable = object->mDrawable;
+                        if (drawable)
+                        {
+                                shame += 10;
+                                LLVOVolume* volume = drawable->getVOVolume();
+                                if (volume)
+                                {
+                                        shame += calc_shame(volume, textures);
+                                }
+                        }
+                }
+        }       
+
+        shame += textures.size() * 5;
+
+        setDebugText(llformat("%d", shame));
+        F32 green = 1.f-llclamp(((F32) shame-1024.f)/1024.f, 0.f, 1.f);
+        F32 red = llmin((F32) shame/1024.f, 1.f);
+        mText->setColor(LLColor4(red,green,0,1));
+}
+
+// static
+BOOL LLVOAvatar::isIndexLocalTexture(ETextureIndex index)
+{
+        if (index < 0 || index >= TEX_NUM_INDICES) return false;
+        return LLVOAvatarDictionary::getInstance()->getTexture(index)->mIsLocalTexture;
+}
+
+// static
+BOOL LLVOAvatar::isIndexBakedTexture(ETextureIndex index)
+{
+        if (index < 0 || index >= TEX_NUM_INDICES) return false;
+        return LLVOAvatarDictionary::getInstance()->getTexture(index)->mIsBakedTexture;
+}
+
+const std::string LLVOAvatar::getBakedStatusForPrintout() const
+{
+        std::string line;
+
+        for (LLVOAvatarDictionary::texture_map_t::const_iterator iter = LLVOAvatarDictionary::getInstance()->getTextures().begin();
+                 iter != LLVOAvatarDictionary::getInstance()->getTextures().end();
+                 iter++)
+        {
+                const ETextureIndex index = iter->first;
+                const LLVOAvatarDictionary::TextureDictionaryEntry *text_dict = iter->second;
+                if (text_dict->mIsBakedTexture)
+                {
+                        line += text_dict->mName;
+                        if (isTextureDefined(index))
+                        {
+                                line += "_baked";
+                        }
+                        line += " ";
+                }
+        }
+        return line;
+}
+
+
 U32 calc_shame(LLVOVolume* volume, std::set<LLUUID> &textures)
 {
         if (!volume)
@@ -10163,45 +9244,11 @@ U32 calc_shame(LLVOVolume* volume, std::set<LLUUID> &textures)
         return shame;
 }
 
-void LLVOAvatar::idleUpdateRenderCost()
-{
-        if (!gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_SHAME))
-        {
-                return;
-        }
-
-        U32 shame = 1;
-
-        std::set<LLUUID> textures;
-
-        attachment_map_t::const_iterator iter;
-        for (iter = mAttachmentPoints.begin(); 
-                iter != mAttachmentPoints.end();
-                ++iter)
-        {
-                LLViewerJointAttachment* attachment = iter->second;
-                LLViewerObject* object = attachment->getObject();
-                if (object && !object->isHUDAttachment())
-                {
-                        LLDrawable* drawable = object->mDrawable;
-                        if (drawable)
-                        {
-                                shame += 10;
-                                LLVOVolume* volume = drawable->getVOVolume();
-                                if (volume)
-                                {
-                                        shame += calc_shame(volume, textures);
-                                }
-                        }
-                }
-        }       
-
-        shame += textures.size() * 5;
+//-----------------------------------------------------------------------------
+// Utility functions
+//-----------------------------------------------------------------------------
 
-        setDebugText(llformat("%d", shame));
-        F32 green = 1.f-llclamp(((F32) shame-1024.f)/1024.f, 0.f, 1.f);
-        F32 red = llmin((F32) shame/1024.f, 1.f);
-        mText->setColor(LLColor4(red,green,0,1));
+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;
 }
-
-