3 files changed, 74 insertions, 25 deletions

diff --git a/OpenSim/Framework/AvatarAppearance.cs b/OpenSim/Framework/AvatarAppearance.cs
index 5a6b265..716baab 100644
--- a/OpenSim/Framework/AvatarAppearance.cs
+++ b/OpenSim/Framework/AvatarAppearance.cs
@@ -196,6 +196,9 @@ namespace OpenSim.Framework
             if (appearance.VisualParams != null)
                 m_visualparams = (byte[])appearance.VisualParams.Clone();
 
+            m_avatarHeight = appearance.m_avatarHeight;
+            m_hipOffset = appearance.m_hipOffset;
+
             // Copy the attachment, force append mode since that ensures consistency
             m_attachments = new Dictionary<int, List<AvatarAttachment>>();
             foreach (AvatarAttachment attachment in appearance.GetAttachments())
@@ -237,7 +240,6 @@ namespace OpenSim.Framework
         {
             m_serial = 0;
 
-            SetDefaultParams();
             SetDefaultTexture();
             
             //for (int i = 0; i < BAKE_INDICES.Length; i++)
diff --git a/OpenSim/Region/CoreModules/Avatar/AvatarFactory/AvatarFactoryModule.cs b/OpenSim/Region/CoreModules/Avatar/AvatarFactory/AvatarFactoryModule.cs
index 75dbeb8..995a552 100644
--- a/OpenSim/Region/CoreModules/Avatar/AvatarFactory/AvatarFactoryModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/AvatarFactory/AvatarFactoryModule.cs
@@ -210,7 +210,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
                     changed = sp.Appearance.SetVisualParams(visualParams);
                     if (sp.Appearance.AvatarHeight > 0)
                         sp.SetHeight(sp.Appearance.AvatarHeight);
-                }
+                    }
 
                 // Process the baked texture array
                 if (textureEntry != null)
@@ -224,12 +224,12 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
                     // update transaction. In theory, we should be able to do an immediate
                     // appearance send and save here.
 
-                    // save only if there were changes, send no matter what (doesn't hurt to send twice)
-                    if (changed)
-                        QueueAppearanceSave(client.AgentId);
-
-                    QueueAppearanceSend(client.AgentId);
                 }
+                                // save only if there were changes, send no matter what (doesn't hurt to send twice)
+                                if (changed)
+                                        QueueAppearanceSave(client.AgentId);
+
+                                QueueAppearanceSend(client.AgentId);
             }
 
             // m_log.WarnFormat("[AVFACTORY]: complete SetAppearance for {0}:\n{1}",client.AgentId,sp.Appearance.ToString());
@@ -387,11 +387,11 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
             // m_log.WarnFormat("[AVFACTORY]: AvatarIsWearing called for {0}", client.AgentId);
 
             // we need to clean out the existing textures
-            sp.Appearance.ResetAppearance(); 
+            sp.Appearance.ResetAppearance();
 
-            // operate on a copy of the appearance so we don't have to lock anything
+            // operate on a copy of the appearance so we don't have to lock anything yet
             AvatarAppearance avatAppearance = new AvatarAppearance(sp.Appearance, false);
-            
+
             foreach (AvatarWearingArgs.Wearable wear in e.NowWearing)
             {
                 if (wear.Type < AvatarWearable.MAX_WEARABLES)
@@ -403,12 +403,19 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
             // This could take awhile since it needs to pull inventory
             SetAppearanceAssets(sp.UUID, ref avatAppearance);
 
-            // could get fancier with the locks here, but in the spirit of "last write wins"
-            // this should work correctly, also, we don't need to send the appearance here
-            // since the "iswearing" will trigger a new set of visual param and baked texture changes
-            // when those complete, the new appearance will be sent
-            sp.Appearance = avatAppearance;
-            QueueAppearanceSave(client.AgentId);
+            lock (m_setAppearanceLock)
+            {
+                // Update only those fields that we have changed. This is important because the viewer
+                // often sends AvatarIsWearing and SetAppearance packets at once, and AvatarIsWearing
+                // shouldn't overwrite the changes made in SetAppearance.
+                sp.Appearance.Wearables = avatAppearance.Wearables;
+                sp.Appearance.Texture = avatAppearance.Texture;
+
+                // We don't need to send the appearance here since the "iswearing" will trigger a new set
+                // of visual param and baked texture changes. When those complete, the new appearance will be sent
+
+                QueueAppearanceSave(client.AgentId);
+            }
         }
 
         private void SetAppearanceAssets(UUID userID, ref AvatarAppearance appearance)
diff --git a/OpenSim/Services/Connectors/Asset/AssetServiceConnector.cs b/OpenSim/Services/Connectors/Asset/AssetServiceConnector.cs
index f1da4fa..fdab254 100644
--- a/OpenSim/Services/Connectors/Asset/AssetServiceConnector.cs
+++ b/OpenSim/Services/Connectors/Asset/AssetServiceConnector.cs
@@ -48,6 +48,13 @@ namespace OpenSim.Services.Connectors
         private string m_ServerURI = String.Empty;
         private IImprovedAssetCache m_Cache = null;
 
+        private delegate void AssetRetrievedEx(AssetBase asset);
+
+        // Keeps track of concurrent requests for the same asset, so that it's only loaded once.
+        // Maps: Asset ID -> Handlers which will be called when the asset has been loaded
+        private Dictionary<string, AssetRetrievedEx> m_AssetHandlers = new Dictionary<string, AssetRetrievedEx>();
+
+
         public AssetServicesConnector()
         {
         }
@@ -178,23 +185,56 @@ namespace OpenSim.Services.Connectors
 
             if (asset == null)
             {
-                bool result = false;
-
-                AsynchronousRestObjectRequester.
-                        MakeRequest<int, AssetBase>("GET", uri, 0,
+                lock (m_AssetHandlers)
+                {
+                    AssetRetrievedEx handlerEx = new AssetRetrievedEx(delegate(AssetBase _asset) { handler(id, sender, _asset); });
+
+                    AssetRetrievedEx handlers;
+                    if (m_AssetHandlers.TryGetValue(id, out handlers))
+                    {
+                        // Someone else is already loading this asset. It will notify our handler when done.
+                        handlers += handlerEx;
+                        return true;
+                    }
+
+                    // Load the asset ourselves
+                    handlers += handlerEx;
+                    m_AssetHandlers.Add(id, handlers);
+                }
+
+                bool success = false;
+                try
+                {
+                    AsynchronousRestObjectRequester.MakeRequest<int, AssetBase>("GET", uri, 0,
                         delegate(AssetBase a)
                         {
                             if (m_Cache != null)
                                 m_Cache.Cache(a);
-                            handler(id, sender, a);
-                            result = true;
-                        });
 
-                return result;
+                            AssetRetrievedEx handlers;
+                            lock (m_AssetHandlers)
+                            {
+                                handlers = m_AssetHandlers[id];
+                                m_AssetHandlers.Remove(id);
+                            }
+                            handlers.Invoke(a);
+                        });
+                    
+                    success = true;
+                }
+                finally
+                {
+                    if (!success)
+                    {
+                        lock (m_AssetHandlers)
+                        {
+                            m_AssetHandlers.Remove(id);
+                        }
+                    }
+                }
             }
             else
             {
-                //Util.FireAndForget(delegate { handler(id, sender, asset); });
                 handler(id, sender, asset);
             }