/// <summary>
/// Gather all the asset uuids associated with a given object.
/// </summary>
///
/// This includes both those directly associated with
/// it (e.g. face textures) and recursively, those of items within it's inventory (e.g. objects contained
/// within this object).
///
/// <param name="sceneObject">The scene object for which to gather assets</param>
/// <param name="assetUuids">The assets gathered</param>
public void GatherAssetUuids(SceneObjectGroup sceneObject, IDictionary <UUID, int> assetUuids)
{
// m_log.DebugFormat(
// "[ASSET GATHERER]: Getting assets for object {0}, {1}", sceneObject.Name, sceneObject.UUID);
foreach (SceneObjectPart part in sceneObject.GetParts())
{
//m_log.DebugFormat(
// "[ARCHIVER]: Getting part {0}, {1} for object {2}", part.Name, part.UUID, sceneObject.UUID);
try
{
Primitive.TextureEntry textureEntry = part.Shape.Textures;
// Get the prim's default texture. This will be used for faces which don't have their own texture
assetUuids[textureEntry.DefaultTexture.TextureID] = 1;
// XXX: Not a great way to iterate through face textures, but there's no
// other method available to tell how many faces there actually are
//int i = 0;
foreach (Primitive.TextureEntryFace texture in textureEntry.FaceTextures)
{
if (texture != null)
{
//m_log.DebugFormat("[ARCHIVER]: Got face {0}", i++);
assetUuids[texture.TextureID] = 1;
}
}
// If the prim is a sculpt then preserve this information too
if (part.Shape.SculptTexture != UUID.Zero)
{
assetUuids[part.Shape.SculptTexture] = 1;
}
TaskInventoryDictionary taskDictionary = (TaskInventoryDictionary)part.TaskInventory.Clone();
// Now analyze this prim's inventory items to preserve all the uuids that they reference
foreach (TaskInventoryItem tii in taskDictionary.Values)
{
//m_log.DebugFormat("[ARCHIVER]: Analysing item asset type {0}", tii.Type);
if (!assetUuids.ContainsKey(tii.AssetID))
{
GatherAssetUuids(tii.AssetID, (AssetType)tii.Type, assetUuids);
}
}
}
catch (Exception e)
{
m_log.ErrorFormat("[UUID GATHERER]: Failed to get part - {0}", e);
m_log.DebugFormat(
"[UUID GATHERER]: Texture entry length for prim was {0} (min is 46)",
part.Shape.TextureEntry.Length);
}
}
}
private void SniffTaskInventoryUUIDs(Dictionary <UUID, bool> uuids, SceneObjectGroup sog)
{
TaskInventoryDictionary tinv = sog.RootPart.TaskInventory;
lock (tinv)
{
foreach (TaskInventoryItem titem in tinv.Values)
{
uuids.Add(titem.AssetID, (InventoryType)titem.Type == InventoryType.Texture);
}
}
}
public static string SerializeTaskInventory(TaskInventoryDictionary inventory, Scene scene)
{
string serializedTaskInventory;
using (StringWriter sw = new StringWriter())
{
using (XmlTextWriter writer = new XmlTextWriter(sw))
{
SceneObjectSerializer.WriteTaskInventory(writer, inventory, new Dictionary <string, object>(), scene);
}
serializedTaskInventory = sw.ToString();
}
return(serializedTaskInventory);
}
public LSL_Key llRequestInventoryData(string name)
{
if (!ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL", m_itemID))
{
return("");
}
TaskInventoryDictionary itemDictionary = (TaskInventoryDictionary)m_host.TaskInventory.Clone();
foreach (TaskInventoryItem item in itemDictionary.Values)
{
if (item.Type == 3 && item.Name == name)
{
UUID rq = UUID.Random();
DataserverPlugin dataserverPlugin = (DataserverPlugin)m_ScriptEngine.GetScriptPlugin("Dataserver");
UUID tid = dataserverPlugin.RegisterRequest(m_host.UUID,
m_itemID, rq.ToString());
Vector3 region = new Vector3(
World.RegionInfo.RegionLocX,
World.RegionInfo.RegionLocY,
0);
World.AssetService.Get(item.AssetID.ToString(), this,
delegate(string i, object sender, AssetBase a) {
if (a != null)
{
AssetLandmark lm = new AssetLandmark(a);
float rx = (uint)(lm.RegionHandle >> 32);
float ry = (uint)lm.RegionHandle;
region = lm.Position + new Vector3(rx, ry, 0) - region;
string reply = region.ToString();
dataserverPlugin.AddReply(rq.ToString(),
reply, 1000);
}
});
PScriptSleep(m_sleepMsOnRequestInventoryData);
return(tid.ToString());
}
}
PScriptSleep(m_sleepMsOnRequestInventoryData);
return(string.Empty);
}
public void RemoveAllScriptControllers(ISceneChildEntity part)
{
TaskInventoryDictionary taskIDict = part.TaskInventory;
if (taskIDict != null)
{
lock (taskIDict)
{
foreach (UUID taskID in taskIDict.Keys)
{
UnRegisterControlEventsToScript(m_sp.LocalId, taskID);
taskIDict[taskID].PermsMask &= ~(
(int)ScriptPermission.ControlCamera |
(int)ScriptPermission.TakeControls);
}
}
}
}
public void LoadModuleFromArchive(byte[] data, string filePath, TarArchiveReader.TarEntryType type, IScene scene)
{
if (filePath.StartsWith("parcels/"))
{
if (!m_merge)
{
//Only use if we are not merging
LandData parcel = new LandData();
OSD parcelData = OSDParser.DeserializeLLSDBinary(data);
parcel.FromOSD((OSDMap)parcelData);
m_parcels.Add(parcel);
}
}
else if (filePath.StartsWith("terrain/"))
{
ITerrainModule terrainModule = m_scene.RequestModuleInterface <ITerrainModule>();
MemoryStream ms = new MemoryStream(data);
terrainModule.LoadFromStream(filePath, ms, 0, 0);
ms.Close();
}
else if (filePath.StartsWith("entities/"))
{
MemoryStream ms = new MemoryStream(data);
SceneObjectGroup sceneObject = OpenSim.Region.Framework.Scenes.Serialization.SceneObjectSerializer.FromXml2Format(ms, (Scene)scene);
foreach (SceneObjectPart part in sceneObject.ChildrenList)
{
if (!ResolveUserUuid(part.CreatorID))
{
part.CreatorID = m_scene.RegionInfo.EstateSettings.EstateOwner;
}
if (!ResolveUserUuid(part.OwnerID))
{
part.OwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;
}
if (!ResolveUserUuid(part.LastOwnerID))
{
part.LastOwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;
}
// And zap any troublesome sit target information
part.SitTargetOrientation = new Quaternion(0, 0, 0, 1);
part.SitTargetPosition = new Vector3(0, 0, 0);
// Fix ownership/creator of inventory items
// Not doing so results in inventory items
// being no copy/no mod for everyone
lock (part.TaskInventory)
{
TaskInventoryDictionary inv = part.TaskInventory;
foreach (KeyValuePair <UUID, TaskInventoryItem> kvp in inv)
{
if (!ResolveUserUuid(kvp.Value.OwnerID))
{
kvp.Value.OwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;
}
if (!ResolveUserUuid(kvp.Value.CreatorID))
{
kvp.Value.CreatorID = m_scene.RegionInfo.EstateSettings.EstateOwner;
}
}
}
}
if (m_scene.SceneGraph.AddPrimToScene(sceneObject))
{
sceneObject.HasGroupChanged = true;
sceneObject.ScheduleGroupUpdate(PrimUpdateFlags.FullUpdate);
sceneObject.CreateScriptInstances(0, false, 0, UUID.Zero);
sceneObject.ResumeScripts();
}
}
}
public static string SerializeTaskInventory(TaskInventoryDictionary inventory, Scene scene)
{
string serializedTaskInventory;
using (StringWriter sw = new StringWriter())
{
using (XmlTextWriter writer = new XmlTextWriter(sw))
{
SceneObjectSerializer.WriteTaskInventory(writer, inventory, new Dictionary<string, object>(), scene);
}
serializedTaskInventory = sw.ToString();
}
return serializedTaskInventory;
}
private void DearchiveRegion0DotStar()
{
int successfulAssetRestores = 0;
int failedAssetRestores = 0;
List <string> serializedSceneObjects = new List <string>();
string filePath = "NONE";
try
{
TarArchiveReader archive = new TarArchiveReader(m_loadStream);
byte[] data;
TarArchiveReader.TarEntryType entryType;
while ((data = archive.ReadEntry(out filePath, out entryType)) != null)
{
//m_log.DebugFormat(
// "[ARCHIVER]: Successfully read {0} ({1} bytes)", filePath, data.Length);
if (TarArchiveReader.TarEntryType.TYPE_DIRECTORY == entryType)
{
continue;
}
if (filePath.StartsWith(ArchiveConstants.OBJECTS_PATH))
{
serializedSceneObjects.Add(Encoding.UTF8.GetString(data));
}
else if (filePath.StartsWith(ArchiveConstants.ASSETS_PATH))
{
if (LoadAsset(filePath, data))
{
successfulAssetRestores++;
}
else
{
failedAssetRestores++;
}
}
else if (!m_merge && filePath.StartsWith(ArchiveConstants.TERRAINS_PATH))
{
LoadTerrain(filePath, data);
}
else if (!m_merge && filePath.StartsWith(ArchiveConstants.SETTINGS_PATH))
{
LoadRegionSettings(filePath, data);
}
}
//m_log.Debug("[ARCHIVER]: Reached end of archive");
archive.Close();
}
catch (Exception e)
{
m_log.ErrorFormat(
"[ARCHIVER]: Aborting load with error in archive file {0}. {1}", filePath, e);
m_errorMessage += e.ToString();
m_scene.EventManager.TriggerOarFileLoaded(m_requestId, m_errorMessage);
return;
}
m_log.InfoFormat("[ARCHIVER]: Restored {0} assets", successfulAssetRestores);
if (failedAssetRestores > 0)
{
m_log.ErrorFormat("[ARCHIVER]: Failed to load {0} assets", failedAssetRestores);
m_errorMessage += String.Format("Failed to load {0} assets", failedAssetRestores);
}
// Reload serialized prims
m_log.InfoFormat("[ARCHIVER]: Preparing {0} scene objects. Please wait.", serializedSceneObjects.Count);
IRegionSerializerModule serializer = m_scene.RequestModuleInterface <IRegionSerializerModule>();
int sceneObjectsLoadedCount = 0;
List <SceneObjectGroup> backupObjects = new List <SceneObjectGroup>();
Dictionary <UUID, UUID> OriginalBackupIDs = new Dictionary <UUID, UUID>();
bool objectFixingFailed = false;
foreach (string serializedSceneObject in serializedSceneObjects)
{
SceneObjectGroup sceneObject;
try
{
sceneObject = serializer.DeserializeGroupFromXml2(serializedSceneObject);
}
catch (Exception e)
{
m_log.InfoFormat("[ARCHIVER]: Error while deserializing group: {0}", e);
if (m_skipErrorGroups)
{
continue;
}
else
{
throw;
}
}
if (sceneObject == null)
{
if (m_skipErrorGroups)
{
continue;
}
else
{
throw new Exception("Error while deserializing group");
}
}
// For now, give all incoming scene objects new uuids. This will allow scenes to be cloned
// on the same region server and multiple examples a single object archive to be imported
// to the same scene (when this is possible).
UUID OldUUID = sceneObject.UUID;
sceneObject.ResetIDs();
// if sceneObject is no-copy, save the old ID with the new ID.
OriginalBackupIDs[sceneObject.UUID] = OldUUID;
// Try to retain the original creator/owner/lastowner if their uuid is present on this grid
// otherwise, use the master avatar uuid instead
UUID masterAvatarId = m_scene.RegionInfo.MasterAvatarAssignedUUID;
if (m_scene.RegionInfo.EstateSettings.EstateOwner != UUID.Zero)
{
masterAvatarId = m_scene.RegionInfo.EstateSettings.EstateOwner;
}
foreach (SceneObjectPart part in sceneObject.GetParts())
{
if (!ResolveUserUuid(part.CreatorID))
{
m_log.WarnFormat("[ARCHIVER]: Could not resolve av/group ID {0} for object '{1}' part creator", part.CreatorID, sceneObject.Name);
// Don't fail to load an object owned by a valid user, just because a creator no longer exists in the DB. (We've seen this with some of YadNi's stuff.)
// objectFixingFailed = true;
// part.CreatorID = masterAvatarId;
}
if (!ResolveUserUuid(part.OwnerID))
{
m_log.WarnFormat("[ARCHIVER]: Could not resolve av/group ID {0} for object '{1}' part owner", part.OwnerID, sceneObject.Name);
objectFixingFailed = true;
part.OwnerID = masterAvatarId;
}
if (!ResolveUserUuid(part.LastOwnerID))
{
m_log.WarnFormat("[ARCHIVER]: Could not resolve av/group ID {0} for object '{1}' part last owner", part.LastOwnerID, sceneObject.Name);
objectFixingFailed = true;
part.LastOwnerID = masterAvatarId;
}
// Fix ownership/creator of inventory items
// Not doing so results in inventory items
// being no copy/no mod for everyone
lock (part.TaskInventory)
{
TaskInventoryDictionary inv = part.TaskInventory;
foreach (KeyValuePair <UUID, TaskInventoryItem> kvp in inv)
{
if (!ResolveUserUuid(kvp.Value.OwnerID))
{
m_log.WarnFormat("[ARCHIVER]: Could not resolve av/group ID {0} for object '{1}' inventory item owner", kvp.Value.OwnerID, sceneObject.Name);
objectFixingFailed = true;
kvp.Value.OwnerID = masterAvatarId;
}
if (!ResolveUserUuid(kvp.Value.CreatorID))
{
m_log.WarnFormat("[ARCHIVER]: Could not resolve av/group ID {0} for object '{1}' inventory item creator", kvp.Value.CreatorID, sceneObject.Name);
// Don't fail to load an object owned by a valid user, just because a creator no longer exists in the DB. (We've seen this with some of YadNi's stuff.)
// objectFixingFailed = true;
// kvp.Value.CreatorID = masterAvatarId;
}
}
}
}
backupObjects.Add(sceneObject);
}
if (objectFixingFailed && !m_allowUserReassignment)
{
m_log.Error("[ARCHIVER]: Could not restore scene objects. One or more avatar accounts not found.");
return;
}
Dictionary <UUID, SceneObjectGroup> ExistingNoCopyObjects = new Dictionary <UUID, SceneObjectGroup>();
if (!m_merge)
{
m_log.Info("[ARCHIVER]: Clearing all existing scene objects");
m_scene.DeleteAllSceneObjectsExcept(delegate(SceneObjectGroup existingSOG)
{ // Return true if this object should be skipped in the delete.
// Don't delete any no-copy objects.
if (NoCopyObjectOrContents(existingSOG))
{
ExistingNoCopyObjects.Add(existingSOG.UUID, existingSOG);
return(true);
}
return(false);
});
}
m_log.InfoFormat("[ARCHIVER]: Loading {0} scene objects. Please wait.", serializedSceneObjects.Count);
// sceneObject is the one from backup to restore to the scene
foreach (SceneObjectGroup backupObject in backupObjects)
{
SceneObjectGroup existingObject = null;
UUID originalUUID = OriginalBackupIDs[backupObject.UUID];
// Don't restore any no-copy objects unless there was an existing matching UUID in the scene.
if (ExistingNoCopyObjects.ContainsKey(originalUUID))
{
existingObject = ExistingNoCopyObjects[originalUUID];
}
// existingSOG here means existing NO-COPY object, not deleted from scene above
if (NoCopyObjectOrContents(backupObject))
{
if ((existingObject != null) && !existingObject.IsAttachment)
{
// copy only position and rotation from backup
existingObject.Rotation = backupObject.Rotation;
existingObject.AbsolutePosition = backupObject.AbsolutePosition;
}
// don't restore no-copy items
}
else
if (m_scene.AddRestoredSceneObject(backupObject, true, false))
{
// this may have added 2nd copyable copy if existingObject is no-copy
sceneObjectsLoadedCount++;
backupObject.CreateScriptInstances(0, ScriptStartFlags.PostOnRez, m_scene.DefaultScriptEngine, 0, null);
}
}
m_log.InfoFormat("[ARCHIVER]: Restored {0} scene objects to the scene", sceneObjectsLoadedCount);
int ignoredObjects = serializedSceneObjects.Count - sceneObjectsLoadedCount;
if (ignoredObjects > 0)
{
m_log.WarnFormat("[ARCHIVER]: Ignored {0} scene objects that already existed in the scene", ignoredObjects);
}
m_log.InfoFormat("[ARCHIVER]: Successfully loaded archive");
m_scene.EventManager.TriggerOarFileLoaded(m_requestId, m_errorMessage);
}
private void DearchiveRegion0DotStar()
{
int successfulAssetRestores = 0;
int failedAssetRestores = 0;
List <string> serialisedSceneObjects = new List <string>();
string filePath = "NONE";
try
{
TarArchiveReader archive = new TarArchiveReader(m_loadStream);
byte[] data;
TarArchiveReader.TarEntryType entryType;
while ((data = archive.ReadEntry(out filePath, out entryType)) != null)
{
//m_log.DebugFormat(
// "[ARCHIVER]: Successfully read {0} ({1} bytes)", filePath, data.Length);
if (TarArchiveReader.TarEntryType.TYPE_DIRECTORY == entryType)
{
continue;
}
if (filePath.StartsWith(ArchiveConstants.OBJECTS_PATH))
{
serialisedSceneObjects.Add(m_asciiEncoding.GetString(data));
}
else if (filePath.StartsWith(ArchiveConstants.ASSETS_PATH))
{
if (LoadAsset(filePath, data))
{
successfulAssetRestores++;
}
else
{
failedAssetRestores++;
}
}
else if (!m_merge && filePath.StartsWith(ArchiveConstants.TERRAINS_PATH))
{
LoadTerrain(filePath, data);
}
else if (!m_merge && filePath.StartsWith(ArchiveConstants.SETTINGS_PATH))
{
LoadRegionSettings(filePath, data);
}
}
//m_log.Debug("[ARCHIVER]: Reached end of archive");
archive.Close();
}
catch (Exception e)
{
m_log.ErrorFormat(
"[ARCHIVER]: Aborting load with error in archive file {0}. {1}", filePath, e);
m_errorMessage += e.ToString();
m_scene.EventManager.TriggerOarFileLoaded(m_requestId, m_errorMessage);
return;
}
m_log.InfoFormat("[ARCHIVER]: Restored {0} assets", successfulAssetRestores);
if (failedAssetRestores > 0)
{
m_log.ErrorFormat("[ARCHIVER]: Failed to load {0} assets", failedAssetRestores);
m_errorMessage += String.Format("Failed to load {0} assets", failedAssetRestores);
}
if (!m_merge)
{
m_log.Info("[ARCHIVER]: Clearing all existing scene objects");
m_scene.DeleteAllSceneObjects();
}
// Reload serialized prims
m_log.InfoFormat("[ARCHIVER]: Loading {0} scene objects. Please wait.", serialisedSceneObjects.Count);
IRegionSerialiserModule serialiser = m_scene.RequestModuleInterface <IRegionSerialiserModule>();
int sceneObjectsLoadedCount = 0;
foreach (string serialisedSceneObject in serialisedSceneObjects)
{
/*
* m_log.DebugFormat("[ARCHIVER]: Loading xml with raw size {0}", serialisedSceneObject.Length);
*
* // Really large xml files (multi megabyte) appear to cause
* // memory problems
* // when loading the xml. But don't enable this check yet
*
* if (serialisedSceneObject.Length > 5000000)
* {
* m_log.Error("[ARCHIVER]: Ignoring xml since size > 5000000);");
* continue;
* }
*/
SceneObjectGroup sceneObject = serialiser.DeserializeGroupFromXml2(serialisedSceneObject);
// For now, give all incoming scene objects new uuids. This will allow scenes to be cloned
// on the same region server and multiple examples a single object archive to be imported
// to the same scene (when this is possible).
sceneObject.ResetIDs();
// Try to retain the original creator/owner/lastowner if their uuid is present on this grid
// otherwise, use the master avatar uuid instead
UUID masterAvatarId = m_scene.RegionInfo.MasterAvatarAssignedUUID;
if (m_scene.RegionInfo.EstateSettings.EstateOwner != UUID.Zero)
{
masterAvatarId = m_scene.RegionInfo.EstateSettings.EstateOwner;
}
foreach (SceneObjectPart part in sceneObject.Children.Values)
{
if (!ResolveUserUuid(part.CreatorID))
{
part.CreatorID = masterAvatarId;
}
if (!ResolveUserUuid(part.OwnerID))
{
part.OwnerID = masterAvatarId;
}
if (!ResolveUserUuid(part.LastOwnerID))
{
part.LastOwnerID = masterAvatarId;
}
// And zap any troublesome sit target information
part.SitTargetOrientation = new Quaternion(0, 0, 0, 1);
part.SitTargetPosition = new Vector3(0, 0, 0);
// Fix ownership/creator of inventory items
// Not doing so results in inventory items
// being no copy/no mod for everyone
lock (part.TaskInventory)
{
TaskInventoryDictionary inv = part.TaskInventory;
foreach (KeyValuePair <UUID, TaskInventoryItem> kvp in inv)
{
if (!ResolveUserUuid(kvp.Value.OwnerID))
{
kvp.Value.OwnerID = masterAvatarId;
}
if (!ResolveUserUuid(kvp.Value.CreatorID))
{
kvp.Value.CreatorID = masterAvatarId;
}
}
}
}
if (m_scene.AddRestoredSceneObject(sceneObject, true, false))
{
sceneObjectsLoadedCount++;
sceneObject.CreateScriptInstances(0, true, m_scene.DefaultScriptEngine, 0);
}
}
m_log.InfoFormat("[ARCHIVER]: Restored {0} scene objects to the scene", sceneObjectsLoadedCount);
int ignoredObjects = serialisedSceneObjects.Count - sceneObjectsLoadedCount;
if (ignoredObjects > 0)
{
m_log.WarnFormat("[ARCHIVER]: Ignored {0} scene objects that already existed in the scene", ignoredObjects);
}
m_log.InfoFormat("[ARCHIVER]: Successfully loaded archive");
m_scene.EventManager.TriggerOarFileLoaded(m_requestId, m_errorMessage);
}
public void T014_UpdateObject()
{
string text1 = "object1 text";
SceneObjectGroup sog = FindSOG("object1", region1);
sog.RootPart.Text = text1;
db.StoreObject(sog, region1);
sog = FindSOG("object1", region1);
Assert.That(text1, Is.EqualTo(sog.RootPart.Text), "Assert.That(text1, Is.EqualTo(sog.RootPart.Text))");
// Creates random values
UUID creator = new UUID();
creator = UUID.Random();
TaskInventoryDictionary dic = new TaskInventoryDictionary();
localID = localID + 1;
string name = "West Adam";
byte material = (byte) random.Next(127);
ulong regionh = (ulong)random.NextDouble() * (ulong)random.Next();
int pin = random.Next();
Byte[] partsys = new byte[8];
Byte[] textani = new byte[8];
random.NextBytes(textani);
random.NextBytes(partsys);
DateTime expires = new DateTime(2010, 12, 20);
DateTime rezzed = new DateTime(2005, 07, 15);
Vector3 groupos = new Vector3(random.Next(),random.Next(),random.Next());
Vector3 offset = new Vector3(random.Next(),random.Next(),random.Next());
Quaternion rotoff = new Quaternion(random.Next(),random.Next(),random.Next(),random.Next());
Vector3 velocity = new Vector3(random.Next(),random.Next(),random.Next());
Vector3 angvelo = new Vector3(random.Next(),random.Next(),random.Next());
Vector3 accel = new Vector3(random.Next(),random.Next(),random.Next());
string description = name;
Color color = Color.FromArgb(255, 255, 255, 0);
string text = "What You Say?{]\vz~";
string sitname = RandomName();
string touchname = RandomName();
int linknum = random.Next();
byte clickaction = (byte) random.Next(127);
PrimitiveBaseShape pbshap = new PrimitiveBaseShape();
pbshap = PrimitiveBaseShape.Default;
Vector3 scale = new Vector3(random.Next(),random.Next(),random.Next());
byte updatef = (byte) random.Next(127);
// Updates the region with new values
SceneObjectGroup sog2 = FindSOG("Adam West", region3);
Assert.That(sog2,Is.Not.Null);
sog2.RootPart.RegionHandle = regionh;
sog2.RootPart.Shape = pbshap;
sog2.RootPart.GroupPosition = groupos;
sog2.RootPart.RotationOffset = rotoff;
sog2.RootPart.CreatorID = creator;
sog2.RootPart.TaskInventory = dic;
sog2.RootPart.Name = name;
sog2.RootPart.Material = material;
sog2.RootPart.ScriptAccessPin = pin;
sog2.RootPart.TextureAnimation = textani;
sog2.RootPart.ParticleSystem = partsys;
sog2.RootPart.Expires = expires;
sog2.RootPart.Rezzed = rezzed;
sog2.RootPart.OffsetPosition = offset;
sog2.RootPart.Velocity = velocity;
sog2.RootPart.AngularVelocity = angvelo;
sog2.RootPart.Acceleration = accel;
sog2.RootPart.Description = description;
sog2.RootPart.Color = color;
sog2.RootPart.Text = text;
sog2.RootPart.SitName = sitname;
sog2.RootPart.TouchName = touchname;
sog2.RootPart.LinkNum = linknum;
sog2.RootPart.ClickAction = clickaction;
sog2.RootPart.Scale = scale;
sog2.RootPart.UpdateFlag = updatef;
db.StoreObject(sog2, region3);
List<SceneObjectGroup> sogs = db.LoadObjects(region3);
Assert.That(sogs.Count, Is.EqualTo(1), "Assert.That(sogs.Count, Is.EqualTo(1))");
SceneObjectGroup retsog = FindSOG("West Adam", region3);
Assert.That(retsog,Is.Not.Null);
SceneObjectPart p = retsog.RootPart;
Assert.That(regionh,Is.EqualTo(p.RegionHandle), "Assert.That(regionh,Is.EqualTo(p.RegionHandle))");
Assert.That(groupos,Is.EqualTo(p.GroupPosition), "Assert.That(groupos,Is.EqualTo(p.GroupPosition))");
Assert.That(name,Is.EqualTo(p.Name), "Assert.That(name,Is.EqualTo(p.Name))");
Assert.That(rotoff,Is.EqualTo(p.RotationOffset), "Assert.That(rotoff,Is.EqualTo(p.RotationOffset))");
Assert.That(creator,Is.EqualTo(p.CreatorID), "Assert.That(creator,Is.EqualTo(p.CreatorID))");
Assert.That(dic,Is.EqualTo(p.TaskInventory), "Assert.That(dic,Is.EqualTo(p.TaskInventory))");
Assert.That(name,Is.EqualTo(p.Name), "Assert.That(name,Is.EqualTo(p.Name))");
Assert.That(material,Is.EqualTo(p.Material), "Assert.That(material,Is.EqualTo(p.Material))");
Assert.That(pin,Is.EqualTo(p.ScriptAccessPin), "Assert.That(pin,Is.EqualTo(p.ScriptAccessPin))");
Assert.That(textani,Is.EqualTo(p.TextureAnimation), "Assert.That(textani,Is.EqualTo(p.TextureAnimation))");
Assert.That(partsys,Is.EqualTo(p.ParticleSystem), "Assert.That(partsys,Is.EqualTo(p.ParticleSystem))");
Assert.That(offset,Is.EqualTo(p.OffsetPosition), "Assert.That(offset,Is.EqualTo(p.OffsetPosition))");
Assert.That(velocity,Is.EqualTo(p.Velocity), "Assert.That(velocity,Is.EqualTo(p.Velocity))");
Assert.That(angvelo,Is.EqualTo(p.AngularVelocity), "Assert.That(angvelo,Is.EqualTo(p.AngularVelocity))");
Assert.That(accel,Is.EqualTo(p.Acceleration), "Assert.That(accel,Is.EqualTo(p.Acceleration))");
Assert.That(description,Is.EqualTo(p.Description), "Assert.That(description,Is.EqualTo(p.Description))");
Assert.That(color,Is.EqualTo(p.Color), "Assert.That(color,Is.EqualTo(p.Color))");
Assert.That(text,Is.EqualTo(p.Text), "Assert.That(text,Is.EqualTo(p.Text))");
Assert.That(sitname,Is.EqualTo(p.SitName), "Assert.That(sitname,Is.EqualTo(p.SitName))");
Assert.That(touchname,Is.EqualTo(p.TouchName), "Assert.That(touchname,Is.EqualTo(p.TouchName))");
Assert.That(clickaction,Is.EqualTo(p.ClickAction), "Assert.That(clickaction,Is.EqualTo(p.ClickAction))");
Assert.That(scale,Is.EqualTo(p.Scale), "Assert.That(scale,Is.EqualTo(p.Scale))");
}
public SOPObjectInventory(IScene rootScene, TaskInventoryDictionary taskInventory)
{
m_rootScene = rootScene;
m_privateInventory = taskInventory;
m_publicInventory = new Dictionary <UUID, IInventoryItem>();
}
private void DearchiveRegion0DotStar()
{
if (m_loadStream == null)
{
return;
}
int successfulAssetRestores = 0;
int failedAssetRestores = 0;
string filePath = "NONE";
DateTime start = DateTime.Now;
TarArchiveReader archive = new TarArchiveReader(m_loadStream);
if (!m_skipAssets)
{
m_threadpool = new AuroraThreadPool(new AuroraThreadPoolStartInfo()
{
Threads = 1,
priority =
System.Threading.ThreadPriority
.BelowNormal
});
}
IBackupModule backup = m_scene.RequestModuleInterface <IBackupModule>();
if (!m_merge)
{
DateTime before = DateTime.Now;
MainConsole.Instance.Info("[ARCHIVER]: Clearing all existing scene objects");
if (backup != null)
{
backup.DeleteAllSceneObjects();
}
MainConsole.Instance.Info("[ARCHIVER]: Cleared all existing scene objects in " +
(DateTime.Now - before).Minutes + ":" + (DateTime.Now - before).Seconds);
}
IScriptModule[] modules = m_scene.RequestModuleInterfaces <IScriptModule>();
//Disable the script engine so that it doesn't load in the background and kill OAR loading
foreach (IScriptModule module in modules)
{
module.Disabled = true;
}
//Disable backup for now as well
if (backup != null)
{
backup.LoadingPrims = true;
}
IRegionSerialiserModule serialiser = m_scene.RequestModuleInterface <IRegionSerialiserModule>();
int sceneObjectsLoadedCount = 0;
//We save the groups so that we can back them up later
List <ISceneEntity> groupsToBackup = new List <ISceneEntity>();
List <LandData> landData = new List <LandData>();
// must save off some stuff until after assets have been saved and recieved new uuids
// keeping these collection local because I am sure they will get large and garbage collection is better that way
List <byte[]> seneObjectGroups = new List <byte[]>();
Dictionary <UUID, UUID> assetBinaryChangeRecord = new Dictionary <UUID, UUID>();
Queue <UUID> assets2Save = new Queue <UUID>();
try
{
byte[] data;
TarArchiveReader.TarEntryType entryType;
while ((data = archive.ReadEntry(out filePath, out entryType)) != null)
{
if (TarArchiveReader.TarEntryType.TYPE_DIRECTORY == entryType)
{
continue;
}
if (filePath.StartsWith(ArchiveConstants.OBJECTS_PATH))
{
seneObjectGroups.Add(data);
}
else if (!m_skipAssets && filePath.StartsWith(ArchiveConstants.ASSETS_PATH))
{
AssetBase asset;
if (LoadAsset(filePath, data, out asset))
{
successfulAssetRestores++;
if (m_useAsync)
{
lock (AssetsToAdd) AssetsToAdd.Add(asset);
}
else
{
if (asset.IsBinaryAsset)
{
UUID aid = asset.ID;
asset.ID = m_scene.AssetService.Store(asset);
if (asset.ID != aid && asset.ID != UUID.Zero)
{
assetBinaryChangeRecord.Add(aid, asset.ID);
}
}
else
{
if (!assetNonBinaryCollection.ContainsKey(asset.ID))
{
assetNonBinaryCollection.Add(asset.ID, asset);
// I need something I can safely loop through
assets2Save.Enqueue(asset.ID);
}
}
}
}
else
{
failedAssetRestores++;
}
if ((successfulAssetRestores + failedAssetRestores) % 250 == 0)
{
MainConsole.Instance.Info("[ARCHIVER]: Loaded " + successfulAssetRestores +
" assets and failed to load " + failedAssetRestores + " assets...");
}
}
else if (filePath.StartsWith(ArchiveConstants.TERRAINS_PATH))
{
LoadTerrain(filePath, data);
}
else if (!m_merge && filePath.StartsWith(ArchiveConstants.SETTINGS_PATH))
{
LoadRegionSettings(filePath, data);
}
else if (filePath.StartsWith(ArchiveConstants.LANDDATA_PATH))
{
LandData parcel = LandDataSerializer.Deserialize(m_utf8Encoding.GetString(data));
parcel.OwnerID = ResolveUserUuid(parcel.OwnerID, UUID.Zero, "", Vector3.Zero, null);
landData.Add(parcel);
}
else if (filePath == ArchiveConstants.CONTROL_FILE_PATH)
{
LoadControlFile(data);
}
}
// Save Assets
int savingAssetsCount = 0;
while (assets2Save.Count > 0)
{
try
{
UUID assetid = assets2Save.Dequeue();
SaveNonBinaryAssets(assetid, assetNonBinaryCollection[assetid], assetBinaryChangeRecord);
savingAssetsCount++;
if ((savingAssetsCount) % 250 == 0)
{
MainConsole.Instance.Info("[ARCHIVER]: Saving " + savingAssetsCount + " assets...");
}
}
catch (Exception ex)
{
MainConsole.Instance.Info("[ARCHIVER]: Exception in saving an asset: " + ex.ToString());
}
}
foreach (byte[] data2 in seneObjectGroups)
{
byte[] data3 = data2;
string stringData = Utils.BytesToString(data3);
MatchCollection mc = Regex.Matches(stringData, sPattern);
bool didChange = false;
if (mc.Count >= 1)
{
foreach (Match match in mc)
{
UUID thematch = new UUID(match.Value);
UUID newvalue = thematch;
if (assetNonBinaryCollection.ContainsKey(thematch))
{
newvalue = assetNonBinaryCollection[thematch].ID;
}
else if (assetBinaryChangeRecord.ContainsKey(thematch))
{
newvalue = assetBinaryChangeRecord[thematch];
}
if (thematch == newvalue)
{
continue;
}
stringData = stringData.Replace(thematch.ToString().Trim(), newvalue.ToString().Trim());
didChange = true;
}
}
if (didChange)
{
data3 = Utils.StringToBytes(stringData);
}
ISceneEntity sceneObject = serialiser.DeserializeGroupFromXml2(data3, m_scene);
if (sceneObject == null)
{
//! big error!
MainConsole.Instance.Error("Error reading SOP XML (Please mantis this!): " +
m_asciiEncoding.GetString(data3));
continue;
}
foreach (ISceneChildEntity part in sceneObject.ChildrenEntities())
{
if (string.IsNullOrEmpty(part.CreatorData))
{
part.CreatorID = ResolveUserUuid(part.CreatorID, part.CreatorID, part.CreatorData,
part.AbsolutePosition, landData);
}
part.OwnerID = ResolveUserUuid(part.OwnerID, part.CreatorID, part.CreatorData,
part.AbsolutePosition, landData);
part.LastOwnerID = ResolveUserUuid(part.LastOwnerID, part.CreatorID, part.CreatorData,
part.AbsolutePosition, landData);
// And zap any troublesome sit target information
part.SitTargetOrientation = new Quaternion(0, 0, 0, 1);
part.SitTargetPosition = new Vector3(0, 0, 0);
// Fix ownership/creator of inventory items
// Not doing so results in inventory items
// being no copy/no mod for everyone
lock (part.TaskInventory)
{
TaskInventoryDictionary inv = part.TaskInventory;
foreach (KeyValuePair <UUID, TaskInventoryItem> kvp in inv)
{
kvp.Value.OwnerID = ResolveUserUuid(kvp.Value.OwnerID, kvp.Value.CreatorID,
kvp.Value.CreatorData, part.AbsolutePosition,
landData);
if (string.IsNullOrEmpty(kvp.Value.CreatorData))
{
kvp.Value.CreatorID = ResolveUserUuid(kvp.Value.CreatorID, kvp.Value.CreatorID,
kvp.Value.CreatorData, part.AbsolutePosition,
landData);
}
}
}
}
//Add the offsets of the region
Vector3 newPos = new Vector3(sceneObject.AbsolutePosition.X + m_offsetX,
sceneObject.AbsolutePosition.Y + m_offsetY,
sceneObject.AbsolutePosition.Z + m_offsetZ);
if (m_flipX)
{
newPos.X = m_scene.RegionInfo.RegionSizeX - newPos.X;
}
if (m_flipY)
{
newPos.Y = m_scene.RegionInfo.RegionSizeY - newPos.Y;
}
sceneObject.SetAbsolutePosition(false, newPos);
if (m_scene.SceneGraph.AddPrimToScene(sceneObject))
{
groupsToBackup.Add(sceneObject);
sceneObject.ScheduleGroupUpdate(PrimUpdateFlags.ForcedFullUpdate);
sceneObject.CreateScriptInstances(0, false, StateSource.RegionStart, UUID.Zero, true);
}
sceneObjectsLoadedCount++;
if (sceneObjectsLoadedCount % 250 == 0)
{
MainConsole.Instance.Info("[ARCHIVER]: Loaded " + sceneObjectsLoadedCount + " objects...");
}
}
assetNonBinaryCollection.Clear();
assetBinaryChangeRecord.Clear();
seneObjectGroups.Clear();
}
catch (Exception e)
{
MainConsole.Instance.ErrorFormat(
"[ARCHIVER]: Aborting load with error in archive file {0}. {1}", filePath, e);
m_errorMessage += e.ToString();
m_scene.EventManager.TriggerOarFileLoaded(UUID.Zero.Guid, m_errorMessage);
return;
}
finally
{
archive.Close();
m_loadStream.Close();
m_loadStream.Dispose();
//Reeanble now that we are done
foreach (IScriptModule module in modules)
{
module.Disabled = false;
}
//Reset backup too
if (backup != null)
{
backup.LoadingPrims = false;
}
}
//Now back up the prims
foreach (ISceneEntity grp in groupsToBackup)
{
//Backup!
grp.HasGroupChanged = true;
}
if (!m_skipAssets && m_useAsync && !AssetSaverIsRunning)
{
m_threadpool.QueueEvent(SaveAssets, 0);
}
if (!m_skipAssets)
{
MainConsole.Instance.InfoFormat("[ARCHIVER]: Restored {0} assets", successfulAssetRestores);
if (failedAssetRestores > 0)
{
MainConsole.Instance.ErrorFormat("[ARCHIVER]: Failed to load {0} assets", failedAssetRestores);
m_errorMessage += String.Format("Failed to load {0} assets", failedAssetRestores);
}
}
// Try to retain the original creator/owner/lastowner if their uuid is present on this grid
// otherwise, use the master avatar uuid instead
// Reload serialized parcels
MainConsole.Instance.InfoFormat("[ARCHIVER]: Loading {0} parcels. Please wait.", landData.Count);
IParcelManagementModule parcelManagementModule = m_scene.RequestModuleInterface <IParcelManagementModule>();
if (parcelManagementModule != null)
{
parcelManagementModule.IncomingLandDataFromOAR(landData, m_merge, new Vector2(m_offsetX, m_offsetY));
}
MainConsole.Instance.InfoFormat("[ARCHIVER]: Restored {0} parcels.", landData.Count);
//Clean it out
landData.Clear();
MainConsole.Instance.InfoFormat("[ARCHIVER]: Successfully loaded archive in " +
(DateTime.Now - start).Minutes + ":" + (DateTime.Now - start).Seconds);
m_validUserUuids.Clear();
m_scene.EventManager.TriggerOarFileLoaded(UUID.Zero.Guid, m_errorMessage);
}
public static void WriteTaskInventory(XmlTextWriter writer, TaskInventoryDictionary tinv, Dictionary<string, object> options, Scene scene)
{
if (tinv.Count > 0) // otherwise skip this
{
writer.WriteStartElement("TaskInventory");
foreach (TaskInventoryItem item in tinv.Values)
{
writer.WriteStartElement("TaskInventoryItem");
WriteUUID(writer, "AssetID", item.AssetID, options);
writer.WriteElementString("BasePermissions", item.BasePermissions.ToString());
writer.WriteElementString("CreationDate", item.CreationDate.ToString());
WriteUUID(writer, "CreatorID", item.CreatorID, options);
if (item.CreatorData != null && item.CreatorData != string.Empty)
writer.WriteElementString("CreatorData", item.CreatorData);
else if (options.ContainsKey("home"))
{
if (m_UserManagement == null)
m_UserManagement = scene.RequestModuleInterface<IUserManagement>();
string name = m_UserManagement.GetUserName(item.CreatorID);
writer.WriteElementString("CreatorData", (string)options["home"] + ";" + name);
}
writer.WriteElementString("Description", item.Description);
writer.WriteElementString("EveryonePermissions", item.EveryonePermissions.ToString());
writer.WriteElementString("Flags", item.Flags.ToString());
WriteUUID(writer, "GroupID", item.GroupID, options);
writer.WriteElementString("GroupPermissions", item.GroupPermissions.ToString());
writer.WriteElementString("InvType", item.InvType.ToString());
WriteUUID(writer, "ItemID", item.ItemID, options);
WriteUUID(writer, "OldItemID", item.OldItemID, options);
UUID lastOwnerID = options.ContainsKey("wipe-owners") ? UUID.Zero : item.LastOwnerID;
WriteUUID(writer, "LastOwnerID", lastOwnerID, options);
writer.WriteElementString("Name", item.Name);
writer.WriteElementString("NextPermissions", item.NextPermissions.ToString());
UUID ownerID = options.ContainsKey("wipe-owners") ? UUID.Zero : item.OwnerID;
WriteUUID(writer, "OwnerID", ownerID, options);
writer.WriteElementString("CurrentPermissions", item.CurrentPermissions.ToString());
WriteUUID(writer, "ParentID", item.ParentID, options);
WriteUUID(writer, "ParentPartID", item.ParentPartID, options);
WriteUUID(writer, "PermsGranter", item.PermsGranter, options);
writer.WriteElementString("PermsMask", item.PermsMask.ToString());
writer.WriteElementString("Type", item.Type.ToString());
writer.WriteElementString("OwnerChanged", item.OwnerChanged.ToString().ToLower());
writer.WriteEndElement(); // TaskInventoryItem
}
writer.WriteEndElement(); // TaskInventory
}
}
static void WriteTaskInventory(XmlTextWriter writer, TaskInventoryDictionary tinv, Dictionary<string, object> options)
{
if (tinv.Count > 0) // otherwise skip this
{
writer.WriteStartElement("TaskInventory");
foreach (TaskInventoryItem item in tinv.Values)
{
writer.WriteStartElement("TaskInventoryItem");
WriteUUID(writer, "AssetID", item.AssetID, options);
writer.WriteElementString("BasePermissions", item.BasePermissions.ToString());
writer.WriteElementString("CreationDate", item.CreationDate.ToString());
WriteUUID(writer, "CreatorID", item.CreatorID, options);
writer.WriteElementString("Description", item.Description);
writer.WriteElementString("EveryonePermissions", item.EveryonePermissions.ToString());
writer.WriteElementString("Flags", item.Flags.ToString());
WriteUUID(writer, "GroupID", item.GroupID, options);
writer.WriteElementString("GroupPermissions", item.GroupPermissions.ToString());
writer.WriteElementString("InvType", item.InvType.ToString());
WriteUUID(writer, "ItemID", item.ItemID, options);
WriteUUID(writer, "OldItemID", item.OldItemID, options);
WriteUUID(writer, "LastOwnerID", item.LastOwnerID, options);
writer.WriteElementString("Name", item.Name);
writer.WriteElementString("NextPermissions", item.NextPermissions.ToString());
WriteUUID(writer, "OwnerID", item.OwnerID, options);
writer.WriteElementString("CurrentPermissions", item.CurrentPermissions.ToString());
WriteUUID(writer, "ParentID", item.ParentID, options);
WriteUUID(writer, "ParentPartID", item.ParentPartID, options);
WriteUUID(writer, "PermsGranter", item.PermsGranter, options);
writer.WriteElementString("PermsMask", item.PermsMask.ToString());
writer.WriteElementString("Type", item.Type.ToString());
writer.WriteElementString("OwnerChanged", item.OwnerChanged.ToString().ToLower());
writer.WriteEndElement(); // TaskInventoryItem
}
writer.WriteEndElement(); // TaskInventory
}
}
private static void WriteTaskInventory(XmlTextWriter writer, TaskInventoryDictionary tinv,
Dictionary<string, object> options, IScene scene)
{
if (tinv.Count > 0) // otherwise skip this
{
writer.WriteStartElement("TaskInventory");
foreach (TaskInventoryItem item in tinv.Values)
{
writer.WriteStartElement("TaskInventoryItem");
WriteUUID(writer, "AssetID", item.AssetID, options);
writer.WriteElementString("BasePermissions", item.BasePermissions.ToString());
writer.WriteElementString("CreationDate", item.CreationDate.ToString());
WriteUUID(writer, "CreatorID", item.CreatorID, options);
if (!string.IsNullOrEmpty(item.CreatorData))
writer.WriteElementString("CreatorData", item.CreatorData);
/*else if (options.ContainsKey("profile"))
{
IUserFinder m_UserManagement = scene.RequestModuleInterface<IUserFinder>();
string name = m_UserManagement.GetUserName(item.CreatorID);
writer.WriteElementString("CreatorData",
(string) options["profile"] + "/" + item.CreatorID + ";" + name);
}
*/
writer.WriteElementString("Description", item.Description);
writer.WriteElementString("EveryonePermissions", item.EveryonePermissions.ToString());
writer.WriteElementString("Flags", item.Flags.ToString());
WriteUUID(writer, "GroupID", item.GroupID, options);
writer.WriteElementString("GroupPermissions", item.GroupPermissions.ToString());
writer.WriteElementString("InvType", item.InvType.ToString());
WriteUUID(writer, "ItemID", item.ItemID, options);
WriteUUID(writer, "OldItemID", item.OldItemID, options);
WriteUUID(writer, "LastOwnerID", item.LastOwnerID, options);
writer.WriteElementString("Name", item.Name);
writer.WriteElementString("NextPermissions", item.NextPermissions.ToString());
WriteUUID(writer, "OwnerID", item.OwnerID, options);
writer.WriteElementString("CurrentPermissions", item.CurrentPermissions.ToString());
WriteUUID(writer, "ParentID", item.ParentID, options);
WriteUUID(writer, "ParentPartID", item.ParentPartID, options);
WriteUUID(writer, "PermsGranter", item.PermsGranter, options);
writer.WriteElementString("PermsMask", item.PermsMask.ToString());
writer.WriteElementString("Type", item.Type.ToString());
writer.WriteElementString("OwnerChanged", item.OwnerChanged.ToString().ToLower());
writer.WriteEndElement(); // TaskInventoryItem
}
writer.WriteEndElement(); // TaskInventory
}
}
public void LoadModuleFromArchive(byte[] data, string filePath, TarArchiveReader.TarEntryType type, IScene scene)
{
if (filePath.StartsWith("parcels/"))
{
if (!m_merge)
{
//Only use if we are not merging
LandData parcel = new LandData();
OSD parcelData = OSDParser.DeserializeLLSDBinary(data);
parcel.FromOSD((OSDMap)parcelData);
m_parcels.Add(parcel);
}
}
#region New Style Terrain Loading
else if (filePath.StartsWith("newstyleterrain/"))
{
ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule>();
terrainModule.TerrainMap = ReadTerrain(data, scene);
}
else if (filePath.StartsWith("newstylerevertterrain/"))
{
ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule>();
terrainModule.TerrainRevertMap = ReadTerrain(data, scene);
}
else if (filePath.StartsWith("newstylewater/"))
{
ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule>();
terrainModule.TerrainWaterMap = ReadTerrain(data, scene);
}
else if (filePath.StartsWith("newstylerevertwater/"))
{
ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule>();
terrainModule.TerrainWaterRevertMap = ReadTerrain(data, scene);
}
#endregion
else if (filePath.StartsWith("terrain/"))
{
ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule>();
MemoryStream ms = new MemoryStream(data);
terrainModule.LoadFromStream(filePath, ms, 0, 0);
ms.Close();
}
else if (filePath.StartsWith("revertterrain/"))
{
ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule>();
MemoryStream ms = new MemoryStream(data);
terrainModule.LoadRevertMapFromStream(filePath, ms, 0, 0);
ms.Close();
}
else if (filePath.StartsWith("water/"))
{
ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule>();
MemoryStream ms = new MemoryStream(data);
terrainModule.LoadWaterFromStream(filePath, ms, 0, 0);
ms.Close();
}
else if (filePath.StartsWith("revertwater/"))
{
ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule>();
MemoryStream ms = new MemoryStream(data);
terrainModule.LoadWaterRevertMapFromStream(filePath, ms, 0, 0);
ms.Close();
}
else if (filePath.StartsWith("entities/"))
{
MemoryStream ms = new MemoryStream(data);
SceneObjectGroup sceneObject = OpenSim.Region.Framework.Scenes.Serialization.SceneObjectSerializer.FromXml2Format(ref ms, scene);
ms.Close();
ms = null;
data = null;
foreach (ISceneChildEntity part in sceneObject.ChildrenEntities())
{
if (!ResolveUserUuid(part.CreatorID))
{
part.CreatorID = m_scene.RegionInfo.EstateSettings.EstateOwner;
}
if (!ResolveUserUuid(part.OwnerID))
{
part.OwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;
}
if (!ResolveUserUuid(part.LastOwnerID))
{
part.LastOwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;
}
// Fix ownership/creator of inventory items
// Not doing so results in inventory items
// being no copy/no mod for everyone
lock (part.TaskInventory)
{
TaskInventoryDictionary inv = part.TaskInventory;
foreach (KeyValuePair <UUID, TaskInventoryItem> kvp in inv)
{
if (!ResolveUserUuid(kvp.Value.OwnerID))
{
kvp.Value.OwnerID = scene.RegionInfo.EstateSettings.EstateOwner;
}
if (!ResolveUserUuid(kvp.Value.CreatorID))
{
kvp.Value.CreatorID = scene.RegionInfo.EstateSettings.EstateOwner;
}
}
}
}
if (scene.SceneGraph.AddPrimToScene(sceneObject))
{
sceneObject.HasGroupChanged = true;
sceneObject.ScheduleGroupUpdate(PrimUpdateFlags.ForcedFullUpdate);
sceneObject.CreateScriptInstances(0, false, StateSource.RegionStart, UUID.Zero);
}
}
else if (filePath.StartsWith("assets/"))
{
if (m_loadAssets)
{
AssetBase asset = new AssetBase();
asset.Unpack(OSDParser.DeserializeJson(Encoding.UTF8.GetString(data)));
bool exists = scene.AssetService.Get(asset.IDString) != null;
if (!exists)
{
scene.AssetService.Store(asset);
}
}
}
}
/// <summary>
/// This isn't really an LSL function, just a way to merge llRezAtRoot and llRezObject into one
/// </summary>
/// <param name="inventory"></param>
/// <param name="pos"></param>
/// <param name="vel"></param>
/// <param name="rot"></param>
/// <param name="param"></param>
/// <param name="isRezAtRoot"></param>
/// <param name="doRecoil"></param>
/// <param name="setDieAtEdge"></param>
/// <param name="checkPos"></param>
/// <returns></returns>
public DateTime llRezPrim(string inventory, LSL_Vector pos, LSL_Vector vel,
LSL_Rotation rot, int param, bool isRezAtRoot, bool doRecoil,
bool setDieAtEdge, bool checkPos)
{
if (!ScriptProtection.CheckThreatLevel(ThreatLevel.Low, "llRezPrim", m_host, "LSL", m_itemID))
{
return(DateTime.Now);
}
if (m_ScriptEngine.Config.GetBoolean("AllowllRezObject", true))
{
if (double.IsNaN(rot.x) || double.IsNaN(rot.y) || double.IsNaN(rot.z) || double.IsNaN(rot.s))
{
return(DateTime.Now);
}
if (checkPos)
{
float dist = (float)llVecDist(llGetPos(), pos);
if (dist > m_ScriptDistanceFactor * 10.0f)
{
return(DateTime.Now);
}
}
TaskInventoryDictionary partInventory = (TaskInventoryDictionary)m_host.TaskInventory.Clone();
foreach (KeyValuePair <UUID, TaskInventoryItem> inv in partInventory)
{
if (inv.Value.Name == inventory)
{
// make sure we're an object.
if (inv.Value.InvType != (int)InventoryType.Object)
{
llSay(0, "Unable to create requested object. Object is missing from database.");
return(DateTime.Now);
}
Vector3 llpos = new Vector3((float)pos.x, (float)pos.y, (float)pos.z);
Vector3 llvel = new Vector3((float)vel.x, (float)vel.y, (float)vel.z);
ISceneEntity new_group = RezObject(m_host, inv.Value, llpos, Rot2Quaternion(rot), llvel, param,
m_host.UUID, isRezAtRoot);
if (new_group == null)
{
continue;
}
new_group.OnFinishedPhysicalRepresentationBuilding +=
delegate() {
//Do this after the physics engine has built the prim
float groupmass = new_group.GetMass();
//Recoil to the av
if (m_host.IsAttachment &&
doRecoil &&
(new_group.RootChild.Flags & PrimFlags.Physics) == PrimFlags.Physics)
{
IScenePresence SP = m_host.ParentEntity.Scene.GetScenePresence(m_host.OwnerID);
if (SP != null)
{
//Push the av backwards (For every action, there is an equal, but opposite reaction)
Vector3 impulse = llvel * groupmass;
impulse.X = impulse.X <1 ? impulse.X : impulse.X> -1 ? impulse.X : -1;
impulse.Y = impulse.Y <1 ? impulse.Y : impulse.Y> -1 ? impulse.Y : -1;
impulse.Z = impulse.Z <1 ? impulse.Z : impulse.Z> -1 ? impulse.Z : -1;
SP.PushForce(impulse);
}
}
};
// If there was an unknown error.
if (new_group.RootChild == null)
{
continue;
}
// objects rezzed with this method are die_at_edge by default.
if (setDieAtEdge)
{
new_group.RootChild.SetDieAtEdge(true);
}
// Variable script delay? (see (http://wiki.secondlife.com/wiki/LSL_Delay)
return(PScriptSleep(m_sleepMsOnRezAtRoot));
}
}
llSay(0, "Could not find object " + inventory);
}
return(DateTime.Now);
}
static TaskInventoryDictionary ReadTaskInventory(XmlTextReader reader, string name)
{
TaskInventoryDictionary tinv = new TaskInventoryDictionary();
reader.ReadStartElement(name, String.Empty);
if (reader.IsEmptyElement)
{
reader.Read();
return tinv;
}
while (reader.Name == "TaskInventoryItem")
{
reader.ReadStartElement("TaskInventoryItem", String.Empty); // TaskInventory
TaskInventoryItem item = new TaskInventoryItem();
while (reader.NodeType != XmlNodeType.EndElement)
{
TaskInventoryXmlProcessor p = null;
if (m_TaskInventoryXmlProcessors.TryGetValue(reader.Name, out p))
p(item, reader);
else
{
// m_log.DebugFormat("[SceneObjectSerializer]: caught unknown element in TaskInventory {0}, {1}", reader.Name, reader.Value);
reader.ReadOuterXml();
}
}
reader.ReadEndElement(); // TaskInventoryItem
tinv.Add(item.ItemID, item);
}
if (reader.NodeType == XmlNodeType.EndElement)
reader.ReadEndElement(); // TaskInventory
return tinv;
}
private void DearchiveRegion0DotStar()
{
int successfulAssetRestores = 0;
int failedAssetRestores = 0;
//List<string> serialisedSceneObjects = new List<string>();
List <string> serialisedParcels = new List <string>();
string filePath = "NONE";
DateTime start = DateTime.Now;
TarArchiveReader archive = new TarArchiveReader(m_loadStream);
byte[] data;
TarArchiveReader.TarEntryType entryType;
if (!m_skipAssets)
{
m_threadpool = new Aurora.Framework.AuroraThreadPool(new Aurora.Framework.AuroraThreadPoolStartInfo()
{
Threads = 1,
priority = System.Threading.ThreadPriority.BelowNormal
});
}
IBackupModule backup = m_scene.RequestModuleInterface <IBackupModule>();
if (!m_merge)
{
DateTime before = DateTime.Now;
m_log.Info("[ARCHIVER]: Clearing all existing scene objects");
if (backup != null)
{
backup.DeleteAllSceneObjects();
}
m_log.Info("[ARCHIVER]: Cleared all existing scene objects in " + (DateTime.Now - before).Minutes + ":" + (DateTime.Now - before).Seconds);
}
IScriptModule[] modules = m_scene.RequestModuleInterfaces <IScriptModule>();
//Disable the script engine so that it doesn't load in the background and kill OAR loading
foreach (IScriptModule module in modules)
{
module.Disabled = true;
}
//Disable backup for now as well
if (backup != null)
{
backup.LoadingPrims = true;
}
IRegionSerialiserModule serialiser = m_scene.RequestModuleInterface <IRegionSerialiserModule>();
int sceneObjectsLoadedCount = 0;
//We save the groups so that we can back them up later
List <SceneObjectGroup> groupsToBackup = new List <SceneObjectGroup>();
try
{
while ((data = archive.ReadEntry(out filePath, out entryType)) != null)
{
//m_log.DebugFormat(
// "[ARCHIVER]: Successfully read {0} ({1} bytes)", filePath, data.Length);
if (TarArchiveReader.TarEntryType.TYPE_DIRECTORY == entryType)
{
continue;
}
if (filePath.StartsWith(ArchiveConstants.OBJECTS_PATH))
{
string sogdata = m_utf8Encoding.GetString(data);
//serialisedSceneObjects.Add(m_utf8Encoding.GetString(data));
/*
* m_log.DebugFormat("[ARCHIVER]: Loading xml with raw size {0}", serialisedSceneObject.Length);
*
* // Really large xml files (multi megabyte) appear to cause
* // memory problems
* // when loading the xml. But don't enable this check yet
*
* if (serialisedSceneObject.Length > 5000000)
* {
* m_log.Error("[ARCHIVER]: Ignoring xml since size > 5000000);");
* continue;
* }
*/
string serialisedSceneObject = sogdata;
SceneObjectGroup sceneObject = (SceneObjectGroup)serialiser.DeserializeGroupFromXml2(serialisedSceneObject, m_scene);
if (sceneObject == null)
{
//! big error!
m_log.Error("Error reading SOP XML (Please mantis this!): " + serialisedSceneObject);
continue;
}
foreach (SceneObjectPart part in sceneObject.ChildrenList)
{
if (!ResolveUserUuid(part.CreatorID))
{
part.CreatorID = m_scene.RegionInfo.EstateSettings.EstateOwner;
}
if (!ResolveUserUuid(part.OwnerID))
{
part.OwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;
}
if (!ResolveUserUuid(part.LastOwnerID))
{
part.LastOwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;
}
// And zap any troublesome sit target information
part.SitTargetOrientation = new Quaternion(0, 0, 0, 1);
part.SitTargetPosition = new Vector3(0, 0, 0);
// Fix ownership/creator of inventory items
// Not doing so results in inventory items
// being no copy/no mod for everyone
lock (part.TaskInventory)
{
TaskInventoryDictionary inv = part.TaskInventory;
foreach (KeyValuePair <UUID, TaskInventoryItem> kvp in inv)
{
if (!ResolveUserUuid(kvp.Value.OwnerID))
{
kvp.Value.OwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;
}
if (!ResolveUserUuid(kvp.Value.CreatorID))
{
kvp.Value.CreatorID = m_scene.RegionInfo.EstateSettings.EstateOwner;
}
}
}
}
//Add the offsets of the region
Vector3 newPos = new Vector3(sceneObject.AbsolutePosition.X + m_offsetX,
sceneObject.AbsolutePosition.Y + m_offsetY,
sceneObject.AbsolutePosition.Z + m_offsetZ);
if (m_flipX)
{
newPos.X = m_scene.RegionInfo.RegionSizeX - newPos.X;
}
if (m_flipY)
{
newPos.Y = m_scene.RegionInfo.RegionSizeY - newPos.Y;
}
sceneObject.SetAbsolutePosition(false, newPos);
if (m_scene.SceneGraph.AddPrimToScene(sceneObject))
{
groupsToBackup.Add(sceneObject);
sceneObject.ScheduleGroupUpdate(PrimUpdateFlags.FullUpdate);
sceneObjectsLoadedCount++;
sceneObject.CreateScriptInstances(0, false, 0, UUID.Zero);
sceneObject.ResumeScripts();
}
sceneObjectsLoadedCount++;
if (sceneObjectsLoadedCount % 250 == 0)
{
m_log.Debug("[ARCHIVER]: Loaded " + sceneObjectsLoadedCount + " objects...");
}
}
else if (filePath.StartsWith(ArchiveConstants.ASSETS_PATH))
{
if (!m_skipAssets)
{
if (LoadAsset(filePath, data))
{
successfulAssetRestores++;
}
else
{
failedAssetRestores++;
}
if ((successfulAssetRestores + failedAssetRestores) % 250 == 0)
{
m_log.Debug("[ARCHIVER]: Loaded " + successfulAssetRestores + " assets and failed to load " + failedAssetRestores + " assets...");
}
}
}
else if (!m_merge && filePath.StartsWith(ArchiveConstants.TERRAINS_PATH))
{
LoadTerrain(filePath, data);
}
else if (!m_merge && filePath.StartsWith(ArchiveConstants.SETTINGS_PATH))
{
LoadRegionSettings(filePath, data);
}
else if (!m_merge && filePath.StartsWith(ArchiveConstants.LANDDATA_PATH))
{
serialisedParcels.Add(m_utf8Encoding.GetString(data));
}
else if (filePath == ArchiveConstants.CONTROL_FILE_PATH)
{
LoadControlFile(filePath, data);
}
else
{
m_log.Debug("[ARCHIVER]:UNKNOWN PATH: " + filePath);
}
}
//m_log.Debug("[ARCHIVER]: Reached end of archive");
}
catch (Exception e)
{
m_log.ErrorFormat(
"[ARCHIVER]: Aborting load with error in archive file {0}. {1}", filePath, e);
m_errorMessage += e.ToString();
m_scene.EventManager.TriggerOarFileLoaded(UUID.Zero.Guid, m_errorMessage);
return;
}
finally
{
archive.Close();
m_loadStream.Close();
m_loadStream.Dispose();
}
//Reeanble now that we are done
foreach (IScriptModule module in modules)
{
module.Disabled = false;
}
//Reset backup too
if (backup != null)
{
backup.LoadingPrims = false;
}
//Now back up the prims
foreach (SceneObjectGroup grp in groupsToBackup)
{
//Backup!
grp.HasGroupChanged = true;
}
if (!m_skipAssets)
{
if (m_useAsync && !AssetSaverIsRunning)
{
m_threadpool.QueueEvent(SaveAssets, 0);
}
else if (!AssetSaverIsRunning)
{
SaveAssets();
}
}
if (!m_skipAssets)
{
m_log.InfoFormat("[ARCHIVER]: Restored {0} assets", successfulAssetRestores);
if (failedAssetRestores > 0)
{
m_log.ErrorFormat("[ARCHIVER]: Failed to load {0} assets", failedAssetRestores);
m_errorMessage += String.Format("Failed to load {0} assets", failedAssetRestores);
}
}
// Try to retain the original creator/owner/lastowner if their uuid is present on this grid
// otherwise, use the master avatar uuid instead
// Reload serialized parcels
m_log.InfoFormat("[ARCHIVER]: Loading {0} parcels. Please wait.", serialisedParcels.Count);
List <LandData> landData = new List <LandData>();
foreach (string serialisedParcel in serialisedParcels)
{
LandData parcel = LandDataSerializer.Deserialize(serialisedParcel);
if (!ResolveUserUuid(parcel.OwnerID))
{
parcel.OwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;
}
landData.Add(parcel);
}
m_scene.EventManager.TriggerIncomingLandDataFromStorage(landData);
//Update the database as well!
IParcelManagementModule parcelManagementModule = m_scene.RequestModuleInterface <IParcelManagementModule>();
if (parcelManagementModule != null)
{
foreach (LandData parcel in landData)
{
parcelManagementModule.UpdateLandObject(parcel.LocalID, parcel);
}
}
m_log.InfoFormat("[ARCHIVER]: Restored {0} parcels.", landData.Count);
//Clean it out
landData.Clear();
serialisedParcels.Clear();
m_log.InfoFormat("[ARCHIVER]: Successfully loaded archive in " + (DateTime.Now - start).Minutes + ":" + (DateTime.Now - start).Seconds);
m_validUserUuids.Clear();
m_scene.EventManager.TriggerOarFileLoaded(UUID.Zero.Guid, m_errorMessage);
}
public static TaskInventoryDictionary ReadTaskInventory(XmlTextReader reader, string name)
{
TaskInventoryDictionary tinv = new TaskInventoryDictionary();
if (reader.IsEmptyElement)
{
reader.Read();
return tinv;
}
reader.ReadStartElement(name, String.Empty);
while (reader.Name == "TaskInventoryItem")
{
reader.ReadStartElement("TaskInventoryItem", String.Empty); // TaskInventory
TaskInventoryItem item = new TaskInventoryItem();
ExternalRepresentationUtils.ExecuteReadProcessors(
item,
m_TaskInventoryXmlProcessors,
reader);
reader.ReadEndElement(); // TaskInventoryItem
tinv.Add(item.ItemID, item);
}
if (reader.NodeType == XmlNodeType.EndElement)
reader.ReadEndElement(); // TaskInventory
return tinv;
}
public void EndLoadModuleFromArchive(IScene scene)
{
IBackupModule backup = scene.RequestModuleInterface <IBackupModule> ();
IScriptModule [] modules = scene.RequestModuleInterfaces <IScriptModule> ();
//Reeanble now that we are done
foreach (IScriptModule module in modules)
{
module.Disabled = false;
}
//Reset backup too
if (backup != null)
{
backup.LoadingPrims = false;
}
//Update the database as well!
IParcelManagementModule parcelManagementModule = scene.RequestModuleInterface <IParcelManagementModule> ();
if (parcelManagementModule != null && !m_merge) //Only if we are not merging
{
if (m_parcels.Count > 0)
{
scene.EventManager.TriggerIncomingLandDataFromStorage(m_parcels, Vector2.Zero);
//Update the database as well!
foreach (LandData parcel in m_parcels)
{
parcelManagementModule.UpdateLandObject(parcelManagementModule.GetLandObject(parcel.LocalID));
}
}
else
{
parcelManagementModule.ResetSimLandObjects();
}
m_parcels.Clear();
}
foreach (ISceneEntity sceneObject in m_groups)
{
foreach (ISceneChildEntity part in sceneObject.ChildrenEntities())
{
if (!ResolveUserUuid(part.CreatorID))
{
part.CreatorID = m_scene.RegionInfo.EstateSettings.EstateOwner;
}
if (!ResolveUserUuid(part.OwnerID))
{
part.OwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;
}
if (!ResolveUserUuid(part.LastOwnerID))
{
part.LastOwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;
}
// Fix ownership/creator of inventory items
// Not doing so results in inventory items
// being no copy/no mod for everyone
lock (part.TaskInventory) {
TaskInventoryDictionary inv = part.TaskInventory;
foreach (KeyValuePair <UUID, TaskInventoryItem> kvp in inv)
{
if (!ResolveUserUuid(kvp.Value.OwnerID))
{
kvp.Value.OwnerID = scene.RegionInfo.EstateSettings.EstateOwner;
}
if (!ResolveUserUuid(kvp.Value.CreatorID))
{
kvp.Value.CreatorID = scene.RegionInfo.EstateSettings.EstateOwner;
}
}
}
}
if (scene.SceneGraph.AddPrimToScene(sceneObject))
{
sceneObject.HasGroupChanged = true;
sceneObject.ScheduleGroupUpdate(PrimUpdateFlags.ForcedFullUpdate);
sceneObject.CreateScriptInstances(0, false, StateSource.RegionStart, UUID.Zero, false);
}
}
}
/// <summary>
/// Gather all the asset uuids associated with a given object.
/// </summary>
/// <remarks>
/// This includes both those directly associated with
/// it (e.g. face textures) and recursively, those of items within it's inventory (e.g. objects contained
/// within this object).
/// </remarks>
/// <param name="sceneObject">The scene object for which to gather assets</param>
/// <param name="assetUuids">
/// 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)
{
// m_log.DebugFormat(
// "[ASSET GATHERER]: Getting assets for object {0}, {1}", sceneObject.Name, sceneObject.UUID);
SceneObjectPart[] parts = sceneObject.Parts;
for (int i = 0; i < parts.Length; i++)
{
SceneObjectPart part = parts[i];
// m_log.DebugFormat(
// "[ARCHIVER]: Getting part {0}, {1} for object {2}", part.Name, part.UUID, sceneObject.UUID);
try
{
Primitive.TextureEntry textureEntry = part.Shape.Textures;
if (textureEntry != null)
{
// 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;
}
if (textureEntry.FaceTextures != null)
{
// Loop through the rest of the texture faces (a non-null face means the face is different from DefaultTexture)
foreach (Primitive.TextureEntryFace texture in textureEntry.FaceTextures)
{
if (texture != null)
{
assetUuids[texture.TextureID] = 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;
}
TaskInventoryDictionary taskDictionary = (TaskInventoryDictionary)part.TaskInventory.Clone();
// Now analyze this prim's inventory items to preserve all the uuids that they reference
foreach (TaskInventoryItem tii in taskDictionary.Values)
{
// m_log.DebugFormat(
// "[ARCHIVER]: Analysing item {0} asset type {1} in {2} {3}",
// tii.Name, tii.Type, part.Name, part.UUID);
if (!assetUuids.ContainsKey(tii.AssetID))
{
GatherAssetUuids(tii.AssetID, (AssetType)tii.Type, assetUuids);
}
}
// FIXME: We need to make gathering modular but we cannot yet, since gatherers are not guaranteed
// to be called with scene objects that are in a scene (e.g. in the case of hg asset mapping and
// inventory transfer. There needs to be a way for a module to register a method without assuming a
// Scene.EventManager is present.
// part.ParentGroup.Scene.EventManager.TriggerGatherUuids(part, assetUuids);
GatherMaterialsUuids(part, assetUuids);
}
catch (Exception e)
{
m_log.ErrorFormat("[UUID GATHERER]: Failed to get part - {0}", e);
m_log.DebugFormat(
"[UUID GATHERER]: Texture entry length for prim was {0} (min is 46)",
part.Shape.TextureEntry.Length);
}
}
}
// This function replaces all the item IDs (UUIDs) of the group's inventory contents with new IDs,
// then returns a dictionary of the map[oldID] = newID.
public Dictionary<UUID, UUID> RemapItemIDs()
{
Dictionary<UUID, UUID> itemIDMap = new Dictionary<UUID, UUID>();
lock (m_parts)
{
foreach (SceneObjectPart part in m_parts.Values)
{
TaskInventoryDictionary newInventory = new TaskInventoryDictionary();
lock (part.TaskInventory)
{
foreach (KeyValuePair<UUID, TaskInventoryItem> inv in part.TaskInventory)
{
UUID oldID = new UUID(inv.Key);
UUID newID = UUID.Random();
TaskInventoryItem item = inv.Value;
itemIDMap[oldID] = newID;
item.ItemID = newID;
newInventory[newID] = item;
}
part.TaskInventory = newInventory;
}
}
}
return itemIDMap;
}
/// <summary>
/// Optionally modify a loaded SceneObjectGroup. Currently this just ensures that the
/// User IDs and Group IDs are valid, but other manipulations could be done as well.
/// </summary>
private void ModifySceneObject(Scene scene, SceneObjectGroup sceneObject)
{
// Try to retain the original creator/owner/lastowner if their uuid is present on this grid
// or creator data is present. Otherwise, use the estate owner instead.
foreach (SceneObjectPart part in sceneObject.Parts)
{
if (string.IsNullOrEmpty(part.CreatorData))
{
if (!ResolveUserUuid(scene, part.CreatorID))
{
part.CreatorID = m_defaultUser;
}
}
if (UserManager != null)
{
UserManager.AddUser(part.CreatorID, part.CreatorData);
}
if (!(ResolveUserUuid(scene, part.OwnerID) || ResolveGroupUuid(part.OwnerID)))
{
part.OwnerID = m_defaultUser;
}
if (!(ResolveUserUuid(scene, part.LastOwnerID) || ResolveGroupUuid(part.LastOwnerID)))
{
part.LastOwnerID = m_defaultUser;
}
if (!ResolveGroupUuid(part.GroupID))
{
part.GroupID = UUID.Zero;
}
// And zap any troublesome sit target information
// part.SitTargetOrientation = new Quaternion(0, 0, 0, 1);
// part.SitTargetPosition = new Vector3(0, 0, 0);
// Fix ownership/creator of inventory items
// Not doing so results in inventory items
// being no copy/no mod for everyone
lock (part.TaskInventory)
{
TaskInventoryDictionary inv = part.TaskInventory;
foreach (KeyValuePair <UUID, TaskInventoryItem> kvp in inv)
{
if (!(ResolveUserUuid(scene, kvp.Value.OwnerID) || ResolveGroupUuid(kvp.Value.OwnerID)))
{
kvp.Value.OwnerID = m_defaultUser;
}
if (string.IsNullOrEmpty(kvp.Value.CreatorData))
{
if (!ResolveUserUuid(scene, kvp.Value.CreatorID))
{
kvp.Value.CreatorID = m_defaultUser;
}
}
if (UserManager != null)
{
UserManager.AddUser(kvp.Value.CreatorID, kvp.Value.CreatorData);
}
if (!ResolveGroupUuid(kvp.Value.GroupID))
{
kvp.Value.GroupID = UUID.Zero;
}
}
}
}
}
/// <summary>
/// Gather all the asset uuids associated with a given object.
/// </summary>
///
/// This includes both those directly associated with
/// it (e.g. face textures) and recursively, those of items within it's inventory (e.g. objects contained
/// within this object).
///
/// <param name="sceneObject">The scene object for which to gather assets</param>
/// <param name="assetUuids">The assets gathered</param>
public void GatherAssetUuids(SceneObjectGroup sceneObject, IDictionary <UUID, AssetType> assetUuids)
{
// m_log.DebugFormat(
// "[ASSET GATHERER]: Getting assets for object {0}, {1}", sceneObject.Name, sceneObject.UUID);
SceneObjectPart[] parts = sceneObject.Parts;
for (int i = 0; i < parts.Length; i++)
{
SceneObjectPart part = parts[i];
// m_log.DebugFormat(
// "[ARCHIVER]: Getting part {0}, {1} for object {2}", part.Name, part.UUID, sceneObject.UUID);
try
{
Primitive.TextureEntry textureEntry = part.Shape.Textures;
if (textureEntry != null)
{
// 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;
}
if (textureEntry.FaceTextures != null)
{
// Loop through the rest of the texture faces (a non-null face means the face is different from DefaultTexture)
foreach (Primitive.TextureEntryFace texture in textureEntry.FaceTextures)
{
if (texture != null)
{
assetUuids[texture.TextureID] = 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;
}
TaskInventoryDictionary taskDictionary = (TaskInventoryDictionary)part.TaskInventory.Clone();
// Now analyze this prim's inventory items to preserve all the uuids that they reference
foreach (TaskInventoryItem tii in taskDictionary.Values)
{
// m_log.DebugFormat(
// "[ARCHIVER]: Analysing item {0} asset type {1} in {2} {3}",
// tii.Name, tii.Type, part.Name, part.UUID);
if (!assetUuids.ContainsKey(tii.AssetID))
{
GatherAssetUuids(tii.AssetID, (AssetType)tii.Type, assetUuids);
}
}
}
catch (Exception e)
{
m_log.ErrorFormat("[UUID GATHERER]: Failed to get part - {0}", e);
m_log.DebugFormat(
"[UUID GATHERER]: Texture entry length for prim was {0} (min is 46)",
part.Shape.TextureEntry.Length);
}
}
}
public void T013_DatabasePersistency()
{
// Sets all ScenePart parameters, stores and retrieves them, then check for consistency with initial data
// The commented Asserts are the ones that are unchangeable (when storing on the database, their "Set" values are ignored
// The ObjectFlags is an exception, if it is entered incorrectly, the object IS REJECTED on the database silently.
UUID creator,uuid = new UUID();
creator = UUID.Random();
uint iserial = (uint)random.Next();
TaskInventoryDictionary dic = new TaskInventoryDictionary();
uint objf = (uint) random.Next();
uuid = prim4;
uint localid = localID+1;
localID = localID + 1;
string name = "Adam West";
byte material = (byte) random.Next(127);
ulong regionh = (ulong)random.NextDouble() * (ulong)random.Next();
int pin = random.Next();
Byte[] partsys = new byte[8];
Byte[] textani = new byte[8];
random.NextBytes(textani);
random.NextBytes(partsys);
DateTime expires = new DateTime(2008, 12, 20);
DateTime rezzed = new DateTime(2009, 07, 15);
Vector3 groupos = new Vector3(random.Next(),random.Next(),random.Next());
Vector3 offset = new Vector3(random.Next(),random.Next(),random.Next());
Quaternion rotoff = new Quaternion(random.Next(),random.Next(),random.Next(),random.Next());
Vector3 velocity = new Vector3(random.Next(),random.Next(),random.Next());
Vector3 angvelo = new Vector3(random.Next(),random.Next(),random.Next());
Vector3 accel = new Vector3(random.Next(),random.Next(),random.Next());
string description = name;
Color color = Color.FromArgb(255, 165, 50, 100);
string text = "All Your Base Are Belong to Us";
string sitname = "SitName";
string touchname = "TouchName";
int linknum = random.Next();
byte clickaction = (byte) random.Next(127);
PrimitiveBaseShape pbshap = new PrimitiveBaseShape();
pbshap = PrimitiveBaseShape.Default;
pbshap.PathBegin = ushort.MaxValue;
pbshap.PathEnd = ushort.MaxValue;
pbshap.ProfileBegin = ushort.MaxValue;
pbshap.ProfileEnd = ushort.MaxValue;
pbshap.ProfileHollow = ushort.MaxValue;
Vector3 scale = new Vector3(random.Next(),random.Next(),random.Next());
byte updatef = (byte) random.Next(127);
RegionInfo regionInfo = new RegionInfo();
regionInfo.RegionID = region3;
regionInfo.RegionLocX = 0;
regionInfo.RegionLocY = 0;
Scene scene = new Scene(regionInfo);
SceneObjectPart sop = new SceneObjectPart();
sop.RegionHandle = regionh;
sop.UUID = uuid;
sop.LocalId = localid;
sop.Shape = pbshap;
sop.GroupPosition = groupos;
sop.RotationOffset = rotoff;
sop.CreatorID = creator;
sop.InventorySerial = iserial;
sop.TaskInventory = dic;
sop.ObjectFlags = objf;
sop.Name = name;
sop.Material = material;
sop.ScriptAccessPin = pin;
sop.TextureAnimation = textani;
sop.ParticleSystem = partsys;
sop.Expires = expires;
sop.Rezzed = rezzed;
sop.OffsetPosition = offset;
sop.Velocity = velocity;
sop.AngularVelocity = angvelo;
sop.Acceleration = accel;
sop.Description = description;
sop.Color = color;
sop.Text = text;
sop.SitName = sitname;
sop.TouchName = touchname;
sop.LinkNum = linknum;
sop.ClickAction = clickaction;
sop.Scale = scale;
sop.UpdateFlag = updatef;
//Tests if local part accepted the parameters:
Assert.That(regionh,Is.EqualTo(sop.RegionHandle), "Assert.That(regionh,Is.EqualTo(sop.RegionHandle))");
Assert.That(localid,Is.EqualTo(sop.LocalId), "Assert.That(localid,Is.EqualTo(sop.LocalId))");
Assert.That(groupos,Is.EqualTo(sop.GroupPosition), "Assert.That(groupos,Is.EqualTo(sop.GroupPosition))");
Assert.That(name,Is.EqualTo(sop.Name), "Assert.That(name,Is.EqualTo(sop.Name))");
Assert.That(rotoff,Is.EqualTo(sop.RotationOffset), "Assert.That(rotoff,Is.EqualTo(sop.RotationOffset))");
Assert.That(uuid,Is.EqualTo(sop.UUID), "Assert.That(uuid,Is.EqualTo(sop.UUID))");
Assert.That(creator,Is.EqualTo(sop.CreatorID), "Assert.That(creator,Is.EqualTo(sop.CreatorID))");
// Modified in-class
// Assert.That(iserial,Is.EqualTo(sop.InventorySerial), "Assert.That(iserial,Is.EqualTo(sop.InventorySerial))");
Assert.That(dic,Is.EqualTo(sop.TaskInventory), "Assert.That(dic,Is.EqualTo(sop.TaskInventory))");
Assert.That(objf,Is.EqualTo(sop.ObjectFlags), "Assert.That(objf,Is.EqualTo(sop.ObjectFlags))");
Assert.That(name,Is.EqualTo(sop.Name), "Assert.That(name,Is.EqualTo(sop.Name))");
Assert.That(material,Is.EqualTo(sop.Material), "Assert.That(material,Is.EqualTo(sop.Material))");
Assert.That(pin,Is.EqualTo(sop.ScriptAccessPin), "Assert.That(pin,Is.EqualTo(sop.ScriptAccessPin))");
Assert.That(textani,Is.EqualTo(sop.TextureAnimation), "Assert.That(textani,Is.EqualTo(sop.TextureAnimation))");
Assert.That(partsys,Is.EqualTo(sop.ParticleSystem), "Assert.That(partsys,Is.EqualTo(sop.ParticleSystem))");
Assert.That(expires,Is.EqualTo(sop.Expires), "Assert.That(expires,Is.EqualTo(sop.Expires))");
Assert.That(rezzed,Is.EqualTo(sop.Rezzed), "Assert.That(rezzed,Is.EqualTo(sop.Rezzed))");
Assert.That(offset,Is.EqualTo(sop.OffsetPosition), "Assert.That(offset,Is.EqualTo(sop.OffsetPosition))");
Assert.That(velocity,Is.EqualTo(sop.Velocity), "Assert.That(velocity,Is.EqualTo(sop.Velocity))");
Assert.That(angvelo,Is.EqualTo(sop.AngularVelocity), "Assert.That(angvelo,Is.EqualTo(sop.AngularVelocity))");
Assert.That(accel,Is.EqualTo(sop.Acceleration), "Assert.That(accel,Is.EqualTo(sop.Acceleration))");
Assert.That(description,Is.EqualTo(sop.Description), "Assert.That(description,Is.EqualTo(sop.Description))");
Assert.That(color,Is.EqualTo(sop.Color), "Assert.That(color,Is.EqualTo(sop.Color))");
Assert.That(text,Is.EqualTo(sop.Text), "Assert.That(text,Is.EqualTo(sop.Text))");
Assert.That(sitname,Is.EqualTo(sop.SitName), "Assert.That(sitname,Is.EqualTo(sop.SitName))");
Assert.That(touchname,Is.EqualTo(sop.TouchName), "Assert.That(touchname,Is.EqualTo(sop.TouchName))");
Assert.That(linknum,Is.EqualTo(sop.LinkNum), "Assert.That(linknum,Is.EqualTo(sop.LinkNum))");
Assert.That(clickaction,Is.EqualTo(sop.ClickAction), "Assert.That(clickaction,Is.EqualTo(sop.ClickAction))");
Assert.That(scale,Is.EqualTo(sop.Scale), "Assert.That(scale,Is.EqualTo(sop.Scale))");
Assert.That(updatef,Is.EqualTo(sop.UpdateFlag), "Assert.That(updatef,Is.EqualTo(sop.UpdateFlag))");
// This is necessary or object will not be inserted in DB
sop.ObjectFlags = 0;
SceneObjectGroup sog = new SceneObjectGroup(sop);
// Inserts group in DB
db.StoreObject(sog,region3);
List<SceneObjectGroup> sogs = db.LoadObjects(region3);
Assert.That(sogs.Count, Is.EqualTo(1), "Assert.That(sogs.Count, Is.EqualTo(1))");
// Makes sure there are no double insertions:
db.StoreObject(sog,region3);
sogs = db.LoadObjects(region3);
Assert.That(sogs.Count, Is.EqualTo(1), "Assert.That(sogs.Count, Is.EqualTo(1))");
// Tests if the parameters were inserted correctly
SceneObjectPart p = sogs[0].RootPart;
Assert.That(regionh,Is.EqualTo(p.RegionHandle), "Assert.That(regionh,Is.EqualTo(p.RegionHandle))");
//Assert.That(localid,Is.EqualTo(p.LocalId), "Assert.That(localid,Is.EqualTo(p.LocalId))");
Assert.That(groupos,Is.EqualTo(p.GroupPosition), "Assert.That(groupos,Is.EqualTo(p.GroupPosition))");
Assert.That(name,Is.EqualTo(p.Name), "Assert.That(name,Is.EqualTo(p.Name))");
Assert.That(rotoff,Is.EqualTo(p.RotationOffset), "Assert.That(rotoff,Is.EqualTo(p.RotationOffset))");
Assert.That(uuid,Is.EqualTo(p.UUID), "Assert.That(uuid,Is.EqualTo(p.UUID))");
Assert.That(creator,Is.EqualTo(p.CreatorID), "Assert.That(creator,Is.EqualTo(p.CreatorID))");
//Assert.That(iserial,Is.EqualTo(p.InventorySerial), "Assert.That(iserial,Is.EqualTo(p.InventorySerial))");
Assert.That(dic,Is.EqualTo(p.TaskInventory), "Assert.That(dic,Is.EqualTo(p.TaskInventory))");
//Assert.That(objf,Is.EqualTo(p.ObjectFlags), "Assert.That(objf,Is.EqualTo(p.ObjectFlags))");
Assert.That(name,Is.EqualTo(p.Name), "Assert.That(name,Is.EqualTo(p.Name))");
Assert.That(material,Is.EqualTo(p.Material), "Assert.That(material,Is.EqualTo(p.Material))");
Assert.That(pin,Is.EqualTo(p.ScriptAccessPin), "Assert.That(pin,Is.EqualTo(p.ScriptAccessPin))");
Assert.That(textani,Is.EqualTo(p.TextureAnimation), "Assert.That(textani,Is.EqualTo(p.TextureAnimation))");
Assert.That(partsys,Is.EqualTo(p.ParticleSystem), "Assert.That(partsys,Is.EqualTo(p.ParticleSystem))");
//Assert.That(expires,Is.EqualTo(p.Expires), "Assert.That(expires,Is.EqualTo(p.Expires))");
//Assert.That(rezzed,Is.EqualTo(p.Rezzed), "Assert.That(rezzed,Is.EqualTo(p.Rezzed))");
Assert.That(offset,Is.EqualTo(p.OffsetPosition), "Assert.That(offset,Is.EqualTo(p.OffsetPosition))");
Assert.That(velocity,Is.EqualTo(p.Velocity), "Assert.That(velocity,Is.EqualTo(p.Velocity))");
Assert.That(angvelo,Is.EqualTo(p.AngularVelocity), "Assert.That(angvelo,Is.EqualTo(p.AngularVelocity))");
Assert.That(accel,Is.EqualTo(p.Acceleration), "Assert.That(accel,Is.EqualTo(p.Acceleration))");
Assert.That(description,Is.EqualTo(p.Description), "Assert.That(description,Is.EqualTo(p.Description))");
Assert.That(color,Is.EqualTo(p.Color), "Assert.That(color,Is.EqualTo(p.Color))");
Assert.That(text,Is.EqualTo(p.Text), "Assert.That(text,Is.EqualTo(p.Text))");
Assert.That(sitname,Is.EqualTo(p.SitName), "Assert.That(sitname,Is.EqualTo(p.SitName))");
Assert.That(touchname,Is.EqualTo(p.TouchName), "Assert.That(touchname,Is.EqualTo(p.TouchName))");
//Assert.That(linknum,Is.EqualTo(p.LinkNum), "Assert.That(linknum,Is.EqualTo(p.LinkNum))");
Assert.That(clickaction,Is.EqualTo(p.ClickAction), "Assert.That(clickaction,Is.EqualTo(p.ClickAction))");
Assert.That(scale,Is.EqualTo(p.Scale), "Assert.That(scale,Is.EqualTo(p.Scale))");
//Assert.That(updatef,Is.EqualTo(p.UpdateFlag), "Assert.That(updatef,Is.EqualTo(p.UpdateFlag))");
Assert.That(pbshap.PathBegin, Is.EqualTo(p.Shape.PathBegin), "Assert.That(pbshap.PathBegin, Is.EqualTo(p.Shape.PathBegin))");
Assert.That(pbshap.PathEnd, Is.EqualTo(p.Shape.PathEnd), "Assert.That(pbshap.PathEnd, Is.EqualTo(p.Shape.PathEnd))");
Assert.That(pbshap.ProfileBegin, Is.EqualTo(p.Shape.ProfileBegin), "Assert.That(pbshap.ProfileBegin, Is.EqualTo(p.Shape.ProfileBegin))");
Assert.That(pbshap.ProfileEnd, Is.EqualTo(p.Shape.ProfileEnd), "Assert.That(pbshap.ProfileEnd, Is.EqualTo(p.Shape.ProfileEnd))");
Assert.That(pbshap.ProfileHollow, Is.EqualTo(p.Shape.ProfileHollow), "Assert.That(pbshap.ProfileHollow, Is.EqualTo(p.Shape.ProfileHollow))");
}
/// <summary>
/// Gather all the asset uuids associated with a given object.
/// </summary>
/// <remarks>
/// This includes both those directly associated with
/// it (e.g. face textures) and recursively, those of items within it's inventory (e.g. objects contained
/// within this object).
/// </remarks>
/// <param name="sceneObject">The scene object for which to gather assets</param>
public void AddForInspection(SceneObjectGroup sceneObject)
{
// m_log.DebugFormat(
// "[ASSET GATHERER]: Getting assets for object {0}, {1}", sceneObject.Name, sceneObject.UUID);
SceneObjectPart[] parts = sceneObject.Parts;
for (int i = 0; i < parts.Length; i++)
{
SceneObjectPart part = parts[i];
// m_log.DebugFormat(
// "[ARCHIVER]: Getting part {0}, {1} for object {2}", part.Name, part.UUID, sceneObject.UUID);
try
{
Primitive.TextureEntry textureEntry = part.Shape.Textures;
if (textureEntry != null)
{
// Get the prim's default texture. This will be used for faces which don't have their own texture
if (textureEntry.DefaultTexture != null)
{
RecordTextureEntryAssetUuids(textureEntry.DefaultTexture);
}
if (textureEntry.FaceTextures != null)
{
// Loop through the rest of the texture faces (a non-null face means the face is different from DefaultTexture)
foreach (Primitive.TextureEntryFace texture in textureEntry.FaceTextures)
{
if (texture != null)
{
RecordTextureEntryAssetUuids(texture);
}
}
}
}
// If the prim is a sculpt then preserve this information too
if (part.Shape.SculptTexture != UUID.Zero)
{
GatheredUuids[part.Shape.SculptTexture] = (sbyte)AssetType.Texture;
}
if (part.Shape.ProjectionTextureUUID != UUID.Zero)
{
GatheredUuids[part.Shape.ProjectionTextureUUID] = (sbyte)AssetType.Texture;
}
if (part.CollisionSound != UUID.Zero)
{
GatheredUuids[part.CollisionSound] = (sbyte)AssetType.Sound;
}
if (part.ParticleSystem.Length > 0)
{
try
{
Primitive.ParticleSystem ps = new Primitive.ParticleSystem(part.ParticleSystem, 0);
if (ps.Texture != UUID.Zero)
{
GatheredUuids[ps.Texture] = (sbyte)AssetType.Texture;
}
}
catch (Exception)
{
m_log.WarnFormat(
"[UUID GATHERER]: Could not check particle system for part {0} {1} in object {2} {3} since it is corrupt. Continuing.",
part.Name, part.UUID, sceneObject.Name, sceneObject.UUID);
}
}
TaskInventoryDictionary taskDictionary = (TaskInventoryDictionary)part.TaskInventory.Clone();
// Now analyze this prim's inventory items to preserve all the uuids that they reference
foreach (TaskInventoryItem tii in taskDictionary.Values)
{
// m_log.DebugFormat(
// "[ARCHIVER]: Analysing item {0} asset type {1} in {2} {3}",
// tii.Name, tii.Type, part.Name, part.UUID);
if (!GatheredUuids.ContainsKey(tii.AssetID))
{
AddForInspection(tii.AssetID, (sbyte)tii.Type);
}
}
// FIXME: We need to make gathering modular but we cannot yet, since gatherers are not guaranteed
// to be called with scene objects that are in a scene (e.g. in the case of hg asset mapping and
// inventory transfer. There needs to be a way for a module to register a method without assuming a
// Scene.EventManager is present.
// part.ParentGroup.Scene.EventManager.TriggerGatherUuids(part, assetUuids);
// still needed to retrieve textures used as materials for any parts containing legacy materials stored in DynAttrs
RecordMaterialsUuids(part);
}
catch (Exception e)
{
m_log.ErrorFormat("[UUID GATHERER]: Failed to get part - {0}", e);
m_log.DebugFormat(
"[UUID GATHERER]: Texture entry length for prim was {0} (min is 46)",
part.Shape.TextureEntry.Length);
}
}
}
/// <summary>
/// Load serialized scene objects.
/// </summary>
protected void LoadObjects(Scene scene, List <string> serialisedSceneObjects, List <SceneObjectGroup> sceneObjects)
{
// Reload serialized prims
m_log.InfoFormat("[ARCHIVER]: Loading {0} scene objects. Please wait.", serialisedSceneObjects.Count);
UUID oldTelehubUUID = scene.RegionInfo.RegionSettings.TelehubObject;
IRegionSerialiserModule serialiser = scene.RequestModuleInterface <IRegionSerialiserModule>();
int sceneObjectsLoadedCount = 0;
foreach (string serialisedSceneObject in serialisedSceneObjects)
{
/*
* m_log.DebugFormat("[ARCHIVER]: Loading xml with raw size {0}", serialisedSceneObject.Length);
*
* // Really large xml files (multi megabyte) appear to cause
* // memory problems
* // when loading the xml. But don't enable this check yet
*
* if (serialisedSceneObject.Length > 5000000)
* {
* m_log.Error("[ARCHIVER]: Ignoring xml since size > 5000000);");
* continue;
* }
*/
SceneObjectGroup sceneObject = serialiser.DeserializeGroupFromXml2(serialisedSceneObject);
bool isTelehub = (sceneObject.UUID == oldTelehubUUID) && (oldTelehubUUID != UUID.Zero);
// For now, give all incoming scene objects new uuids. This will allow scenes to be cloned
// on the same region server and multiple examples a single object archive to be imported
// to the same scene (when this is possible).
sceneObject.ResetIDs();
if (isTelehub)
{
// Change the Telehub Object to the new UUID
scene.RegionInfo.RegionSettings.TelehubObject = sceneObject.UUID;
scene.RegionInfo.RegionSettings.Save();
oldTelehubUUID = UUID.Zero;
}
// Try to retain the original creator/owner/lastowner if their uuid is present on this grid
// or creator data is present. Otherwise, use the estate owner instead.
foreach (SceneObjectPart part in sceneObject.Parts)
{
if (part.CreatorData == null || part.CreatorData == string.Empty)
{
if (!ResolveUserUuid(scene, part.CreatorID))
{
part.CreatorID = scene.RegionInfo.EstateSettings.EstateOwner;
}
}
if (UserManager != null)
{
UserManager.AddUser(part.CreatorID, part.CreatorData);
}
if (!ResolveUserUuid(scene, part.OwnerID))
{
part.OwnerID = scene.RegionInfo.EstateSettings.EstateOwner;
}
if (!ResolveUserUuid(scene, part.LastOwnerID))
{
part.LastOwnerID = scene.RegionInfo.EstateSettings.EstateOwner;
}
if (!ResolveGroupUuid(part.GroupID))
{
part.GroupID = UUID.Zero;
}
// And zap any troublesome sit target information
// part.SitTargetOrientation = new Quaternion(0, 0, 0, 1);
// part.SitTargetPosition = new Vector3(0, 0, 0);
// Fix ownership/creator of inventory items
// Not doing so results in inventory items
// being no copy/no mod for everyone
lock (part.TaskInventory)
{
TaskInventoryDictionary inv = part.TaskInventory;
foreach (KeyValuePair <UUID, TaskInventoryItem> kvp in inv)
{
if (!ResolveUserUuid(scene, kvp.Value.OwnerID))
{
kvp.Value.OwnerID = scene.RegionInfo.EstateSettings.EstateOwner;
}
if (kvp.Value.CreatorData == null || kvp.Value.CreatorData == string.Empty)
{
if (!ResolveUserUuid(scene, kvp.Value.CreatorID))
{
kvp.Value.CreatorID = scene.RegionInfo.EstateSettings.EstateOwner;
}
}
if (UserManager != null)
{
UserManager.AddUser(kvp.Value.CreatorID, kvp.Value.CreatorData);
}
if (!ResolveGroupUuid(kvp.Value.GroupID))
{
kvp.Value.GroupID = UUID.Zero;
}
}
}
}
if (scene.AddRestoredSceneObject(sceneObject, true, false))
{
sceneObjectsLoadedCount++;
sceneObject.CreateScriptInstances(0, false, scene.DefaultScriptEngine, 0);
sceneObject.ResumeScripts();
}
}
m_log.InfoFormat("[ARCHIVER]: Restored {0} scene objects to the scene", sceneObjectsLoadedCount);
int ignoredObjects = serialisedSceneObjects.Count - sceneObjectsLoadedCount;
if (ignoredObjects > 0)
{
m_log.WarnFormat("[ARCHIVER]: Ignored {0} scene objects that already existed in the scene", ignoredObjects);
}
if (oldTelehubUUID != UUID.Zero)
{
m_log.WarnFormat("Telehub object not found: {0}", oldTelehubUUID);
scene.RegionInfo.RegionSettings.TelehubObject = UUID.Zero;
scene.RegionInfo.RegionSettings.ClearSpawnPoints();
}
}
/// <summary>
/// Gather all the asset uuids associated with a given object.
/// </summary>
/// This includes both those directly associated with
/// it (e.g. face textures) and recursively, those of items within it's inventory (e.g. objects contained
/// within this object).
/// <param name = "sceneObject">The scene object for which to gather assets</param>
/// <param name = "assetUuids">The assets gathered</param>
public void GatherAssetUuids(ISceneEntity sceneObject, IDictionary <UUID, AssetType> assetUuids,
IRegistryCore scene)
{
// MainConsole.Instance.DebugFormat(
// "[ASSET GATHERER]: Getting assets for object {0}, {1}", sceneObject.Name, sceneObject.UUID);
ISceneChildEntity[] parts = sceneObject.ChildrenEntities().ToArray();
foreach (ISceneChildEntity part in parts)
{
// MainConsole.Instance.DebugFormat(
// "[ARCHIVER]: Getting part {0}, {1} for object {2}", part.Name, part.UUID, sceneObject.UUID);
try
{
Primitive.TextureEntry textureEntry = part.Shape.Textures;
if (textureEntry != null)
{
// 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;
}
if (textureEntry.FaceTextures != null)
{
// Loop through the rest of the texture faces (a non-null face means the face is different from DefaultTexture)
#if (!ISWIN)
foreach (Primitive.TextureEntryFace texture in textureEntry.FaceTextures)
{
if (texture != null)
{
assetUuids[texture.TextureID] = AssetType.Texture;
}
}
#else
foreach (Primitive.TextureEntryFace texture in textureEntry.FaceTextures.Where(texture => texture != null))
{
assetUuids[texture.TextureID] = AssetType.Texture;
}
#endif
}
}
// If the prim is a sculpt then preserve this information too
if (part.Shape.SculptTexture != UUID.Zero)
{
assetUuids[part.Shape.SculptTexture] = AssetType.Texture;
}
TaskInventoryDictionary taskDictionary = (TaskInventoryDictionary)part.TaskInventory.Clone();
// Now analyze this prim's inventory items to preserve all the uuids that they reference
#if (!ISWIN)
foreach (TaskInventoryItem tii in taskDictionary.Values)
{
if (!assetUuids.ContainsKey(tii.AssetID))
{
GatherAssetUuids(tii.AssetID, (AssetType)tii.Type, assetUuids, scene);
}
}
#else
foreach (TaskInventoryItem tii in taskDictionary.Values.Where(tii => !assetUuids.ContainsKey(tii.AssetID)))
{
GatherAssetUuids(tii.AssetID, (AssetType)tii.Type, assetUuids, scene);
}
#endif
}
catch (Exception e)
{
MainConsole.Instance.ErrorFormat("[UUID GATHERER]: Failed to get part - {0}", e);
MainConsole.Instance.DebugFormat(
"[UUID GATHERER]: Texture entry length for prim was {0} (min is 46)",
part.Shape.TextureEntry.Length);
}
}
}