* 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, 129 insertions, 3 deletions

diff --git a/OpenSim/Framework/AvatarAppearance.cs b/OpenSim/Framework/AvatarAppearance.cs
index 4df4fb6..ffc3527 100644
--- a/OpenSim/Framework/AvatarAppearance.cs
+++ b/OpenSim/Framework/AvatarAppearance.cs
@@ -66,7 +66,9 @@ namespace OpenSim.Framework
         protected Vector3 m_avatarBoxSize = new Vector3(0.45f, 0.6f, 1.9f);
         protected float m_avatarFeetOffset = 0;
         protected float m_avatarAnimOffset = 0;
-        protected WearableCacheItem[] cacheitems;
+        protected WearableCacheItem[] m_cacheitems;
+        protected bool m_cacheItemsDirty = true;
+
         public virtual int Serial
         {
             get { return m_serial; }
@@ -118,8 +120,14 @@ namespace OpenSim.Framework
         
         public virtual WearableCacheItem[] WearableCacheItems
         {
-            get { return cacheitems; }
-            set { cacheitems = value; }
+            get { return m_cacheitems; }
+            set { m_cacheitems = value; }
+        }
+
+        public virtual bool WearableCacheItemsDirty
+        {
+            get { return m_cacheItemsDirty; }
+            set { m_cacheItemsDirty = value; }
         }
 
         public AvatarAppearance()
diff --git a/OpenSim/Framework/WearableCacheItem.cs b/OpenSim/Framework/WearableCacheItem.cs
index 83b1346..1aecf79 100644
--- a/OpenSim/Framework/WearableCacheItem.cs
+++ b/OpenSim/Framework/WearableCacheItem.cs
@@ -26,14 +26,132 @@
  */
 
 using System;
+using System.Collections.Generic;
 using OpenMetaverse;
+using OpenMetaverse.StructuredData;
 
 namespace OpenSim.Framework
 {
+    [Serializable]
     public class WearableCacheItem
     {
         public uint TextureIndex { get; set; }
         public UUID CacheId { get; set; }
         public UUID TextureID { get; set; }
+        public AssetBase TextureAsset { get; set; }
+
+
+        public static WearableCacheItem[] GetDefaultCacheItem()
+        {
+            int itemmax = 21;
+            WearableCacheItem[] retitems = new WearableCacheItem[itemmax];
+            for (uint i=0;i<itemmax;i++)
+                retitems[i] = new WearableCacheItem() {CacheId = UUID.Zero, TextureID = UUID.Zero, TextureIndex = i + 1};
+            return retitems;
+        }
+        public static WearableCacheItem[] FromOSD(OSD pInput, IImprovedAssetCache dataCache)
+        {
+            List<WearableCacheItem> ret = new List<WearableCacheItem>();
+            if (pInput.Type == OSDType.Array)
+            {
+                OSDArray itemarray = (OSDArray) pInput;
+                foreach (OSDMap item in itemarray)
+                {
+                    ret.Add(new WearableCacheItem()
+                                {
+                                    TextureIndex = item["textureindex"].AsUInteger(),
+                                    CacheId = item["cacheid"].AsUUID(),
+                                    TextureID = item["textureid"].AsUUID()
+                                });
+                    
+                    if (dataCache != null && item.ContainsKey("assetdata"))
+                    {
+                        AssetBase asset = new AssetBase(item["textureid"].AsUUID(),"BakedTexture",(sbyte)AssetType.Texture,UUID.Zero.ToString());
+                        asset.Temporary = true;
+                        asset.Data = item["assetdata"].AsBinary();
+                        dataCache.Cache(asset);
+                    }
+                }
+            }
+            else if (pInput.Type == OSDType.Map)
+            {
+                OSDMap item = (OSDMap) pInput;
+                ret.Add(new WearableCacheItem(){
+                                    TextureIndex = item["textureindex"].AsUInteger(),
+                                    CacheId = item["cacheid"].AsUUID(),
+                                    TextureID = item["textureid"].AsUUID()
+                                });
+                if (dataCache != null && item.ContainsKey("assetdata"))
+                {
+                    string assetCreator = item["assetcreator"].AsString();
+                    string assetName = item["assetname"].AsString();
+                    AssetBase asset = new AssetBase(item["textureid"].AsUUID(), assetName, (sbyte)AssetType.Texture, assetCreator);
+                    asset.Temporary = true;
+                    asset.Data = item["assetdata"].AsBinary();
+                    dataCache.Cache(asset);
+                }
+            }
+            else
+            {
+                return new WearableCacheItem[0];
+            }
+            return ret.ToArray();
+
+        }
+        public static OSD ToOSD(WearableCacheItem[] pcacheItems, IImprovedAssetCache dataCache)
+        {
+            OSDArray arr = new OSDArray();
+            foreach (WearableCacheItem item in pcacheItems)
+            {
+                OSDMap itemmap = new OSDMap();
+                itemmap.Add("textureindex", OSD.FromUInteger(item.TextureIndex));
+                itemmap.Add("cacheid", OSD.FromUUID(item.CacheId));
+                itemmap.Add("textureid", OSD.FromUUID(item.TextureID));
+                if (dataCache != null)
+                {
+                    if (dataCache.Check(item.TextureID.ToString()))
+                    {
+                        AssetBase assetItem = dataCache.Get(item.TextureID.ToString());
+                        if (assetItem != null)
+                        {
+                            itemmap.Add("assetdata", OSD.FromBinary(assetItem.Data));
+                            itemmap.Add("assetcreator", OSD.FromString(assetItem.CreatorID));
+                            itemmap.Add("assetname", OSD.FromString(assetItem.Name));
+                        }
+                    }
+                }
+                arr.Add(itemmap);
+            }
+            return arr;
+        }
+        public static WearableCacheItem SearchTextureIndex(uint pTextureIndex,WearableCacheItem[] pcacheItems)
+        {
+            for (int i = 0; i < pcacheItems.Length; i++)
+            {
+                if (pcacheItems[i].TextureIndex == pTextureIndex)
+                    return pcacheItems[i];
+            }
+            return null;
+        }
+        public static WearableCacheItem SearchTextureCacheId(UUID pCacheId, WearableCacheItem[] pcacheItems)
+        {
+            for (int i = 0; i < pcacheItems.Length; i++)
+            {
+                if (pcacheItems[i].CacheId == pCacheId)
+                    return pcacheItems[i];
+            }
+            return null;
+        }
+        public static WearableCacheItem SearchTextureTextureId(UUID pTextureId, WearableCacheItem[] pcacheItems)
+        {
+            for (int i = 0; i < pcacheItems.Length; i++)
+            {
+                if (pcacheItems[i].TextureID == pTextureId)
+                    return pcacheItems[i];
+            }
+            return null;
+        }
     }
+
+
 }