1 files changed, 402 insertions, 214 deletions

diff --git a/OpenSim/Region/CoreModules/Avatar/AvatarFactory/AvatarFactoryModule.cs b/OpenSim/Region/CoreModules/Avatar/AvatarFactory/AvatarFactoryModule.cs
index cfb082b..4abac43 100644
--- a/OpenSim/Region/CoreModules/Avatar/AvatarFactory/AvatarFactoryModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/AvatarFactory/AvatarFactoryModule.cs
@@ -75,7 +75,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
                 m_savetime = Convert.ToInt32(appearanceConfig.GetString("DelayBeforeAppearanceSave",Convert.ToString(m_savetime)));
                 m_sendtime = Convert.ToInt32(appearanceConfig.GetString("DelayBeforeAppearanceSend",Convert.ToString(m_sendtime)));
                 m_reusetextures = appearanceConfig.GetBoolean("ReuseTextures",m_reusetextures);
-                
+
                 // m_log.InfoFormat("[AVFACTORY] configured for {0} save and {1} send",m_savetime,m_sendtime);
             }
 
@@ -166,7 +166,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
         }
 
         /// <summary>
-        /// Set appearance data (texture asset IDs and slider settings) 
+        /// Set appearance data (texture asset IDs and slider settings)
         /// </summary>
         /// <param name="sp"></param>
         /// <param name="texture"></param>
@@ -188,29 +188,9 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
                 // Process the visual params, this may change height as well
                 if (visualParams != null)
                 {
-                    //                    string[] visualParamsStrings = new string[visualParams.Length];
-                    //                    for (int i = 0; i < visualParams.Length; i++)
-                    //                        visualParamsStrings[i] = visualParams[i].ToString();
-                    //                    m_log.DebugFormat(
-                    //                        "[AVFACTORY]: Setting visual params for {0} to {1}",
-                    //                        client.Name, string.Join(", ", visualParamsStrings));
-/*
-                    float oldHeight = sp.Appearance.AvatarHeight;
-                    changed = sp.Appearance.SetVisualParams(visualParams);
-
-                    if (sp.Appearance.AvatarHeight != oldHeight && sp.Appearance.AvatarHeight > 0)
-                        ((ScenePresence)sp).SetHeight(sp.Appearance.AvatarHeight);
- */
-//                    float oldoff = sp.Appearance.AvatarFeetOffset;
-//                    Vector3 oldbox = sp.Appearance.AvatarBoxSize;
                     changed = sp.Appearance.SetVisualParams(visualParams);
-//                    float off = sp.Appearance.AvatarFeetOffset;
-//                    Vector3 box = sp.Appearance.AvatarBoxSize;
-//                    if(oldoff != off || oldbox != box)
-//                        ((ScenePresence)sp).SetSize(box,off);
-
                 }
-            
+
                 // Process the baked texture array
                 if (textureEntry != null)
                 {
@@ -222,9 +202,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
 
 //                    WriteBakedTexturesReport(sp, m_log.DebugFormat);
 
-                    // If bake textures are missing and this is not an NPC, request a rebake from client
-                    if (!ValidateBakedTextureCache(sp) && (((ScenePresence)sp).PresenceType != PresenceType.Npc))
-                        RequestRebake(sp, true);
+                    UpdateBakedTextureCache(sp, cacheItems);
 
                     // This appears to be set only in the final stage of the appearance
                     // update transaction. In theory, we should be able to do an immediate
@@ -251,7 +229,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
         private void SendAppearance(ScenePresence sp)
         {
             // Send the appearance to everyone in the scene
-            sp.SendAppearanceToAllOtherClients();
+            sp.SendAppearanceToAllOtherAgents();
 
             // Send animations back to the avatar as well
             sp.Animator.SendAnimPack();
@@ -289,7 +267,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
             WearableCacheItem[] items = sp.Appearance.WearableCacheItems;
             //foreach (WearableCacheItem item in items)
             //{
-               
+
             //}
             return items;
         }
@@ -310,23 +288,25 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
             if (bakedTextures.Count == 0)
                 return false;
 
+            IAssetCache cache = sp.Scene.RequestModuleInterface<IAssetCache>();
+            if(cache == null)
+                return true; // no baked local caching so nothing to do
+
             foreach (BakeType bakeType in bakedTextures.Keys)
             {
                 Primitive.TextureEntryFace bakedTextureFace = bakedTextures[bakeType];
 
                 if (bakedTextureFace == null)
-                {
-                    // This can happen legitimately, since some baked textures might not exist
-                    //m_log.WarnFormat(
-                    //    "[AV FACTORY]: No texture ID set for {0} for {1} in {2} not found when trying to save permanently",
-                    //    bakeType, sp.Name, m_scene.RegionInfo.RegionName);
                     continue;
-                }
 
-                AssetBase asset = m_scene.AssetService.Get(bakedTextureFace.TextureID.ToString());
+                AssetBase asset;
+                cache.Get(bakedTextureFace.TextureID.ToString(), out asset);
 
-                if (asset != null)
+                if (asset != null && asset.Local)
                 {
+                    // cache does not update asset contents
+                    cache.Expire(bakedTextureFace.TextureID.ToString());
+
                     // Replace an HG ID with the simple asset ID so that we can persist textures for foreign HG avatars
                     asset.ID = asset.FullID.ToString();
 
@@ -334,7 +314,8 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
                     asset.Local = false;
                     m_scene.AssetService.Store(asset);
                 }
-                else
+
+                if (asset == null)
                 {
                     m_log.WarnFormat(
                         "[AV FACTORY]: Baked texture id {0} not found for bake {1} for avatar {2} in {3} when trying to save permanently",
@@ -377,116 +358,366 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
             }
         }
 
-        public bool ValidateBakedTextureCache(IScenePresence sp)
+        // called on textures update
+        public bool UpdateBakedTextureCache(IScenePresence sp, WearableCacheItem[] cacheItems)
         {
-            bool defonly = true; // are we only using default textures
-            IImprovedAssetCache cache = m_scene.RequestModuleInterface<IImprovedAssetCache>();
-            IBakedTextureModule bakedModule = m_scene.RequestModuleInterface<IBakedTextureModule>();
-            WearableCacheItem[] wearableCache = null;
-
-            // Cache wearable data for teleport.
-            // Only makes sense if there's a bake module and a cache module
-            if (bakedModule != null && cache != null)
+            if(cacheItems == null)
+                return false;
+
+            // npcs dont have baked cache
+            if (((ScenePresence)sp).IsNPC)
+                return true;
+
+            // uploaded baked textures will be in assets local cache
+            IAssetCache cache = m_scene.RequestModuleInterface<IAssetCache>();
+            IBakedTextureModule m_BakedTextureModule = m_scene.RequestModuleInterface<IBakedTextureModule>();
+
+            int validDirtyBakes = 0;
+            int hits = 0;
+
+            // our main cacheIDs mapper is p.Appearance.WearableCacheItems
+            WearableCacheItem[] wearableCache = sp.Appearance.WearableCacheItems;
+
+            if (wearableCache == null)
+            {
+                wearableCache = WearableCacheItem.GetDefaultCacheItem();
+            }
+
+            List<UUID> missing = new List<UUID>();
+
+            bool haveSkirt = (wearableCache[19].TextureID != UUID.Zero);
+            bool haveNewSkirt = false;
+
+            // Process received baked textures
+            for (int i = 0; i < cacheItems.Length; i++)
             {
-                try
+                int idx = (int)cacheItems[i].TextureIndex;
+                Primitive.TextureEntryFace face = sp.Appearance.Texture.FaceTextures[idx];
+
+                // No face
+                if (face == null)
                 {
-                    wearableCache = bakedModule.Get(sp.UUID);
+                    // for some reason viewer is cleaning this
+                    if(idx != 19) // skirt is optional
+                        {
+                        sp.Appearance.Texture.FaceTextures[idx] = sp.Appearance.Texture.CreateFace((uint) idx);
+                        sp.Appearance.Texture.FaceTextures[idx].TextureID = AppearanceManager.DEFAULT_AVATAR_TEXTURE;
+                        }
+                    wearableCache[idx].CacheId = UUID.Zero;
+                    wearableCache[idx].TextureID = UUID.Zero;
+                    wearableCache[idx].TextureAsset = null;
+                    continue;
                 }
-                catch (Exception)
+                else
                 {
+                    if (face.TextureID == UUID.Zero || face.TextureID == AppearanceManager.DEFAULT_AVATAR_TEXTURE)
+                    {
+                        wearableCache[idx].CacheId = UUID.Zero;
+                        wearableCache[idx].TextureID = UUID.Zero;
+                        wearableCache[idx].TextureAsset = null;
+                        continue;
+                    }
 
-                }
-                if (wearableCache != null)
-                {
-                    for (int i = 0; i < wearableCache.Length; i++)
+                    if(idx == 19)
+                        haveNewSkirt = true;
+/*
+                    if (face.TextureID == wearableCache[idx].TextureID && m_BakedTextureModule != null)
                     {
-                       cache.Cache(wearableCache[i].TextureAsset);
+                        if (wearableCache[idx].CacheId != cacheItems[i].CacheId)
+                        {
+                            wearableCache[idx].CacheId = cacheItems[i].CacheId;
+                            validDirtyBakes++;
+
+                            //assuming this can only happen if asset is in cache
+                        }
+                        hits++;
+                        continue;
+                    }
+*/
+                    wearableCache[idx].TextureAsset = null;
+                    if (cache != null)
+                    {
+                        AssetBase asb = null;
+                        cache.Get(face.TextureID.ToString(), out asb);
+                        wearableCache[idx].TextureAsset = asb;
+                    }
+
+                    if (wearableCache[idx].TextureAsset != null)
+                    {
+                        if ( wearableCache[idx].TextureID != face.TextureID ||
+                                wearableCache[idx].CacheId != cacheItems[i].CacheId)
+                            validDirtyBakes++;
+
+                        wearableCache[idx].TextureID = face.TextureID;
+                        wearableCache[idx].CacheId = cacheItems[i].CacheId;
+                        hits++;
+                    }
+                    else
+                    {
+                        wearableCache[idx].CacheId = UUID.Zero;
+                        wearableCache[idx].TextureID = UUID.Zero;
+                        wearableCache[idx].TextureAsset = null;
+                        missing.Add(face.TextureID);
+                        continue;
                     }
                 }
             }
-            /*
-             IBakedTextureModule bakedModule = m_scene.RequestModuleInterface<IBakedTextureModule>();
-            if (invService.GetRootFolder(userID) != null)
+
+            // handle optional skirt case
+            if(!haveNewSkirt && haveSkirt)
+            {
+                wearableCache[19].CacheId = UUID.Zero;
+                wearableCache[19].TextureID = UUID.Zero;
+                wearableCache[19].TextureAsset = null;
+                validDirtyBakes++;
+            }
+
+            sp.Appearance.WearableCacheItems = wearableCache;
+
+            if (missing.Count > 0)
             {
-                WearableCacheItem[] wearableCache = null;
-                if (bakedModule != null)
+                foreach (UUID id in missing)
+                    sp.ControllingClient.SendRebakeAvatarTextures(id);
+            }
+
+            if (validDirtyBakes > 0 && hits == cacheItems.Length)
+            {
+                // if we got a full set of baked textures save all in BakedTextureModule
+                if (m_BakedTextureModule != null)
                 {
-                    try
+                    m_log.DebugFormat("[UpdateBakedCache] Uploading to Bakes Server: cache hits: {0} changed entries: {1} rebakes {2}",
+                        hits.ToString(), validDirtyBakes.ToString(), missing.Count);
+
+                    m_BakedTextureModule.Store(sp.UUID, wearableCache);
+                }
+            }
+            else
+                m_log.DebugFormat("[UpdateBakedCache] cache hits: {0} changed entries: {1} rebakes {2}",
+                        hits.ToString(), validDirtyBakes.ToString(), missing.Count);
+
+            for (int iter = 0; iter < AvatarAppearance.BAKE_INDICES.Length; iter++)
+            {
+                int j = AvatarAppearance.BAKE_INDICES[iter];
+                sp.Appearance.WearableCacheItems[j].TextureAsset = null;
+//                m_log.Debug("[UpdateBCache] {" + iter + "/" +
+//                                    sp.Appearance.WearableCacheItems[j].TextureIndex + "}: c-" +
+//                                    sp.Appearance.WearableCacheItems[j].CacheId + ", t-" +
+//                                    sp.Appearance.WearableCacheItems[j].TextureID);
+            }
+
+            return (hits == cacheItems.Length);
+        }
+
+        // called when we get a new root avatar
+        public bool ValidateBakedTextureCache(IScenePresence sp)
+        {
+            int hits = 0;
+
+            if (((ScenePresence)sp).IsNPC)
+                return true;
+
+            lock (m_setAppearanceLock)
+            {
+                IAssetCache cache = m_scene.RequestModuleInterface<IAssetCache>();
+                IBakedTextureModule bakedModule = m_scene.RequestModuleInterface<IBakedTextureModule>();
+                WearableCacheItem[] bakedModuleCache = null;
+
+                if (cache == null)
+                    return false;
+
+                WearableCacheItem[] wearableCache = sp.Appearance.WearableCacheItems;
+
+                // big debug
+                //m_log.DebugFormat("[AVFACTORY]: ValidateBakedTextureCache start for {0} {1}", sp.Name, sp.UUID);
+/*
+                for (int iter = 0; iter < AvatarAppearance.BAKE_INDICES.Length; iter++)
+                {
+                    int j = AvatarAppearance.BAKE_INDICES[iter];
+                    Primitive.TextureEntryFace face = sp.Appearance.Texture.FaceTextures[j];
+                    if (wearableCache == null)
+                    {
+                        if (face != null)
+                            m_log.Debug("[ValidateBakedCache] {" + iter + "/" + j + " t- " + face.TextureID);
+                        else
+                            m_log.Debug("[ValidateBakedCache] {" + iter + "/" + j + " t- No texture");
+                    }
+                    else
+                    {
+                        if (face != null)
+                            m_log.Debug("[ValidateBakedCache] {" + iter + "/" + j + " ft- " + face.TextureID +
+                                   "}: cc-" +
+                                    wearableCache[j].CacheId + ", ct-" +
+                                    wearableCache[j].TextureID
+                                );
+                        else
+                            m_log.Debug("[ValidateBakedCache] {" + iter + "/" + j + " t - No texture" +
+                                    "}: cc-" +
+                                    wearableCache[j].CacheId + ", ct-" +
+                                    wearableCache[j].TextureID
+                                );
+                    }
+                }
+*/
+
+                bool wearableCacheValid = false;
+                if (wearableCache == null)
+                {
+                    wearableCache = WearableCacheItem.GetDefaultCacheItem();
+                }
+                else
+                {
+                    // we may have received a full cache
+                    // check same coerence and store
+                    wearableCacheValid = true;
+                    for (int i = 0; i < AvatarAppearance.BAKE_INDICES.Length; i++)
                     {
-                        wearableCache = bakedModule.Get(userID);
-                        appearance.WearableCacheItems = wearableCache;
-                        appearance.WearableCacheItemsDirty = false;
-                        foreach (WearableCacheItem item in wearableCache)
+                        int idx = AvatarAppearance.BAKE_INDICES[i];
+                        Primitive.TextureEntryFace face = sp.Appearance.Texture.FaceTextures[idx];
+                        if (face != null)
                         {
-                            appearance.Texture.FaceTextures[item.TextureIndex].TextureID = item.TextureID;
+                            if (face.TextureID == wearableCache[idx].TextureID &&
+                                face.TextureID != UUID.Zero)
+                            {
+                                if (wearableCache[idx].TextureAsset != null)
+                                {
+                                    hits++;
+                                    wearableCache[idx].TextureAsset.Temporary = true;
+                                    wearableCache[idx].TextureAsset.Local = true;
+                                    cache.Cache(wearableCache[idx].TextureAsset);
+                                    wearableCache[idx].TextureAsset = null;
+                                    continue;
+                                }
+                                
+                                if (cache.Check((wearableCache[idx].TextureID).ToString()))
+                                {
+                                    hits++;
+                                    continue;
+                                }
+                            }
+                            wearableCacheValid = false;
                         }
                     }
-                    catch (Exception)
+
+                    wearableCacheValid = (wearableCacheValid && (hits >= AvatarAppearance.BAKE_INDICES.Length - 1));
+                    if (wearableCacheValid)
                     {
-                        
+                        //m_log.Debug("[ValidateBakedCache] have valid local cache");
                     }
+                    else
+                        wearableCache[19].TextureAsset = null; // clear optional skirt
                 }
-             */
 
-            // Process the texture entry
-            for (int i = 0; i < AvatarAppearance.BAKE_INDICES.Length; i++)
-            {
-                int idx = AvatarAppearance.BAKE_INDICES[i];
-                Primitive.TextureEntryFace face = sp.Appearance.Texture.FaceTextures[idx];
+                bool checkExternal = false;
 
-                // No face, so lets check our baked service cache, teleport or login.
-                if (face == null)
+                if (!wearableCacheValid)
                 {
-                    if (wearableCache != null)
+                    hits = 0;
+                    // only use external bake module on login condition check
+//                    ScenePresence ssp = null;
+//                    if (sp is ScenePresence)
                     {
-                        // If we find the an appearance item, set it as the textureentry and the face
-                        WearableCacheItem searchitem = WearableCacheItem.SearchTextureIndex((uint) idx, wearableCache);
-                        if (searchitem != null)
-                        {
-                            sp.Appearance.Texture.FaceTextures[idx] = sp.Appearance.Texture.CreateFace((uint) idx);
-                            sp.Appearance.Texture.FaceTextures[idx].TextureID = searchitem.TextureID;
-                            face = sp.Appearance.Texture.FaceTextures[idx];
-                        }
-                        else
+//                        ssp = (ScenePresence)sp;
+//                        checkExternal = (((uint)ssp.TeleportFlags & (uint)TeleportFlags.ViaLogin) != 0) &&
+//                            bakedModule != null;
+
+                        // or do it anytime we dont have the cache
+                        checkExternal = bakedModule != null;
+                    }
+                }
+
+                if (checkExternal)
+                {
+                    bool gotbacked = false;
+
+                    m_log.Debug("[ValidateBakedCache] local cache invalid, checking bakedModule");
+                    try
+                    {
+                        bakedModuleCache = bakedModule.Get(sp.UUID);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat(e.ToString());
+                        bakedModuleCache = null;
+                    }
+
+                    if (bakedModuleCache != null)
+                    {
+                        //m_log.Debug("[ValidateBakedCache] got bakedModule " + bakedModuleCache.Length + " cached textures");
+
+                        for (int i = 0; i < bakedModuleCache.Length; i++)
                         {
-                            // if there is no texture entry and no baked cache, skip it
-                            continue;
+                            int j = (int)bakedModuleCache[i].TextureIndex;
+
+                            if (bakedModuleCache[i].TextureAsset != null)
+                            {
+                                wearableCache[j].TextureID = bakedModuleCache[i].TextureID;
+                                wearableCache[j].CacheId = bakedModuleCache[i].CacheId;
+                                wearableCache[j].TextureAsset = bakedModuleCache[i].TextureAsset;
+                                bakedModuleCache[i].TextureAsset.Temporary = true;
+                                bakedModuleCache[i].TextureAsset.Local = true;
+                                cache.Cache(bakedModuleCache[i].TextureAsset);
+                            }
                         }
+                        gotbacked = true;
                     }
-                    else
+
+                    if (gotbacked)
                     {
-                        //No texture entry face and no cache.  Skip this face.
-                        continue;
+                        // force the ones we got
+                        for (int i = 0; i < AvatarAppearance.BAKE_INDICES.Length; i++)
+                        {
+                            int idx = AvatarAppearance.BAKE_INDICES[i];
+                            if(wearableCache[idx].TextureAsset == null)
+                            {
+                                if(idx == 19)
+                                {
+                                    sp.Appearance.Texture.FaceTextures[idx] = null;
+                                    hits++;
+                                }
+                                continue;
+                            }
+
+                            Primitive.TextureEntryFace face = sp.Appearance.Texture.FaceTextures[idx];
+
+                            if (face == null)
+                            {
+                                face = sp.Appearance.Texture.CreateFace((uint)idx);
+                                sp.Appearance.Texture.FaceTextures[idx] = face;
+                            }
+
+                            face.TextureID = wearableCache[idx].TextureID;
+                            hits++;
+                            wearableCache[idx].TextureAsset = null;
+                        }
                     }
                 }
-                    
-//                m_log.DebugFormat(
-//                    "[AVFACTORY]: Looking for texture {0}, id {1} for {2} {3}",
-//                    face.TextureID, idx, client.Name, client.AgentId);
 
-                // if the texture is one of the "defaults" then skip it
-                // this should probably be more intelligent (skirt texture doesnt matter
-                // if the avatar isnt wearing a skirt) but if any of the main baked 
-                // textures is default then the rest should be as well
-                if (face.TextureID == UUID.Zero || face.TextureID == AppearanceManager.DEFAULT_AVATAR_TEXTURE)
-                    continue;
-                
-                defonly = false; // found a non-default texture reference
+                sp.Appearance.WearableCacheItems = wearableCache;
 
-                if (m_scene.AssetService.Get(face.TextureID.ToString()) == null)
-                    return false;
             }
 
-//            m_log.DebugFormat("[AVFACTORY]: Completed texture check for {0} {1}", sp.Name, sp.UUID);
-
-            // If we only found default textures, then the appearance is not cached
-            return (defonly ? false : true);
+            // debug
+            //m_log.DebugFormat("[ValidateBakedCache]: Completed texture check for {0} {1} with {2} hits", sp.Name, sp.UUID, hits);
+/*
+            for (int iter = 0; iter < AvatarAppearance.BAKE_INDICES.Length; iter++)
+            {
+                int j = AvatarAppearance.BAKE_INDICES[iter];
+                m_log.Debug("[ValidateBakedCache] {" + iter + "/" +
+                                    sp.Appearance.WearableCacheItems[j].TextureIndex + "}: c-" +
+                                    sp.Appearance.WearableCacheItems[j].CacheId + ", t-" +
+                                    sp.Appearance.WearableCacheItems[j].TextureID);
+            }
+*/
+            return (hits >= AvatarAppearance.BAKE_INDICES.Length - 1); // skirt is optional
         }
 
         public int RequestRebake(IScenePresence sp, bool missingTexturesOnly)
         {
+            if (((ScenePresence)sp).IsNPC)
+                return 0;
+
             int texturesRebaked = 0;
-//            IImprovedAssetCache cache = m_scene.RequestModuleInterface<IImprovedAssetCache>();
+            IAssetCache cache = m_scene.RequestModuleInterface<IAssetCache>();
 
             for (int i = 0; i < AvatarAppearance.BAKE_INDICES.Length; i++)
             {
@@ -497,31 +728,17 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
                 if (face == null)
                     continue;
 
-//                m_log.DebugFormat(
-//                    "[AVFACTORY]: Looking for texture {0}, id {1} for {2} {3}",
-//                    face.TextureID, idx, client.Name, client.AgentId);
-
-                // if the texture is one of the "defaults" then skip it
-                // this should probably be more intelligent (skirt texture doesnt matter
-                // if the avatar isnt wearing a skirt) but if any of the main baked
-                // textures is default then the rest should be as well
                 if (face.TextureID == UUID.Zero || face.TextureID == AppearanceManager.DEFAULT_AVATAR_TEXTURE)
                     continue;
 
                 if (missingTexturesOnly)
                 {
-                    if (m_scene.AssetService.Get(face.TextureID.ToString()) != null)
+                    if (cache != null &&  cache.Check(face.TextureID.ToString()))
                     {
                         continue;
                     }
                     else
                     {
-                        // On inter-simulator teleports, this occurs if baked textures are not being stored by the
-                        // grid asset service (which means that they are not available to the new region and so have
-                        // to be re-requested from the client).
-                        //
-                        // The only available core OpenSimulator behaviour right now
-                        // is not to store these textures, temporarily or otherwise.
                         m_log.DebugFormat(
                             "[AVFACTORY]: Missing baked texture {0} ({1}) for {2}, requesting rebake.",
                             face.TextureID, idx, sp.Name);
@@ -605,7 +822,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
                 foreach (KeyValuePair<UUID, long> kvp in saves)
                 {
                     // We have to load the key and value into local parameters to avoid a race condition if we loop
-                    // around and load kvp with a different value before FireAndForget has launched its thread.                    
+                    // around and load kvp with a different value before FireAndForget has launched its thread.
                     UUID avatarID = kvp.Key;
                     long sendTime = kvp.Value;
 
@@ -658,13 +875,13 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
 
             m_scene.AvatarService.SetAppearance(agentid, sp.Appearance);
 
-            // Trigger this here because it's the final step in the set/queue/save process for appearance setting. 
+            // Trigger this here because it's the final step in the set/queue/save process for appearance setting.
             // Everything has been updated and stored. Ensures bakes have been persisted (if option is set to persist bakes).
             m_scene.EventManager.TriggerAvatarAppearanceChanged(sp);
         }
 
         /// <summary>
-        /// For a given set of appearance items, check whether the items are valid and add their asset IDs to 
+        /// For a given set of appearance items, check whether the items are valid and add their asset IDs to
         /// appearance data.
         /// </summary>
         /// <param name='userID'></param>
@@ -675,25 +892,27 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
 
             if (invService.GetRootFolder(userID) != null)
             {
-                for (int i = 0; i < AvatarWearable.MAX_WEARABLES; i++)
+                for (int i = 0; i < appearance.Wearables.Length; i++)
                 {
                     for (int j = 0; j < appearance.Wearables[i].Count; j++)
                     {
                         if (appearance.Wearables[i][j].ItemID == UUID.Zero)
                         {
                             m_log.WarnFormat(
-                                "[AVFACTORY]: Wearable item {0}:{1} for user {2} unexpectedly UUID.Zero.  Ignoring.", 
+                                "[AVFACTORY]: Wearable item {0}:{1} for user {2} unexpectedly UUID.Zero.  Ignoring.",
                                 i, j, userID);
 
                             continue;
                         }
 
                         // Ignore ruth's assets
-                        if (appearance.Wearables[i][j].ItemID == AvatarWearable.DefaultWearables[i][0].ItemID)
-                            continue;
+                        if (i < AvatarWearable.DefaultWearables.Length)
+                        {
+                            if (appearance.Wearables[i][j].ItemID == AvatarWearable.DefaultWearables[i][0].ItemID)
+                                continue;
+                        }
 
-                        InventoryItemBase baseItem = new InventoryItemBase(appearance.Wearables[i][j].ItemID, userID);
-                        baseItem = invService.GetItem(baseItem);
+                        InventoryItemBase baseItem = invService.GetItem(userID, appearance.Wearables[i][j].ItemID);
 
                         if (baseItem != null)
                         {
@@ -754,7 +973,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
 //                                case WearableType.Skin:
 //                                //case WearableType.Underpants:
 //                                    TryAndRepairBrokenWearable((WearableType)i, invService, userID, appearance);
-//                            
+//
 //                                    m_log.WarnFormat("[AVFACTORY]: {0} Default Wearables, passing existing values.", (WearableType)i);
 //                                    resetwearable = true;
 //                                    break;
@@ -762,7 +981,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
 //                            }
 //                            continue;
 //                        }
-//                        
+//
 //                        InventoryItemBase baseItem = new InventoryItemBase(appearance.Wearables[i][j].ItemID, userID);
 //                        baseItem = invService.GetItem(baseItem);
 //
@@ -789,7 +1008,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
 //
 //                            TryAndRepairBrokenWearable((WearableType)i, invService, userID, appearance);
 //                            resetwearable = true;
-//                            
+//
 //                        }
 //                    }
 //                }
@@ -798,7 +1017,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
 //                if (appearance.Wearables[(int) WearableType.Eyes] == null)
 //                {
 //                    m_log.WarnFormat("[AVFACTORY]: {0} Eyes are Null, passing existing values.", (WearableType.Eyes));
-//                    
+//
 //                    TryAndRepairBrokenWearable(WearableType.Eyes, invService, userID, appearance);
 //                    resetwearable = true;
 //                }
@@ -902,85 +1121,45 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
             {
                 UUID newInvItem = UUID.Random();
                 InventoryItemBase itembase = new InventoryItemBase(newInvItem, userID)
-                                                 {
-                                                     AssetID =
-                                                         defaultwearable,
-                                                     AssetType
-                                                         =
-                                                         (int)
-                                                         FolderType
-                                                             .BodyPart,
-                                                     CreatorId
-                                                         =
-                                                         userID
-                                                         .ToString
-                                                         (),
-                                                     //InvType = (int)InventoryType.Wearable,
-
-                                                     Description
-                                                         =
-                                                         "Failed Wearable Replacement",
-                                                     Folder =
-                                                         invService
-                                                         .GetFolderForType
-                                                         (userID,
-                                                          FolderType
-                                                              .BodyPart)
-                                                         .ID,
-                                                     Flags = (uint) type,
-                                                     Name = Enum.GetName(typeof (WearableType), type),
-                                                     BasePermissions = (uint) PermissionMask.Copy,
-                                                     CurrentPermissions = (uint) PermissionMask.Copy,
-                                                     EveryOnePermissions = (uint) PermissionMask.Copy,
-                                                     GroupPermissions = (uint) PermissionMask.Copy,
-                                                     NextPermissions = (uint) PermissionMask.Copy
-                                                 };
+                            {
+                                AssetID = defaultwearable,
+                                AssetType = (int)FolderType.BodyPart,
+                                CreatorId = userID.ToString(),
+                                //InvType = (int)InventoryType.Wearable,
+                                Description = "Failed Wearable Replacement",
+                                Folder = invService.GetFolderForType(userID, FolderType.BodyPart).ID,
+                                Flags = (uint) type, Name = Enum.GetName(typeof (WearableType), type),
+                                BasePermissions = (uint) PermissionMask.Copy,
+                                CurrentPermissions = (uint) PermissionMask.Copy,
+                                EveryOnePermissions = (uint) PermissionMask.Copy,
+                                GroupPermissions = (uint) PermissionMask.Copy,
+                                NextPermissions = (uint) PermissionMask.Copy
+                            };
                 invService.AddItem(itembase);
                 UUID LinkInvItem = UUID.Random();
                 itembase = new InventoryItemBase(LinkInvItem, userID)
-                               {
-                                   AssetID =
-                                       newInvItem,
-                                   AssetType
-                                       =
-                                       (int)
-                                       AssetType
-                                           .Link,
-                                   CreatorId
-                                       =
-                                       userID
-                                       .ToString
-                                       (),
-                                   InvType = (int) InventoryType.Wearable,
-
-                                   Description
-                                       =
-                                       "Failed Wearable Replacement",
-                                   Folder =
-                                       invService
-                                       .GetFolderForType
-                                       (userID,
-                                        FolderType
-                                            .CurrentOutfit)
-                                       .ID,
-                                   Flags = (uint) type,
-                                   Name = Enum.GetName(typeof (WearableType), type),
-                                   BasePermissions = (uint) PermissionMask.Copy,
-                                   CurrentPermissions = (uint) PermissionMask.Copy,
-                                   EveryOnePermissions = (uint) PermissionMask.Copy,
-                                   GroupPermissions = (uint) PermissionMask.Copy,
-                                   NextPermissions = (uint) PermissionMask.Copy
-                               };
+                            {
+                                AssetID = newInvItem,
+                                AssetType = (int)AssetType.Link,
+                                CreatorId = userID.ToString(),
+                                InvType = (int) InventoryType.Wearable,
+                                Description = "Failed Wearable Replacement",
+                                Folder = invService.GetFolderForType(userID, FolderType.CurrentOutfit).ID,
+                                Flags = (uint) type,
+                                Name = Enum.GetName(typeof (WearableType), type),
+                                BasePermissions = (uint) PermissionMask.Copy,
+                                CurrentPermissions = (uint) PermissionMask.Copy,
+                                EveryOnePermissions = (uint) PermissionMask.Copy,
+                                GroupPermissions = (uint) PermissionMask.Copy,
+                                NextPermissions = (uint) PermissionMask.Copy
+                            };
                 invService.AddItem(itembase);
                 appearance.Wearables[(int)type] = new AvatarWearable(newInvItem, GetDefaultItem(type));
                 ScenePresence presence = null;
                 if (m_scene.TryGetScenePresence(userID, out presence))
                 {
                     m_scene.SendInventoryUpdate(presence.ControllingClient,
-                                                invService.GetFolderForType(userID,
-                                                                            FolderType
-                                                                                .CurrentOutfit),
-                                                false, true);
+                                invService.GetFolderForType(userID, FolderType.CurrentOutfit), false, true);
                 }
             }
         }
@@ -1040,7 +1219,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
                     m_log.WarnFormat("[AVFACTORY]: Client_OnRequestWearables unable to find presence for {0}", client.AgentId);
             }, null, "AvatarFactoryModule.OnClientRequestWearables");
         }
-        
+
         /// <summary>
         /// Set appearance data (texture asset IDs and slider settings) received from a client
         /// </summary>
@@ -1080,8 +1259,17 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
 
             foreach (AvatarWearingArgs.Wearable wear in e.NowWearing)
             {
-                if (wear.Type < AvatarWearable.MAX_WEARABLES)
-                    avatAppearance.Wearables[wear.Type].Add(wear.ItemID, UUID.Zero);
+                // If the wearable type is larger than the current array, expand it
+                if (avatAppearance.Wearables.Length <= wear.Type)
+                {
+                    int currentLength = avatAppearance.Wearables.Length;
+                    AvatarWearable[] wears = avatAppearance.Wearables;
+                    Array.Resize(ref wears, wear.Type + 1);
+                    for (int i = currentLength ; i <= wear.Type ; i++)
+                        wears[i] = new AvatarWearable();
+                    avatAppearance.Wearables = wears;
+                }
+                avatAppearance.Wearables[wear.Type].Add(wear.ItemID, UUID.Zero);
             }
 
             avatAppearance.GetAssetsFrom(sp.Appearance);
@@ -1117,12 +1305,12 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
             {
                 UUID texture = UUID.Zero;
                 int index = request.BakedTextureIndex;
-                
+
                 if (m_reusetextures)
                 {
                     // this is the most insanely dumb way to do this... however it seems to
                     // actually work. if the appearance has been reset because wearables have
-                    // changed then the texture entries are zero'd out until the bakes are 
+                    // changed then the texture entries are zero'd out until the bakes are
                     // uploaded. on login, if the textures exist in the cache (eg if you logged
                     // into the simulator recently, then the appearance will pull those and send
                     // them back in the packet and you won't have to rebake. if the textures aren't
@@ -1138,7 +1326,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
 
                     // m_log.WarnFormat("[AVFACTORY]: reuse texture {0} for index {1}",texture,index);
                 }
-                
+
                 CachedTextureResponseArg response = new CachedTextureResponseArg();
                 response.BakedTextureIndex = index;
                 response.BakedTextureID = texture;
@@ -1146,7 +1334,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
 
                 cachedTextureResponse.Add(response);
             }
-            
+
             // m_log.WarnFormat("[AVFACTORY]: serial is {0}",serial);
             // The serial number appears to be used to match requests and responses
             // in the texture transaction. We just send back the serial number