1 files changed, 55 insertions, 26 deletions

diff --git a/OpenSim/Region/Framework/Scenes/UuidGatherer.cs b/OpenSim/Region/Framework/Scenes/UuidGatherer.cs
index d8309d8..67655d6 100644
--- a/OpenSim/Region/Framework/Scenes/UuidGatherer.cs
+++ b/OpenSim/Region/Framework/Scenes/UuidGatherer.cs
@@ -38,6 +38,7 @@ using OpenMetaverse.StructuredData;
 using OpenSim.Framework;
 using OpenSim.Region.Framework.Scenes.Serialization;
 using OpenSim.Services.Interfaces;
+using OpenSimAssetType = OpenSim.Framework.SLUtil.OpenSimAssetType;
 
 namespace OpenSim.Region.Framework.Scenes
 {
@@ -83,29 +84,33 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="assetUuid">The uuid of the asset for which to gather referenced assets</param>
         /// <param name="assetType">The type of the asset for the uuid given</param>
         /// <param name="assetUuids">The assets gathered</param>
-        public void GatherAssetUuids(UUID assetUuid, AssetType assetType, IDictionary<UUID, AssetType> assetUuids)
+        public void GatherAssetUuids(UUID assetUuid, sbyte assetType, IDictionary<UUID, sbyte> assetUuids)
         {
             try
             {               
                 assetUuids[assetUuid] = assetType;
     
-                if (AssetType.Bodypart == assetType || AssetType.Clothing == assetType)
+                if ((sbyte)AssetType.Bodypart == assetType || (sbyte)AssetType.Clothing == assetType)
                 {
                     GetWearableAssetUuids(assetUuid, assetUuids);
                 }
-                else if (AssetType.Gesture == assetType)
+                else if ((sbyte)AssetType.Gesture == assetType)
                 {
                     GetGestureAssetUuids(assetUuid, assetUuids);
                 }
-                else if (AssetType.Notecard == assetType)
+                else if ((sbyte)AssetType.Notecard == assetType)
                 {
                     GetTextEmbeddedAssetUuids(assetUuid, assetUuids);
                 }
-                else if (AssetType.LSLText == assetType)
+                else if ((sbyte)AssetType.LSLText == assetType)
                 {
                     GetTextEmbeddedAssetUuids(assetUuid, assetUuids);
                 }
-                else if (AssetType.Object == assetType)
+                else if ((sbyte)OpenSimAssetType.Material == assetType)
+                {
+                    GetMaterialAssetUuids(assetUuid, assetUuids);
+                }
+                else if ((sbyte)AssetType.Object == assetType)
                 {
                     GetSceneObjectAssetUuids(assetUuid, assetUuids);
                 }
@@ -132,7 +137,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// A dictionary which is populated with the asset UUIDs gathered and the type of that asset.
         /// For assets where the type is not clear (e.g. UUIDs extracted from LSL and notecards), the type is Unknown.
         /// </param>
-        public void GatherAssetUuids(SceneObjectGroup sceneObject, IDictionary<UUID, AssetType> assetUuids)
+        public void GatherAssetUuids(SceneObjectGroup sceneObject, IDictionary<UUID, sbyte> assetUuids)
         {
 //            m_log.DebugFormat(
 //                "[ASSET GATHERER]: Getting assets for object {0}, {1}", sceneObject.Name, sceneObject.UUID);
@@ -152,7 +157,7 @@ namespace OpenSim.Region.Framework.Scenes
                     {
                         // Get the prim's default texture.  This will be used for faces which don't have their own texture
                         if (textureEntry.DefaultTexture != null)
-                            assetUuids[textureEntry.DefaultTexture.TextureID] = AssetType.Texture;
+                            assetUuids[textureEntry.DefaultTexture.TextureID] = (sbyte)AssetType.Texture;
 
                         if (textureEntry.FaceTextures != null)
                         {
@@ -160,20 +165,20 @@ namespace OpenSim.Region.Framework.Scenes
                             foreach (Primitive.TextureEntryFace texture in textureEntry.FaceTextures)
                             {
                                 if (texture != null)
-                                    assetUuids[texture.TextureID] = AssetType.Texture;
+                                    assetUuids[texture.TextureID] = (sbyte)AssetType.Texture;
                             }
                         }
                     }
                     
                     // If the prim is a sculpt then preserve this information too
                     if (part.Shape.SculptTexture != UUID.Zero)
-                        assetUuids[part.Shape.SculptTexture] = AssetType.Texture;
+                        assetUuids[part.Shape.SculptTexture] = (sbyte)AssetType.Texture;
 
                     if (part.Shape.ProjectionTextureUUID != UUID.Zero)
-                        assetUuids[part.Shape.ProjectionTextureUUID] = AssetType.Texture;
+                        assetUuids[part.Shape.ProjectionTextureUUID] = (sbyte)AssetType.Texture;
 
                     if (part.CollisionSound != UUID.Zero)
-                        assetUuids[part.CollisionSound] = AssetType.Sound;
+                        assetUuids[part.CollisionSound] = (sbyte)AssetType.Sound;
 
                     if (part.ParticleSystem.Length > 0)
                     {
@@ -181,7 +186,7 @@ namespace OpenSim.Region.Framework.Scenes
                         {
                             Primitive.ParticleSystem ps = new Primitive.ParticleSystem(part.ParticleSystem, 0);
                             if (ps.Texture != UUID.Zero)
-                                assetUuids[ps.Texture] = AssetType.Texture;
+                                assetUuids[ps.Texture] = (sbyte)AssetType.Texture;
                         }
                         catch (Exception e)
                         {
@@ -201,7 +206,7 @@ namespace OpenSim.Region.Framework.Scenes
 //                            tii.Name, tii.Type, part.Name, part.UUID);
 
                         if (!assetUuids.ContainsKey(tii.AssetID))
-                            GatherAssetUuids(tii.AssetID, (AssetType)tii.Type, assetUuids);
+                            GatherAssetUuids(tii.AssetID, (sbyte)tii.Type, assetUuids);
                     }
 
                     // FIXME: We need to make gathering modular but we cannot yet, since gatherers are not guaranteed
@@ -210,7 +215,9 @@ namespace OpenSim.Region.Framework.Scenes
                     // Scene.EventManager is present.
 //                    part.ParentGroup.Scene.EventManager.TriggerGatherUuids(part, assetUuids);
 
-                    GatherMaterialsUuids(part, assetUuids);
+
+                    // still needed to retrieve textures used as materials for any parts containing legacy materials stored in DynAttrs
+                    GatherMaterialsUuids(part, assetUuids); 
                 }
                 catch (Exception e)
                 {
@@ -221,7 +228,7 @@ namespace OpenSim.Region.Framework.Scenes
                 }
             }
         }
-        
+
 //        /// <summary>
 //        /// The callback made when we request the asset for an object from the asset service.
 //        /// </summary>
@@ -237,10 +244,12 @@ namespace OpenSim.Region.Framework.Scenes
 
         /// <summary>
         /// Gather all of the texture asset UUIDs used to reference "Materials" such as normal and specular maps
+        /// stored in legacy format in part.DynAttrs
         /// </summary>
         /// <param name="part"></param>
         /// <param name="assetUuids"></param>
-        public void GatherMaterialsUuids(SceneObjectPart part, IDictionary<UUID, AssetType> assetUuids)
+        //public void GatherMaterialsUuids(SceneObjectPart part, IDictionary<UUID, AssetType> assetUuids)
+        public void GatherMaterialsUuids(SceneObjectPart part, IDictionary<UUID, sbyte> assetUuids)
         {
             // scan thru the dynAttrs map of this part for any textures used as materials
             OSD osdMaterials = null;
@@ -276,7 +285,7 @@ namespace OpenSim.Region.Framework.Scenes
                                         UUID normalMapId = mat["NormMap"].AsUUID();
                                         if (normalMapId != UUID.Zero)
                                         {
-                                            assetUuids[normalMapId] = AssetType.Texture;
+                                            assetUuids[normalMapId] = (sbyte)AssetType.Texture;
                                             //m_log.Info("[UUID Gatherer]: found normal map ID: " + normalMapId.ToString());
                                         }
                                     }
@@ -285,7 +294,7 @@ namespace OpenSim.Region.Framework.Scenes
                                         UUID specularMapId = mat["SpecMap"].AsUUID();
                                         if (specularMapId != UUID.Zero)
                                         {
-                                            assetUuids[specularMapId] = AssetType.Texture;
+                                            assetUuids[specularMapId] = (sbyte)AssetType.Texture;
                                             //m_log.Info("[UUID Gatherer]: found specular map ID: " + specularMapId.ToString());
                                         }
                                     }
@@ -340,7 +349,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <param name="scriptUuid"></param>
         /// <param name="assetUuids">Dictionary in which to record the references</param>
-        private void GetTextEmbeddedAssetUuids(UUID embeddingAssetId, IDictionary<UUID, AssetType> assetUuids)
+        private void GetTextEmbeddedAssetUuids(UUID embeddingAssetId, IDictionary<UUID, sbyte> assetUuids)
         {
 //            m_log.DebugFormat("[ASSET GATHERER]: Getting assets for uuid references in asset {0}", embeddingAssetId);
 
@@ -360,7 +369,7 @@ namespace OpenSim.Region.Framework.Scenes
 
                     // Embedded asset references (if not false positives) could be for many types of asset, so we will
                     // label these as unknown.
-                    assetUuids[uuid] = AssetType.Unknown;
+                    assetUuids[uuid] = (sbyte)AssetType.Unknown;
                 }
             }
         }
@@ -370,7 +379,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <param name="wearableAssetUuid"></param>
         /// <param name="assetUuids">Dictionary in which to record the references</param>
-        private void GetWearableAssetUuids(UUID wearableAssetUuid, IDictionary<UUID, AssetType> assetUuids)
+        private void GetWearableAssetUuids(UUID wearableAssetUuid, IDictionary<UUID, sbyte> assetUuids)
         {
             AssetBase assetBase = GetAsset(wearableAssetUuid);
 
@@ -385,7 +394,7 @@ namespace OpenSim.Region.Framework.Scenes
     
                 foreach (UUID uuid in wearableAsset.Textures.Values)
                 {
-                    assetUuids[uuid] = AssetType.Texture;
+                    assetUuids[uuid] = (sbyte)AssetType.Texture;
                 }
             }
         }
@@ -397,7 +406,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <param name="sceneObject"></param>
         /// <param name="assetUuids"></param>
-        private void GetSceneObjectAssetUuids(UUID sceneObjectUuid, IDictionary<UUID, AssetType> assetUuids)
+        private void GetSceneObjectAssetUuids(UUID sceneObjectUuid, IDictionary<UUID, sbyte> assetUuids)
         {
             AssetBase objectAsset = GetAsset(sceneObjectUuid);
 
@@ -426,7 +435,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <param name="gestureUuid"></param>
         /// <param name="assetUuids"></param>
-        private void GetGestureAssetUuids(UUID gestureUuid, IDictionary<UUID, AssetType> assetUuids)
+        private void GetGestureAssetUuids(UUID gestureUuid, IDictionary<UUID, sbyte> assetUuids)
         {
             AssetBase assetBase = GetAsset(gestureUuid);
             if (null == assetBase)
@@ -460,9 +469,29 @@ namespace OpenSim.Region.Framework.Scenes
                 // If it can be parsed as a UUID, it is an asset ID
                 UUID uuid;
                 if (UUID.TryParse(id, out uuid))
-                    assetUuids[uuid] = AssetType.Animation;
+                    assetUuids[uuid] = (sbyte)AssetType.Animation;
             }
         }
+
+        /// <summary>
+        /// Get the asset uuid's referenced in a material.
+        /// </summary>
+        private void GetMaterialAssetUuids(UUID materialUuid, IDictionary<UUID, sbyte> assetUuids)
+        {
+            AssetBase assetBase = GetAsset(materialUuid);
+            if (null == assetBase)
+                return;
+
+            OSDMap mat = (OSDMap)OSDParser.DeserializeLLSDXml(assetBase.Data);
+
+            UUID normMap = mat["NormMap"].AsUUID();
+            if (normMap != UUID.Zero)
+                assetUuids[normMap] = (sbyte)AssetType.Texture;
+
+            UUID specMap = mat["SpecMap"].AsUUID();
+            if (specMap != UUID.Zero)
+                assetUuids[specMap] = (sbyte)AssetType.Texture;
+        }
     }
 
     public class HGUuidGatherer : UuidGatherer