* This finishes the implementation of AgentCachedTexture. Requires the XBakes Module and service for full functionality. Previous no-cache functionality works without the service and module. In some ways, I would have been happier not putting an AssetBase in WearableCacheItem.. but turns out it was probably unavoidable. No additional locks, yay.

2 files changed, 230 insertions, 20 deletions

diff --git a/OpenSim/Region/ClientStack/Linden/Caps/UploadBakedTextureModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/UploadBakedTextureModule.cs
index 3b0ccd7..6778ba5 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/UploadBakedTextureModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/UploadBakedTextureModule.cs
@@ -27,6 +27,7 @@
 
 using System;
 using System.Collections;
+using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.Drawing;
 using System.Drawing.Imaging;
@@ -53,8 +54,8 @@ namespace OpenSim.Region.ClientStack.Linden
     [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "UploadBakedTextureModule")]
     public class UploadBakedTextureModule : INonSharedRegionModule
     {
-//        private static readonly ILog m_log =
-//            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+       private static readonly ILog m_log =
+            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         /// <summary>
         /// For historical reasons this is fixed, but there
@@ -64,31 +65,154 @@ namespace OpenSim.Region.ClientStack.Linden
         private Scene m_scene;
         private bool m_persistBakedTextures;
 
+        private IBakedTextureModule m_BakedTextureModule;
+
         public void Initialise(IConfigSource source)
         {
             IConfig appearanceConfig = source.Configs["Appearance"];
             if (appearanceConfig != null)
                 m_persistBakedTextures = appearanceConfig.GetBoolean("PersistBakedTextures", m_persistBakedTextures);
+
+
         }
 
         public void AddRegion(Scene s)
         {
             m_scene = s;
+           
         }
 
         public void RemoveRegion(Scene s)
         {
+            s.EventManager.OnRegisterCaps -= RegisterCaps;
+            s.EventManager.OnNewPresence -= RegisterNewPresence;
+            s.EventManager.OnRemovePresence -= DeRegisterPresence;
+            m_BakedTextureModule = null;
+            m_scene = null;
         }
 
+       
+
         public void RegionLoaded(Scene s)
         {
             m_scene.EventManager.OnRegisterCaps += RegisterCaps;
+            m_scene.EventManager.OnNewPresence += RegisterNewPresence;
+            m_scene.EventManager.OnRemovePresence += DeRegisterPresence;
+            
+        }
+
+        private void DeRegisterPresence(UUID agentId)
+        {
+            ScenePresence presence = null;
+            if (m_scene.TryGetScenePresence(agentId, out presence))
+            {
+                presence.ControllingClient.OnSetAppearance -= CaptureAppearanceSettings;
+            }
+
+        }
+
+        private void RegisterNewPresence(ScenePresence presence)
+        {
+           presence.ControllingClient.OnSetAppearance += CaptureAppearanceSettings;
+
+        }
+
+        private void CaptureAppearanceSettings(IClientAPI remoteClient, Primitive.TextureEntry textureEntry, byte[] visualParams, Vector3 avSize, WearableCacheItem[] cacheItems)
+        {
+            m_BakedTextureModule = m_scene.RequestModuleInterface<IBakedTextureModule>();
+            if (cacheItems.Length > 0)
+            {
+                m_log.Info("[Cacheitems]: " + cacheItems.Length);
+                for (int iter = 0; iter < cacheItems.Length; iter++)
+                {
+                    m_log.Info("[Cacheitems] {" + iter + "/" + cacheItems[iter].TextureIndex + "}: c-" + cacheItems[iter].CacheId + ", t-" +
+                                      cacheItems[iter].TextureID);
+                }
+               
+                ScenePresence p = null;
+                if (m_scene.TryGetScenePresence(remoteClient.AgentId, out p))
+                {
+
+                        WearableCacheItem[] existingitems = p.Appearance.WearableCacheItems;
+                        if (existingitems == null)
+                        {
+                            if (m_BakedTextureModule != null)
+                            {
+                                WearableCacheItem[] savedcache = null;
+                                try
+                                {
+                                    if (p.Appearance.WearableCacheItemsDirty)
+                                    {
+                                        savedcache = m_BakedTextureModule.Get(p.UUID);
+                                        p.Appearance.WearableCacheItems = savedcache;
+                                        p.Appearance.WearableCacheItemsDirty = false;
+                                    }
+
+                                }
+                                catch (InvalidOperationException)
+                                {
+                                }
+
+                                if (savedcache != null)
+                                    existingitems = savedcache;
+                            }
+                        }
+                        // Existing items null means it's a fully new appearance
+                        if (existingitems == null)
+                        {
+
+                            for (int iter = 0; iter < cacheItems.Length; iter++)
+                            {
+
+                                cacheItems[iter].TextureID = textureEntry.FaceTextures[cacheItems[iter].TextureIndex].TextureID;
+                                if (m_scene.AssetService != null)
+                                    cacheItems[iter].TextureAsset = m_scene.AssetService.GetCached(cacheItems[iter].TextureID.ToString());
+                                
+
+                            }
+                        }
+                        else  
+                         
+                            
+                        {
+                            // for each uploaded baked texture
+                            for (int i = 0; i < cacheItems.Length; i++)
+                            {
+                                cacheItems[i].TextureID =
+                                    textureEntry.FaceTextures[cacheItems[i].TextureIndex].TextureID;
+                            }
+                            
+                            for (int i = 0; i < cacheItems.Length; i++)
+                            {
+                                if (cacheItems[i].TextureAsset == null)
+                                {
+                                    cacheItems[i].TextureAsset = m_scene.AssetService.GetCached(cacheItems[i].TextureID.ToString());
+                                }
+                            }
+                        }
+
+                   
+
+                    p.Appearance.WearableCacheItems = cacheItems;
+                    
+                   
+
+                    if (m_BakedTextureModule != null)
+                    {
+                        m_BakedTextureModule.Store(remoteClient.AgentId, cacheItems);
+                        p.Appearance.WearableCacheItemsDirty = true;
+                        
+                    }
+                }
+            }
         }
 
         public void PostInitialise()
         {
         }
 
+
+
         public void Close() { }
 
         public string Name { get { return "UploadBakedTextureModule"; } }
@@ -100,15 +224,23 @@ namespace OpenSim.Region.ClientStack.Linden
 
         public void RegisterCaps(UUID agentID, Caps caps)
         {
+            UploadBakedTextureHandler avatarhandler = new UploadBakedTextureHandler(
+                caps, m_scene.AssetService, m_persistBakedTextures);
+
+           
+            
             caps.RegisterHandler(
                 "UploadBakedTexture",
                 new RestStreamHandler(
                     "POST",
                     "/CAPS/" + caps.CapsObjectPath + m_uploadBakedTexturePath,
-                    new UploadBakedTextureHandler(
-                        caps, m_scene.AssetService, m_persistBakedTextures).UploadBakedTexture,
+                    avatarhandler.UploadBakedTexture,
                     "UploadBakedTexture",
                     agentID.ToString()));
+
+           
+            
+
         }
     }
 }
\ No newline at end of file
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
index d18b026..9e39699 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
@@ -3629,7 +3629,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             avp.Sender.IsTrial = false;
             avp.Sender.ID = agentID;
-            //m_log.DebugFormat("[CLIENT]: Sending appearance for {0} to {1}", agentID.ToString(), AgentId.ToString());
+            m_log.DebugFormat("[CLIENT]: Sending appearance for {0} to {1}", agentID.ToString(), AgentId.ToString());
             OutPacket(avp, ThrottleOutPacketType.State);
         }
 
@@ -11725,32 +11725,110 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            // var item = fac.GetBakedTextureFaces(AgentId);
             //WearableCacheItem[] items = fac.GetCachedItems(AgentId);
 
-            IImprovedAssetCache cache = m_scene.RequestModuleInterface<IImprovedAssetCache>();
-            if (cache == null)
+            IAssetService cache = m_scene.AssetService;
+            IBakedTextureModule bakedTextureModule = m_scene.RequestModuleInterface<IBakedTextureModule>();
+            if (bakedTextureModule != null && cache != null)
             {
-                for (int i = 0; i < cachedtex.WearableData.Length; i++)
+                // We need to make sure the asset stored in the bake is available on this server also by it's assetid before we map it to a Cacheid
+
+                WearableCacheItem[] cacheItems = null;
+                ScenePresence p = m_scene.GetScenePresence(AgentId);
+                if (p.Appearance != null)
+                    if (p.Appearance.WearableCacheItems == null || p.Appearance.WearableCacheItemsDirty)
+                    {
+                        try
+                        {
+                            cacheItems = bakedTextureModule.Get(AgentId);
+                            p.Appearance.WearableCacheItems = cacheItems;
+                            p.Appearance.WearableCacheItemsDirty = false;
+                        }
+                        catch (InvalidOperationException)
+                        {
+                            cacheItems = null;
+                        }
+                    }
+                    else if (p.Appearance.WearableCacheItems != null)
+                    {
+                        cacheItems = p.Appearance.WearableCacheItems;
+                    }
+
+                if (cache != null && cacheItems != null)
+                {
+                    foreach (WearableCacheItem item in cacheItems)
+                    {
+                       
+                        if (cache.GetCached(item.TextureID.ToString()) == null)
+                        {
+                            item.TextureAsset.Temporary = true;
+                            cache.Store(item.TextureAsset);
+                        }
+
+
+                    }
+                }
+                if (cacheItems != null)
+                {
+                   
+                    for (int i = 0; i < cachedtex.WearableData.Length; i++)
+                    {
+                        WearableCacheItem item =
+                            WearableCacheItem.SearchTextureIndex(cachedtex.WearableData[i].TextureIndex,cacheItems);
+
+                        cachedresp.WearableData[i] = new AgentCachedTextureResponsePacket.WearableDataBlock();
+                        cachedresp.WearableData[i].TextureIndex= cachedtex.WearableData[i].TextureIndex;
+                        cachedresp.WearableData[i].HostName = new byte[0];
+                        if (item != null)
+                        {
+                            cachedresp.WearableData[i].TextureID = item.TextureID;
+                        }
+                        else
+                        {
+                            cachedresp.WearableData[i].TextureID = UUID.Zero;
+                        }
+                    }
+                }
+                else
                 {
-                    cachedresp.WearableData[i] = new AgentCachedTextureResponsePacket.WearableDataBlock();
-                    cachedresp.WearableData[i].TextureIndex = cachedtex.WearableData[i].TextureIndex;
-                    cachedresp.WearableData[i].TextureID = UUID.Zero; //UUID.Parse("8334fb6e-c2f5-46ee-807d-a435f61a8d46");
-                    cachedresp.WearableData[i].HostName = new byte[0];
+                    for (int i = 0; i < cachedtex.WearableData.Length; i++)
+                    {
+                        cachedresp.WearableData[i] = new AgentCachedTextureResponsePacket.WearableDataBlock();
+                        cachedresp.WearableData[i].TextureIndex = cachedtex.WearableData[i].TextureIndex;
+                        cachedresp.WearableData[i].TextureID = UUID.Zero;
+                        //UUID.Parse("8334fb6e-c2f5-46ee-807d-a435f61a8d46");
+                        cachedresp.WearableData[i].HostName = new byte[0];
+                    }
                 }
             }
             else
             {
-                for (int i = 0; i < cachedtex.WearableData.Length; i++)
+                if (cache == null)
+                {
+                    for (int i = 0; i < cachedtex.WearableData.Length; i++)
+                    {
+                        cachedresp.WearableData[i] = new AgentCachedTextureResponsePacket.WearableDataBlock();
+                        cachedresp.WearableData[i].TextureIndex = cachedtex.WearableData[i].TextureIndex;
+                        cachedresp.WearableData[i].TextureID = UUID.Zero;
+                            //UUID.Parse("8334fb6e-c2f5-46ee-807d-a435f61a8d46");
+                        cachedresp.WearableData[i].HostName = new byte[0];
+                    }
+                }
+                else
                 {
-                    cachedresp.WearableData[i] = new AgentCachedTextureResponsePacket.WearableDataBlock();
-                    cachedresp.WearableData[i].TextureIndex = cachedtex.WearableData[i].TextureIndex;
+                    for (int i = 0; i < cachedtex.WearableData.Length; i++)
+                    {
+                        cachedresp.WearableData[i] = new AgentCachedTextureResponsePacket.WearableDataBlock();
+                        cachedresp.WearableData[i].TextureIndex = cachedtex.WearableData[i].TextureIndex;
 
 
 
-                    if (cache.Check(cachedtex.WearableData[i].ID.ToString()))
-                        cachedresp.WearableData[i].TextureID = UUID.Zero;
+                        if (cache.GetCached(cachedresp.WearableData[i].TextureID.ToString()) == null)
+                            cachedresp.WearableData[i].TextureID = UUID.Zero;
                             //UUID.Parse("8334fb6e-c2f5-46ee-807d-a435f61a8d46");
-                    else
-                        cachedresp.WearableData[i].TextureID = UUID.Zero; // UUID.Parse("8334fb6e-c2f5-46ee-807d-a435f61a8d46");
-                    cachedresp.WearableData[i].HostName = new byte[0];
+                        else
+                            cachedresp.WearableData[i].TextureID = UUID.Zero;
+                                // UUID.Parse("8334fb6e-c2f5-46ee-807d-a435f61a8d46");
+                        cachedresp.WearableData[i].HostName = new byte[0];
+                    }
                 }
             }
             cachedresp.Header.Zerocoded = true;