public static bool IsSkipped(SimObject P, ImportSettings settings)
{
if (P is SimAvatar) return true;
if (P == null) return true;
if (IsIncluded(P.ID, P.LocalID)) return false;
if (P.Parent != null) if (IsIncluded(P.Parent.ID, P.ParentID)) return false;
Primitive pp = P.Prim0;
if (P.IsKilled)
{
if (pp != null)
{
if (P.IsTemporary) return true;
}
}
if (P.IsTemporary) return true;
if (!P.HasPrim) return true;
if (pp == null) return true;
var sp = P.SimPosition;
if (!onlyObjectAt.IsInside(sp.X, sp.Y, sp.Z)) return true;
Primitive.ObjectProperties props = pp.Properties;
if (props != null)
{
if (IsSkippedName(props.Name))
{
return true;
}
}
if (pp.ParentID == 0) return false;
SimObject parent = P.Parent;
// yes SL really does have links two deep! (called attachment linksets)
if (parent == null) return true;
if (parent == P) return false;
if (!IsSkipped(parent, settings)) return false;
return true;
}
private void UploadTerrain(ImportSettings importSettings)
{
string fn = ExportCommand.terrainFileName;
lock (ExportCommand.fileWriterLock)
{
if (!File.Exists(fn))
{
// upload patches
var fn2 = ExportCommand.terrainDir + "terrain.patches";
lock (ExportCommand.fileWriterLock)
{
if (File.Exists(fn2))
{
TerrainPatch[] loaded = (TerrainPatch[])ExportCommand.FromFile(fn2, true);
// TerrainCompressor.CreateLayerDataPacket(loaded, TerrainPatch.LayerType.Land);
float[,] hm = GetHeightMap(loaded);
hm = SmoothHM(hm);
byte[] raw = ToRaw32File(hm);
lock (ExportCommand.fileWriterLock) File.WriteAllBytes(fn, raw);
}
}
}
}
if (File.Exists(fn))
{
Client.Estate.UploadTerrain(File.ReadAllBytes(fn), Path.GetFileName(fn));
Success("Terrain file uploading");
}
else
{
Failure("unable to find any terrain files");
}
}
private int ImportTaskFiles0(ImportSettings importSettings, bool createObjects)
{
//if (IsLocalScene) return 0;
DateTime lastProgressNotice = DateTime.Now;
int incomplete = 0;
var agentSyncFolderHolder = Exporting.FolderCalled("TaskInvHolder");
int created = 0;
foreach (var file in Directory.GetFiles(ExportCommand.dumpDir, "*.task"))
{
string fileUUID = Path.GetFileNameWithoutExtension(Path.GetFileName(file));
var ptc = APrimToCreate(UUID.Parse(fileUUID));
if (++created % 25 == 0) WriteLine("tasked " + created);
if (ptc.PackedInsideNow) continue;
// if (ptc.TaskInvComplete) continue;
if ((ptc.Prim.RegionHandle != importSettings.CurSim.Handle) && importSettings.Contains("CheckRegion"))
{
KillID(ptc.OldID);
continue;
}
string taskDataS = File.ReadAllText(file);
if (string.IsNullOrEmpty(taskDataS) || taskDataS.Length < 30)
{
ptc.TaskInvComplete = true;
continue;
}
ptc.CreateWorkflow(agentSyncFolderHolder);
if (!ptc.LoadTaskOSD(WriteLine))
{
//Failure("FAILED: LoadOSD " + ptc);
incomplete++;
continue;
}
if (!ptc.SyncToAgentFolder(WriteLine, createObjects))
{
//Failure("FAILED: SyncToAgentFolder " + ptc);
if (ptc.succeeded == 0) continue;
}
if (!ptc.SyncToObject(WriteLine, createObjects))
{
//Failure("FAILED: SyncToObject " + ptc);
if (ptc.succeeded == 0) continue;
}
if (!ptc.Complete)
{
Failure("INCOMPLETE: " + ptc);
incomplete++;
}
else
{
Success("COMPLETE: " + ptc);
}
if (!IsLocalScene) Success("............");
if (lastProgressNotice.AddSeconds(30) < DateTime.Now)
{
lastProgressNotice = DateTime.Now;
WriteLine("Task created " + created + " incomplete=" + incomplete);
}
}
return incomplete;
}
private void SaveParcelInfoCommand(ImportSettings arglist)
{
if (SaveParcelInfoThread != null) return;
SaveParcelInfoThread = new Thread(() => SaveParcelInfo(arglist));
SaveParcelInfoThread.Name = "SimExport SaveParcelInfo";
SaveParcelInfoThread.Start();
}
static public void SaveLinkset(Linkset linkset, string filename, bool oldFormat, ImportSettings options)
{
try
{
using (StreamWriter stream = new StreamWriter(filename))
{
XmlTextWriter writer = new XmlTextWriter(stream);
SOGToXml2(writer, linkset, oldFormat, options);
writer.Flush();
}
}
catch (Exception ex)
{
Logger.Log("Failed saving linkset: " + ex.Message, Helpers.LogLevel.Error);
}
}
private void ImportTaskFiles(ImportSettings importSettings, bool createObjects)
{
int incomplete = 1;
int maxRetries = 10;
while (incomplete > 0 && maxRetries-- > 0)
{
incomplete = ImportTaskFiles0(importSettings, createObjects);
WriteLine("ImportTaskFiles Incomplete=" + incomplete);
}
foreach (PrimToCreate toCreate in parents)
{
toCreate.EnsureTaskInv(false);
}
foreach (PrimToCreate toCreate in childs)
{
toCreate.EnsureTaskInv(false);
}
}
static void SOGToXml2(XmlTextWriter writer, Linkset linkset, bool oldFormat, ImportSettings options)
{
options.CurLink = linkset;
writer.WriteStartElement(String.Empty, "SceneObjectGroup", String.Empty);
if (oldFormat) writer.WriteStartElement(String.Empty, "RootPart", String.Empty);
options.CurPrim = linkset.Parent;
SOPToXml(writer, linkset.Parent.Prim, 0, null, GetTaskInv(linkset.Parent), options);
if (oldFormat) writer.WriteEndElement();
writer.WriteStartElement(String.Empty, "OtherParts", String.Empty);
//uint linkNum = sop.LocalID - parent.LocalID;
int linkNum = 1;
foreach (var child in linkset.Children)
{
options.CurPrim = child;
if (oldFormat) writer.WriteStartElement(String.Empty, "Part", String.Empty);
SOPToXml(writer, child.Prim, linkNum++, linkset.Parent.Prim, GetTaskInv(child), options);
if (oldFormat) writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteEndElement();
}
public void LoadUsersAndGroups(ImportSettings settings)
{
string nameChangesFile = ExportCommand.siminfoDir + "../nameChanges.txt";
if (File.Exists(nameChangesFile))
{
string[] nameChanges = File.ReadAllLines(nameChangesFile);
foreach (var entry in nameChanges)
{
string[] entrySplit = entry.Split(',');
string n1 = entrySplit[0];
string n2 = n1;
if (entrySplit.Length > 1)
{
n2 = entrySplit[1];
}
RenamedWhosit[n1] = n2;
}
}
string found;
if (RenamedWhosit.TryGetValue("LINDENZERO", out found))
{
LINDENZERO = WorldSystem.FindUUIDForName(found);
}
if (RenamedWhosit.TryGetValue("MISSINGPERSON", out found))
{
MISSINGPERSON = WorldSystem.FindUUIDForName(found);
}
foreach (string file in Directory.GetFiles(ExportCommand.siminfoDir, "*.avatar"))
{
string[] content = File.ReadAllText(file).Split(',');
UUID key = UUID.Parse(Path.GetFileNameWithoutExtension(file));
UserOrGroupMapping mapping = new UserOrGroupMapping(key, content[0], false);
UUID2OBJECT[key] = mapping;
if (content.Length > 1)
{
mapping.NewName = content[1];
}
else
{
mapping.NewName = "MISSINGPERSON";
}
if (IsLocalScene)
{
LocalScene.Users.Add(mapping);
}
}
foreach (string file in Directory.GetFiles(ExportCommand.siminfoDir, "*.group"))
{
string[] content = File.ReadAllText(file).Split(',');
UUID key = UUID.Parse(Path.GetFileNameWithoutExtension(file));
UserOrGroupMapping mapping = new UserOrGroupMapping(key, content[0], true);
UUID2OBJECT[key] = mapping;
if (content.Length > 1)
{
mapping.NewName = content[1];
}
else
{
mapping.NewName = content[0];
}
if (IsLocalScene)
{
LocalScene.Groups.Add(mapping);
}
}
}
public void SaveTerrainHeight(ImportSettings settings)
{
bool prefixFP = false;
var CurSim = settings.CurSim;
OSDMap simInfoMap = new OSDMap();
// leave these out of serialization
simInfoMap["ObjectsPrimitives"] = true;
simInfoMap["ObjectsAvatars"] = true;
simInfoMap["Client"] = true;
simInfoMap["SharedData"] = true;
simInfoMap["Caps"] = true;
simInfoMap["DeadObjects"] = true;
simInfoMap["KilledObjects"] = true;
var exceptFor = new HashSet <object>()
{
typeof(IList), typeof(IDictionary), typeof(object)
};
OSD.AddObjectOSD0(CurSim.Stats, simInfoMap, typeof(Simulator.SimStats), exceptFor, true, prefixFP);
//@todo OSD.AddObjectOSD0(CurSim.SharedData, simInfoMap, typeof(Simulator.SimPooledData), exceptFor, true, prefixFP);
OSD.AddObjectOSD0(CurSim, simInfoMap, typeof(Simulator), exceptFor, true, prefixFP);
string output = OSDParser.SerializeLLSDXmlString(simInfoMap);
{
lock (fileWriterLock) File.WriteAllText(terrainDir + "simInfoMap.llsd", output);
}
AddRelated(CurSim.TerrainBase0, AssetType.Texture);
AddRelated(CurSim.TerrainBase1, AssetType.Texture);
AddRelated(CurSim.TerrainBase2, AssetType.Texture);
AddRelated(CurSim.TerrainBase3, AssetType.Texture);
AddRelated(CurSim.TerrainDetail0, AssetType.Texture);
AddRelated(CurSim.TerrainDetail1, AssetType.Texture);
AddRelated(CurSim.TerrainDetail2, AssetType.Texture);
AddRelated(CurSim.TerrainDetail3, AssetType.Texture);
AddExportUser(CurSim.SimOwner);
var Terrain = CurSim.Terrain;
if (Terrain == null)
{
Failure("Terrain missing completely");
return;
}
Client.Grid.RequestMapItems(CurSim.Handle, GridItemType.LandForSale, GridLayerType.Terrain);
var number = CurSim.Terrain.Length;
var missing = 0;
foreach (TerrainPatch patch in Terrain)
{
if (patch != null && patch.Data != null && patch.Data.Length > 0)
{
continue;
}
missing++;
}
var terrainReady = (missing == 0);
if (!terrainReady)
{
Failure("Terrain missing chunks/total=" + missing + "/" + number);
}
if (terrainReady || forced)
{
SaveToDisk(terrainDir + "terrain.patches", Terrain);
SaveTerrainRaw32(dumpDir + "../terrains/heightmap.r32");
if (!terrainReady)
{
Failure("SaveTerrainHeight Saved but not ready");
}
else
{
Success("SaveTerrainHeight Success");
}
return;
}
Failure("Unable to SaveTerrainHeight (use --force)");
}
private void CheckTasks(ImportSettings settings)
{
foreach (PrimToCreate parent in LockInfo.CopyOf(parents))
{
var ls = new Linkset()
{
Parent = parent
};
parent.Link = ls;
LocalScene.Links.Add(ls);
}
foreach (PrimToCreate ch in childs)
{
var pp = ch.ParentPrim;
if (pp == null)
{
continue;
}
pp.Link.ChildAdd(ch);
}
foreach (var ls in LockInfo.CopyOf(LocalScene.Links))
{
ls.Children.Sort(compareLocalIDs);
if (ls.Parent.IsAsset)
{
LocalScene.AssetLinks.Add(ls);
LocalScene.Links.Remove(ls);
}
}
int found = 0;
Dictionary <UUID, TaskFileInfo> item2TO = new Dictionary <UUID, TaskFileInfo>();
List <TaskFileInfo> mssingTO = new List <TaskFileInfo>();
List <TaskFileInfo> duped = new List <TaskFileInfo>();
foreach (var file in Directory.GetFiles(ExportCommand.dumpDir, "*.objectAsset"))
{
break;
found++;
string fileString = File.ReadAllText(file);
string[] c = fileString.Split(',');
try
{
TaskFileInfo to = new TaskFileInfo()
{
OldLid = uint.Parse(c[0]),
RezzedID = UUID.Parse(c[2]),
OldTaskHolder = UUID.Parse(c[3]),
AssetUUID = UUID.Parse(c[4]),
TaskItemID = UUID.Parse(c[5])
};
bool missing = false;
if (MissingLLSD(to.RezzedID))
{
Failure("Need LLSD: " + fileString);
to.missingLLSD = true;
mssingTO.Add(to);
}
TaskFileInfo old;
if (item2TO.TryGetValue(to.TaskItemID, out old))
{
if (old.missingLLSD)
{
item2TO[to.TaskItemID] = to;
duped.Add(old);
}
else
{
duped.Add(to);
}
}
else
{
if (to.missingLLSD)
{
continue;
}
item2TO[to.TaskItemID] = to;
}
}
catch (Exception ee)
{
Failure("fileIssue: " + file + " = " + fileString);
}
}
Success("t=" + found + " m=" + mssingTO.Count + " td=" + item2TO.Count + " duped=" + duped.Count);
}
public void DivideTaskObjects(ImportSettings importSettings)
{
}
public void RequestLinksetInfo(BotClient Client, string pathStem, SimObject exportPrim, OutputDelegate Failure, ImportSettings settings)
{
string exportFile = pathStem + ".link";
lock (fileWriterLock) if (File.Exists(exportFile)) return;
bool canScript = checkPerms(Client, exportPrim, SilientFailure, true);
InventoryItem found = GetInvItem(Client, "LinksetSpeaker");
if (!canScript || found == null)
{
ScanForLinksets(exportPrim);
return;
}
lock (PrimWaitingLinkset)
{
if (PrimWaitingLinkset.ContainsKey(exportPrim.ID)) return;
PrimWaitingLinkset.Add(exportPrim.ID, new LinkSetBuffer {S = "", O = exportPrim, F = pathStem});
}
PutItemToTaskInv(Client,exportPrim.LocalID, exportPrim, "LinksetSpeaker");
}
private void CountReady(ImportSettings settings)
{
Exporting.GiveStatus();
int readyObjects = 0;
int readyObjectsForDelete = 0;
int unreadyObjs = 0;
int unreadyObjsMustReRez = 0;
int requestedShort = 0;
foreach (var file in Directory.GetFiles(ExportCommand.dumpDir, "*.*.rti"))
{
if (!file.EndsWith("rti"))
{
//rti_status
continue;
}
string rtiData = File.ReadAllText(file);
var contents = rtiData.Split(',');
if (contents.Length < 2)
{
requestedShort++;
continue;
}
UUID objID, holderID;
if (!UUID.TryParse(contents[0], out objID) || !UUID.TryParse(contents[1], out holderID))
{
Failure("SHORT: " + file + " " + rtiData);
requestedShort++;
continue;
}
// var uuidstr = Path.GetFileName(file).Split('.');
// var objNum = int.Parse(uuidstr[1]);
string completeStr = ExportCommand.IsComplete(objID, false, true, settings);
Vector3 where;
bool inWorld = Exporting.IsExisting(objID, out where);
if (string.IsNullOrEmpty(completeStr))
{
readyObjects++;
if (inWorld)
{
Exporting.AttemptMoveTo(where);
Thread.Sleep(3000);
Exporting.KillInWorld(objID);
Importing.APrimToCreate(holderID);
readyObjectsForDelete++;
}
else
{
Importing.APrimToCreate(holderID);
Importing.APrimToCreate(objID);
}
}
else
{
unreadyObjs++;
if (!inWorld)
{
unreadyObjsMustReRez++;
Failure("REREZ: " + completeStr + " " + rtiData);
Importing.APrimToCreate(holderID).MustUseAgentCopy = true;
File.Delete(ExportCommand.dumpDir + holderID + ".rti_status");
File.Delete(file);
}
else
{
MustExport.Add(objID);
MustExport.Add(holderID);
Importing.APrimToCreate(holderID);
Failure("RTIDATA: " + completeStr + " " + rtiData);
Exporting.AddMoveTo(where);
}
}
}
Success("readyObjects = " + readyObjects);
Success("readyObjectsForDelete = " + readyObjectsForDelete);
Success("unreadyObjs = " + unreadyObjs);
Success("unreadyObjsMustReRez = " + unreadyObjsMustReRez);
Success("requestedShort = " + requestedShort);
}
private void ConfirmLSLPrims(ImportSettings settings)
{
;// <44, 143, 340 > to <154, 241, 360>
foreach (var o0 in File.ReadAllLines(ExportCommand.dumpDir + "../required.txt"))
{
if (o0==null) continue;
var o = o0.Trim();
if (o.Contains("TOO DENSE AT") || o.Contains("1000.187000>,1,0,rod")) continue;
string[] ss = o.Split(',');
try
{
UUID confirmID = UUID.Parse(ss[1]);
// int childc = int.Parse(ss[6]);
//bool problems = false;
/* if (MissingLINK(confirmID))
{
Failure("MissingLINK: " + o);
problems = true;
}
if (MissingTASK(confirmID))
{
Failure("MissingTASK: " + o);
problems = true;
}
if (MissingLLSD(confirmID))
{
Failure("MissingLLSD: " + o);
continue;
}
* */
// if (problems)
{
if (!MissingLLSD(confirmID))
{
// Failure("MissingLLSD: " + o);
continue;
}
var p = GetOldPrim(confirmID);
if (p == null)
{
o = o.Replace("<", "").Replace(">", "");
ss = o.Split(',');
Vector3 to = new Vector3(float.Parse(ss[2]), float.Parse(ss[3]), float.Parse(ss[4]));
Exporting.AddMoveTo(to);
Failure("cant find " + o);
}
}
} catch(Exception e)
{
Failure("cant parse " + o);
}
}
}
static void WriteFlags0(XmlTextWriter writer, string name, string flagsStr, ImportSettings options)
{
// Older versions of serialization can't cope with commas, so we eliminate the commas
writer.WriteElementString(name, flagsStr.Replace(",", " ").Replace(" ", " "));
}
private static void WriteUserUUID(XmlTextWriter writer, string name, UUID uuid, ImportSettings settings)
{
WriteUUID(writer, name, uuid, settings);
}
private static Enum Reperm(PermissionMask mask, ImportSettings settings)
{
if (settings.Contains("sameperms")) return mask;
if (settings.Contains("+xfer+copy")) return mask | PermissionMask.Copy | PermissionMask.Transfer;
return PermissionMask.All;
}
OSDMap SaveEachTaskItem(ImportSettings arglist, BotClient Client, SimObject exportPrim, InventoryBase b, OutputDelegate Failure, out bool missing)
{
InventoryFolder fldr = b as InventoryFolder;
if (fldr != null)
{
missing = false;
return OSDSerializeMembers(b);
}
InventoryItem item = b as InventoryItem;
if (item == null)
{
string errorMsg = "" + b.UUID + ",ERROR," + b.UUID + "," + b.Name;
Failure("No an Item");
missing = true;
return OSDSerializeMembers(b);
}
bool exportable = checkTaskPerm(exportPrim, item, Client, Failure, false);
lock (TaskAssetWaiting)
{
lock (CompletedTaskItem)
{
UUID itemID = item.UUID;
if (CompletedTaskItem.Contains(itemID))
{
missing = false;
return OSDSerializeMembers(item);
}
}
}
if (item.InventoryType == InventoryType.Object)
{
//UUID newObjID;
//return UnpackTaskObject(arglist, exportPrim, item as InventoryObject, Client, Failure, out missing, taskobj, out newObjID);
}
missing = CogbotHelpers.IsNullOrZero(item.AssetUUID);
return OSDSerializeMembers(item); //UnpackTaskItem(Client, exportPrim, item, Failure, out missing);
}
private static void WriteUserUUID(XmlTextWriter writer, string name, UUID uuid, ImportSettings settings)
{
WriteUUID(writer, name, uuid, settings);
}
static void WriteFlags(XmlTextWriter writer, string name, Enum flagsStr, ImportSettings options)
{
// Older versions of serialization can't cope with commas, so we eliminate the commas
WriteEnum(writer, name, flagsStr);
}
static void WriteFlags0(XmlTextWriter writer, string name, string flagsStr, ImportSettings options)
{
// Older versions of serialization can't cope with commas, so we eliminate the commas
writer.WriteElementString(name, flagsStr.Replace(",", " ").Replace(" ", " "));
}
public static void WriteShape(XmlTextWriter writer, Primitive prim, Primitive.ObjectProperties props, Primitive.ConstructionData shp, ImportSettings options)
{
if (true /*shp != null*/)
{
writer.WriteStartElement("Shape");
WriteEnum(writer, "ProfileCurve", shp.ProfileCurve);
writer.WriteStartElement("TextureEntry");
byte[] te;
if (prim.Textures != null)
te = prim.Textures.GetBytes();
else
te = Utils.EmptyBytes;
writer.WriteBase64(te, 0, te.Length);
writer.WriteEndElement(); // TextureEntry
writer.WriteStartElement("ExtraParams");
byte[] ep;
if (prim.GetExtraParamsBytes() != null)
ep = prim.GetExtraParamsBytes();
else
ep = Utils.EmptyBytes;
writer.WriteBase64(ep, 0, ep.Length);
writer.WriteEndElement(); // ExtraParams
writer.WriteElementString("PathBegin", Primitive.PackBeginCut(shp.PathBegin).ToString());
WriteEnum(writer, "PathCurve", shp.PathCurve);
writer.WriteElementString("PathEnd", Primitive.PackEndCut(shp.PathEnd).ToString());
writer.WriteElementString("PathRadiusOffset", Primitive.PackPathTwist(shp.PathRadiusOffset).ToString());
writer.WriteElementString("PathRevolutions", Primitive.PackPathRevolutions(shp.PathRevolutions).ToString());
writer.WriteElementString("PathScaleX", Primitive.PackPathScale(shp.PathScaleX).ToString());
writer.WriteElementString("PathScaleY", Primitive.PackPathScale(shp.PathScaleY).ToString());
writer.WriteElementString("PathShearX", ((byte)Primitive.PackPathShear(shp.PathShearX)).ToString());
writer.WriteElementString("PathShearY", ((byte)Primitive.PackPathShear(shp.PathShearY)).ToString());
writer.WriteElementString("PathSkew", Primitive.PackPathTwist(shp.PathSkew).ToString());
writer.WriteElementString("PathTaperX", Primitive.PackPathTaper(shp.PathTaperX).ToString());
writer.WriteElementString("PathTaperY", Primitive.PackPathTaper(shp.PathTaperY).ToString());
writer.WriteElementString("PathTwist", Primitive.PackPathTwist(shp.PathTwist).ToString());
writer.WriteElementString("PathTwistBegin", Primitive.PackPathTwist(shp.PathTwistBegin).ToString());
writer.WriteElementString("ProfileBegin", Primitive.PackBeginCut(shp.ProfileBegin).ToString());
writer.WriteElementString("ProfileEnd", Primitive.PackEndCut(shp.ProfileEnd).ToString());
writer.WriteElementString("ProfileHollow", Primitive.PackProfileHollow(shp.ProfileHollow).ToString());
WriteEnum(writer, "PCode", shp.PCode);
// this is Attachment in a way?
WriteInt(writer, "State", shp.State);
//WriteEnum(writer, "State", shp.AttachmentPoint);
WriteFlags(writer, "ProfileShape", shp.ProfileCurve, options);
WriteFlags(writer, "HollowShape", shp.ProfileHole, options);
var Sculpt = prim.Sculpt;
if (Sculpt != null)
{
WriteUUID(writer, "SculptTexture", Sculpt.SculptTexture, options);
WriteEnum(writer, "SculptType", Sculpt.Type);
writer.WriteStartElement("SculptData");
byte[] sd;
if (prim.Sculpt != null)
sd = Sculpt.GetBytes();
else
sd = Utils.EmptyBytes;
writer.WriteBase64(sd, 0, sd.Length);
writer.WriteEndElement(); // SculptData
}
Primitive.FlexibleData Flexi = prim.Flexible;
if (Flexi != null)
{
WriteInt(writer,"FlexiSoftness", Flexi.Softness);
WriteFloat(writer,"FlexiTension", Flexi.Tension);
WriteFloat(writer,"FlexiDrag", Flexi.Drag);
WriteFloat(writer,"FlexiGravity", Flexi.Gravity);
WriteFloat(writer,"FlexiWind", Flexi.Wind);
WriteFloat(writer,"FlexiForceX", Flexi.Force.X);
WriteFloat(writer,"FlexiForceY", Flexi.Force.Y);
WriteFloat(writer,"FlexiForceZ", Flexi.Force.Z);
}
Primitive.LightData Light = prim.Light;
if (Light != null)
{
WriteFloat(writer,"LightColorR", Light.Color.R);
WriteFloat(writer,"LightColorG", Light.Color.G);
WriteFloat(writer,"LightColorB", Light.Color.B);
WriteFloat(writer,"LightColorA", Light.Color.A);
WriteFloat(writer,"LightRadius", Light.Radius);
WriteFloat(writer,"LightCutoff", Light.Cutoff);
WriteFloat(writer,"LightFalloff", Light.Falloff);
WriteFloat(writer,"LightIntensity", Light.Intensity);
}
WriteValue(writer,"FlexiEntry", (Flexi != null).ToString().ToLower());
WriteValue(writer,"LightEntry", (Light != null).ToString().ToLower());
WriteValue(writer,"SculptEntry", (Sculpt != null).ToString().ToLower());
//todo if (shp.Media != null) WES(writer,"Media", shp.Media.ToXml());
writer.WriteEndElement(); // Shape
}
}
public CmdResult Execute(string[] args, UUID fromAgentID, OutputDelegate writeLine)
{
if (!IsLocalScene)
{
ExportCommand.IsExporting = false;
}
else
{
ExportCommand.IsExporting = true;
}
const string hlp = @"
Toplevel Directives
// todo = shows what must be done for import to be complete (suggest adding verbose)
// perms = shows what perms are going to be a problem (suggest adding verbose)
// clear - clear the export dir
// reset - reset the exporter state
// cache - blow away asset cache
// prims [spec] - do only prims meeting spec (default is prims $region)
// incr - do only do what is 'todo'
// nonincr - do things 'todo' but also 'redo' things already done
// noperms = dont skip things when perms might be a problem
// quietly = terser output
// verbose = more verbose
// request = will rerequest missing things like textures
// force = will allow unequal LLSD files - this should only be used as last resort
// users - load users files
// prims - load llsd files
// trees - load trees files
// terrain - load terrain files
// links - operate on linkset
// tasks - save task files
// taskobjs - task objects
// all = users llsd tasks deps links (dl and taskobj not included)
";
if (args == null || args.Length == 0)
{
return(Failure(hlp));
}
ImportSettings importSettings = new ImportSettings();
ExportCommand.Exporting.settings = importSettings;
importSettings.GroupID = (args.Length > 1) ? TheBotClient.GroupID : UUID.Zero;
importSettings.CurSim = Client.Network.CurrentSim;
var arglist = importSettings;
writeLine("Starting SimImport...");
foreach (string s in args)
{
arglist.Add(s);
}
if (arglist.Contains("reoar"))
{
OarFile.PackageArchive("cog_export/oarfile/", "repack.oar", false, false);
return(SuccessOrFailure());
}
if (arglist.Contains("nolldie"))
{
ReplaceLSLText(ExportCommand.assetDumpDir, "llDie()",
"llOwnerSay((string)llGetKey() + \",script caused die ,\" + llGetObjectName() + \",\" + (string)llGetPos() + \",\" + llGetScriptName() + \",\" + llGetLinkNumber())",
arglist);
return(SuccessOrFailure());
}
if (arglist.Contains("hhp"))
{
//arglist.Add("keepmissing");
//arglist.Add("all");
//arglist.Add("oar");
arglist.Add("fullperms");
// arglist.Add("lslprims");
//arglist.Add("request");
//arglist.Add("KillMissing");
arglist.Add("reztaskobj");
arglist.Add("prim");
arglist.Add("confirm");
arglist.Add("link");
arglist.Add("checktasks");
arglist.Add("tasklsl");
}
bool doRez = false;
if (arglist.Contains("all"))
{
// arglist.Add("terrain");
arglist.Add("asset");
arglist.Add("user");
arglist.Add("group");
arglist.Add("prim");
arglist.Add("confirm");
arglist.Add("link");
arglist.Add("task");
arglist.Add("taskobj");
arglist.Add("CountReady");
}
if (arglist.Contains("prim"))
{
doRez = true;
arglist.Add("asset");
arglist.Add("link");
}
if (arglist.Contains("nolink"))
{
arglist.Remove("link");
}
if (arglist.Contains("noasset"))
{
arglist.Remove("asset");
}
if (arglist.Contains("link"))
{
arglist.Add("confirm");
}
if (arglist.Contains("user") || arglist.Contains("group") || true)
{
LoadUsersAndGroups(arglist);
}
if (arglist.Contains("asset") || true)
{
UploadAllAssets(arglist);
}
GleanUUIDsFrom(GetAssetUploadsFolder());
ScanForChangeList();
if (arglist.Contains("terrain"))
{
UploadTerrain(importSettings);
}
WriteLine("NewAsset ChangeList Size is " + ChangeList.Count);
if (arglist.Contains("confirm"))
{
ImportPTCFiles(importSettings, false, doRez);
}
if (arglist.Contains("prim"))
{
ImportPrims(importSettings, doRez);
}
if (doRez)
{
RezPrims(importSettings);
}
if (arglist.Contains("confirm"))
{
ConfirmLocalIDs(importSettings);
}
if (arglist.Contains("link"))
{
ImportLinks(importSettings);
}
if (arglist.Contains("move"))
{
MoveToKnownObjects();
Success("Moving to " + _parents.Count);
}
bool tasksObjs = arglist.Contains("taskobj") && !IsLocalScene;
if (tasksObjs || arglist.Contains("checktasks"))
{
ImportTaskObjects(importSettings);
}
if (arglist.Contains("task") || tasksObjs)
{
ImportTaskFiles(importSettings, tasksObjs);
}
GleanUUIDsFrom(GetAssetUploadsFolder());
SaveMissingIDs();
if (arglist.Contains("request"))
{
RequestMissingIDs(importSettings);
}
if (arglist.Contains("locate"))
{
LocatePrims(importSettings);
}
DivideTaskObjects(importSettings);
if (arglist.Contains("killmissing"))
{
KillMissing(importSettings);
}
if (arglist.Contains("lslprims"))
{
ConfirmLSLPrims(importSettings);
}
if (arglist.Contains("todo"))
{
DoTodo(importSettings);
}
if (arglist.Contains("checktasks"))
{
CheckTasks(importSettings);
}
if (arglist.Contains("upackobjs"))
{
UnpackTaskObjs(importSettings);
}
if (arglist.Contains("oar"))
{
CreateOARFile(importSettings, "exported.oar");
}
if (arglist.Contains("CountReady"))
{
CountReady(importSettings);
}
if (arglist.Contains("cleanup"))
{
CleanupPrims(importSettings);
}
if (arglist.Contains("cleanuptasks"))
{
CleanupTasks(importSettings);
}
writeLine("Completed SimImport");
return(SuccessOrFailure());
}
static void WriteFlags(XmlTextWriter writer, string name, Enum flagsStr, ImportSettings options)
{
// Older versions of serialization can't cope with commas, so we eliminate the commas
WriteEnum(writer, name, flagsStr);
}
private void RequestMissingIDs(ImportSettings settings)
{
ExportCommand.IsExporting = true;
foreach (MissingItemInfo itemInfo in MissingFromExport)
{
var ex = ExportCommand.Exporting;
if (itemInfo.AssetType == AssetType.Unknown)
{
Failure("MISSING STILL: " + itemInfo);
continue;
}
Success("Requesting: " + itemInfo);
if (itemInfo.AssetType == AssetType.Landmark)
{
Client.Grid.RequestRegionHandle(itemInfo.MissingID);
continue;
}
if (itemInfo.AssetType == AssetType.EnsembleStart)
{
if (settings.Contains("requestaccts")) Client.Groups.RequestGroupName(itemInfo.MissingID);
continue;
}
if (itemInfo.AssetType == AssetType.CallingCard)
{
if (settings.Contains("requestaccts")) Client.Avatars.RequestAvatarName(itemInfo.MissingID);
continue;
}
ex.AddRelated(itemInfo.MissingID, itemInfo.AssetType);
}
}
static void WriteUUID(XmlTextWriter writer, string name, UUID id, ImportSettings options)
{
writer.WriteStartElement(name);
if (options.ContainsKey("old-guids"))
writer.WriteElementString("Guid", id.ToString());
else
writer.WriteElementString("UUID", id.ToString());
writer.WriteEndElement();
}
internal bool ExportPrim0(BotClient Client, SimObject exportPrim, OutputDelegate Failure, ImportSettings settings)
{
if (IsSkipped(exportPrim, settings)) return false;
Simulator CurSim = exportPrim.GetSimulator();
//settings.CurSim = CurSim;
WorldObjects.EnsureSelected(exportPrim.LocalID, CurSim);
string pathStem = Path.Combine(dumpDir, exportPrim.ID.ToString());
if (settings.Contains("task") || showsMissingOnly)
{
exportPrim.StartGetTaskInventory();
}
if (settings.Contains("wait"))
{
var waitUntil = DateTime.Now.AddSeconds(10);
bool needsLoop = true;
while (needsLoop && waitUntil > DateTime.Now)
{
needsLoop = false;
if (exportPrim.Properties == null || CogbotHelpers.IsNullOrZero(exportPrim.Properties.OwnerID))
{
needsLoop = true;
}
if (settings.Contains("task"))
{
var ti = exportPrim.TaskInventory;
if (ti == null)
{
needsLoop = true;
}
}
}
if (needsLoop)
{
Success("needs loop " + named(exportPrim));
string bissues = exportPrim.MissingData;
if (!string.IsNullOrEmpty(bissues) && !settings.Allows(bissues ,exportPrim))
{
Failure("Cant wait out the Issues " + bissues + ": " + named(exportPrim));
if (LocalFailures == 0) LocalFailures++;
// return;
}
}
}
string issues = exportPrim.MissingData;
if (!string.IsNullOrEmpty(issues) && !settings.Allows(issues, exportPrim))
{
Failure("Issues " + issues + " " + named(exportPrim));
if (LocalFailures == 0) LocalFailures++;
//return false;
}
//ImportCommand.PrimToCreate ptc = ImportCommand.Running.APrimToCreate(exportPrim.ID);
//ptc._prim = exportPrim.Prim;
bool passedOK = true;
if (settings.Contains("llsd"))
{
SaveLLSD(Client, pathStem, exportPrim, Failure, settings);
}
if (exportPrim.IsRoot && (true || exportPrim.Children.Count > 0))
{
if (settings.Contains("link")) SaveLinksetInfo(Client, pathStem, exportPrim, Failure, settings);
string exportFile = pathStem + ".link";
//lock (fileWriterLock) if (File.Exists(exportFile))
{
foreach (var c in exportPrim.Children)
{
var ch = ExportPrim(Client, c, Failure, settings);
if (!ch) passedOK = false;
}
}
}
if (settings.Contains("task"))
{
if (!SaveTaskInv(settings, Client, pathStem, exportPrim, Failure)) passedOK = false;
// ImportCommand.PrimToCreate ptc = ImportCommand.Running.APrimToCreate(exportPrim.ID);
// if (!ptc.EnsureTaskInv()) return false;
}
if (!settings.Contains("dep")) return passedOK;
AddRelatedTextures(exportPrim);
SaveRelatedAssets(pathStem, exportPrim, Failure);
return passedOK;
}
public static void SavePrims(DoubleDictionary <uint, UUID, Primitive> prims, string path, ImportSettings options)
{
// Delete all of the old linkset files
try
{
Directory.Delete(path, true);
Directory.CreateDirectory(path);
}
catch (Exception ex)
{
Logger.Log("Failed saving prims: " + ex.Message, Helpers.LogLevel.Error);
return;
}
// Copy the double dictionary to a temporary list for iterating
List <Primitive> primList = new List <Primitive>();
prims.ForEach(delegate(Primitive prim)
{
primList.Add(prim);
});
foreach (Primitive p in primList)
{
if (p.ParentID == 0)
{
Linkset linkset = new Linkset();
linkset.Parent = ImportCommand.Importing.APrimToCreate(p);
prims.ForEach(delegate(Primitive q)
{
if (q.ParentID == p.LocalID)
{
linkset.Children.Add(ImportCommand.Importing.APrimToCreate(q));
}
});
OarFile.SaveLinkset(linkset, path + "/Primitive_" + linkset.Parent.NewID.ToString() + ".xml", false,
options);
}
}
}
static public string IsComplete(UUID uuid, bool includeLink, bool includeTask, ImportSettings settings)
{
string whynotCOmplete = "";
if (ImportCommand.MissingLLSD(uuid)) return "!llsd";
if (includeLink && ImportCommand.MissingLINK(uuid)) whynotCOmplete += "!link";
if (ImportCommand.MissingTASK(uuid)) return whynotCOmplete += "!task";
whynotCOmplete += PerfectTaskOSD(uuid, settings, true);
return whynotCOmplete;
}
public void LoadUsersAndGroups(ImportSettings settings)
{
string nameChangesFile = ExportCommand.siminfoDir + "../nameChanges.txt";
if (File.Exists(nameChangesFile))
{
string[] nameChanges = File.ReadAllLines(nameChangesFile);
foreach (var entry in nameChanges)
{
string[] entrySplit = entry.Split(',');
string n1 = entrySplit[0];
string n2 = n1;
if (entrySplit.Length > 1)
{
n2 = entrySplit[1];
}
RenamedWhosit[n1] = n2;
}
}
string found;
if (RenamedWhosit.TryGetValue("LINDENZERO", out found))
{
LINDENZERO = WorldSystem.FindUUIDForName(found);
}
if (RenamedWhosit.TryGetValue("MISSINGPERSON", out found))
{
MISSINGPERSON = WorldSystem.FindUUIDForName(found);
}
foreach (string file in Directory.GetFiles(ExportCommand.siminfoDir, "*.avatar"))
{
string[] content = File.ReadAllText(file).Split(',');
UUID key = UUID.Parse(Path.GetFileNameWithoutExtension(file));
UserOrGroupMapping mapping = new UserOrGroupMapping(key, content[0], false);
UUID2OBJECT[key] = mapping;
if (content.Length > 1)
{
mapping.NewName = content[1];
}
else
{
mapping.NewName = "MISSINGPERSON";
}
if (IsLocalScene)
{
LocalScene.Users.Add(mapping);
}
}
foreach (string file in Directory.GetFiles(ExportCommand.siminfoDir, "*.group"))
{
string[] content = File.ReadAllText(file).Split(',');
UUID key = UUID.Parse(Path.GetFileNameWithoutExtension(file));
UserOrGroupMapping mapping = new UserOrGroupMapping(key, content[0], true);
UUID2OBJECT[key] = mapping;
if (content.Length > 1)
{
mapping.NewName = content[1];
}
else
{
mapping.NewName = content[0];
}
if (IsLocalScene)
{
LocalScene.Groups.Add(mapping);
}
}
}
private void StartTerrainDownload(ImportSettings settings)
{
// Create a delegate which will be fired when the simulator receives our download request
// Starts the actual transfer request
if (DownloadTerrainThread != null) return;
DownloadTerrainThread = new Thread(DownloadTerrain);
DownloadTerrainThread.Name = "SimExport DownloadTerrain";
DownloadTerrainThread.Start();
}
public bool ExportPrim(BotClient Client, SimObject exportPrim, OutputDelegate Failure, ImportSettings settings)
{
uint localID = exportPrim.LocalID;
WorldObjects.EnsureRequested(localID + 1, settings.CurSim);
try
{
Client.Objects.SelectObject(settings.CurSim, localID);
WorldObjects.EnsureRequested(localID, settings.CurSim);
return(ExportPrim0(Client, exportPrim, Failure, settings));
}
finally
{
Client.Objects.DeselectObject(settings.CurSim, localID);
}
}
private void SaveParcelInfo(ImportSettings settings)
{
var CurSim = settings.CurSim;
Client.Parcels.RequestAllSimParcels(CurSim);
if (CurSim.IsParcelMapFull())
ParcelsDownloaded.Set();
if (ParcelsDownloaded.WaitOne(30000, false) && Client.Network.Connected)
{
Success(string.Format("Downloaded {0} Parcels in {1} " + Environment.NewLine, CurSim.Parcels.Count, CurSim.Name));
IDictionary<int, Parcel> curSimParcels = null;
lock (CurSim.Parcels.Dictionary)
{
curSimParcels = LockInfo.CopyOf(CurSim.Parcels.Dictionary);
}
List<UUID> ParcelPrimOwners = new List<UUID>();
List<uint> ParcelObjectIDS = new List<uint>();
foreach (KeyValuePair<int, Parcel> simParcel in curSimParcels)
{
var parcel = simParcel.Value;
int parcelID = parcel.LocalID;
Success(string.Format(
"Parcel[{0}]: Name: \"{1}\", Description: \"{2}\" ACLBlacklist Count: {3}, ACLWhiteList Count: {5} Traffic: {4}" +
Environment.NewLine,
parcel.LocalID, parcel.Name, parcel.Desc,
parcel.AccessBlackList.Count, parcel.Dwell,
parcel.AccessWhiteList.Count));
AddExportUser(parcel.OwnerID);
AddExportGroup(parcel.GroupID);
Success(Helpers.StructToString(parcel));
foreach (
ParcelManager.ParcelAccessEntry white in parcel.AccessWhiteList)
{
if (white.AgentID != UUID.Zero)
Success(string.Format(
"\tAllowed Avatar {0}" + Environment.NewLine,
white.AgentID));
}
foreach (
ParcelManager.ParcelAccessEntry black in parcel.AccessBlackList)
{
// if(black.AgentID != UUID.Zero)
Success(string.Format("\t Banned Avatar {0}" + Environment.NewLine,
black.AgentID));
}
{
AutoResetEvent parcelOwnerWait = new AutoResetEvent(false);
EventHandler<ParcelObjectOwnersReplyEventArgs> callback =
delegate(object sender, ParcelObjectOwnersReplyEventArgs e)
{
for (int i = 0; i < e.PrimOwners.Count; i++)
{
ParcelManager.ParcelPrimOwners ownerse = e.PrimOwners[i];
if (ownerse.IsGroupOwned)
{
AddExportGroup(ownerse.OwnerID);
}
else
{
AddExportUser(ownerse.OwnerID);
}
Success(string.Format("Owner: {0} Count: {1}" + Environment.NewLine,
ownerse.OwnerID, ownerse.Count));
if (!CogbotHelpers.IsNullOrZero(ownerse.OwnerID))
{
ParcelPrimOwners.Add(ownerse.OwnerID);
}
}
parcelOwnerWait.Set();
};
Client.Parcels.ParcelObjectOwnersReply += callback;
try
{
Client.Parcels.RequestObjectOwners(CurSim, parcelID);
if (!parcelOwnerWait.WaitOne(10000, false))
{
Failure("Timed out waiting for packet.");
}
}
finally
{
Client.Parcels.ParcelObjectOwnersReply -= callback;
}
}
foreach (UUID ownerUUID in ParcelPrimOwners)
{
AutoResetEvent wait = new AutoResetEvent(false);
EventHandler<ForceSelectObjectsReplyEventArgs> callback = delegate(object sender, ForceSelectObjectsReplyEventArgs e)
{
ParcelObjectIDS.AddRange(e.ObjectIDs);
for (int i = 0; i < e.ObjectIDs.Count; i++)
{
// Success(string.Format(e.ObjectIDs[i].ToString() + " "));
// counter++;
}
if (e.ObjectIDs.Count < 251)
wait.Set();
};
Client.Parcels.ForceSelectObjectsReply += callback;
Client.Parcels.RequestSelectObjects(parcelID, (ObjectReturnType)16, ownerUUID);
wait.WaitOne(10000);
}
}
foreach (uint u in ParcelObjectIDS)
{
RequiredForExportLocalIDs.Add(u);
}
Success("Parcel LocalIDs=" + ParcelObjectIDS.Count + " ParcelOwners=" + ParcelPrimOwners.Count);
}
else
Failure("Failed to retrieve information on all the simulator parcels");
string parcelDirs = settings.OarDir + "landdata/";
Directory.CreateDirectory(parcelDirs);
SimRegion r = SimRegion.GetRegion(CurSim);
foreach (var p in r.ParcelMap)
{
Parcel parcel = p.Value;
if (CogbotHelpers.IsNullOrZero(parcel.GlobalID)) parcel.GlobalID = UUID.Random();
File.WriteAllText(parcelDirs + "" + parcel.GlobalID + ".xml", OarFile.Serialize(parcel));
}
}
internal bool ExportPrim0(BotClient Client, SimObject exportPrim, OutputDelegate Failure, ImportSettings settings)
{
if (IsSkipped(exportPrim, settings))
{
return(false);
}
Simulator CurSim = exportPrim.GetSimulator();
//settings.CurSim = CurSim;
WorldObjects.EnsureSelected(exportPrim.LocalID, CurSim);
string pathStem = Path.Combine(dumpDir, exportPrim.ID.ToString());
if (settings.Contains("task") || showsMissingOnly)
{
exportPrim.StartGetTaskInventory();
}
if (settings.Contains("wait"))
{
var waitUntil = DateTime.Now.AddSeconds(10);
bool needsLoop = true;
while (needsLoop && waitUntil > DateTime.Now)
{
needsLoop = false;
if (exportPrim.Properties == null || CogbotHelpers.IsNullOrZero(exportPrim.Properties.OwnerID))
{
needsLoop = true;
}
if (settings.Contains("task"))
{
var ti = exportPrim.TaskInventory;
if (ti == null)
{
needsLoop = true;
}
}
}
if (needsLoop)
{
Success("needs loop " + named(exportPrim));
string bissues = exportPrim.MissingData;
if (!string.IsNullOrEmpty(bissues) && !settings.Allows(bissues, exportPrim))
{
Failure("Cant wait out the Issues " + bissues + ": " + named(exportPrim));
if (LocalFailures == 0)
{
LocalFailures++;
}
// return;
}
}
}
string issues = exportPrim.MissingData;
if (!string.IsNullOrEmpty(issues) && !settings.Allows(issues, exportPrim))
{
Failure("Issues " + issues + " " + named(exportPrim));
if (LocalFailures == 0)
{
LocalFailures++;
}
//return false;
}
//ImportCommand.PrimToCreate ptc = ImportCommand.Running.APrimToCreate(exportPrim.ID);
//ptc._prim = exportPrim.Prim;
bool passedOK = true;
if (settings.Contains("llsd"))
{
SaveLLSD(Client, pathStem, exportPrim, Failure, settings);
}
if (exportPrim.IsRoot && (true || exportPrim.Children.Count > 0))
{
if (settings.Contains("link"))
{
SaveLinksetInfo(Client, pathStem, exportPrim, Failure, settings);
}
string exportFile = pathStem + ".link";
//lock (fileWriterLock) if (File.Exists(exportFile))
{
foreach (var c in exportPrim.Children)
{
var ch = ExportPrim(Client, c, Failure, settings);
if (!ch)
{
passedOK = false;
}
}
}
}
if (settings.Contains("task"))
{
if (!SaveTaskInv(settings, Client, pathStem, exportPrim, Failure))
{
passedOK = false;
}
// ImportCommand.PrimToCreate ptc = ImportCommand.Running.APrimToCreate(exportPrim.ID);
// if (!ptc.EnsureTaskInv()) return false;
}
if (!settings.Contains("dep"))
{
return(passedOK);
}
AddRelatedTextures(exportPrim);
SaveRelatedAssets(pathStem, exportPrim, Failure);
return(passedOK);
}
private void SaveParcelInfo(ImportSettings settings)
{
var CurSim = settings.CurSim;
Client.Parcels.RequestAllSimParcels(CurSim);
if (CurSim.IsParcelMapFull())
{
ParcelsDownloaded.Set();
}
if (ParcelsDownloaded.WaitOne(30000, false) && Client.Network.Connected)
{
Success(string.Format("Downloaded {0} Parcels in {1} " + Environment.NewLine, CurSim.Parcels.Count, CurSim.Name));
IDictionary <int, Parcel> curSimParcels = null;
lock (CurSim.Parcels.Dictionary)
{
curSimParcels = LockInfo.CopyOf(CurSim.Parcels.Dictionary);
}
List <UUID> ParcelPrimOwners = new List <UUID>();
List <uint> ParcelObjectIDS = new List <uint>();
foreach (KeyValuePair <int, Parcel> simParcel in curSimParcels)
{
var parcel = simParcel.Value;
int parcelID = parcel.LocalID;
Success(string.Format(
"Parcel[{0}]: Name: \"{1}\", Description: \"{2}\" ACLBlacklist Count: {3}, ACLWhiteList Count: {5} Traffic: {4}" +
Environment.NewLine,
parcel.LocalID, parcel.Name, parcel.Desc,
parcel.AccessBlackList.Count, parcel.Dwell,
parcel.AccessWhiteList.Count));
AddExportUser(parcel.OwnerID);
AddExportGroup(parcel.GroupID);
Success(Helpers.StructToString(parcel));
foreach (
ParcelManager.ParcelAccessEntry white in parcel.AccessWhiteList)
{
if (white.AgentID != UUID.Zero)
{
Success(string.Format(
"\tAllowed Avatar {0}" + Environment.NewLine,
white.AgentID));
}
}
foreach (
ParcelManager.ParcelAccessEntry black in parcel.AccessBlackList)
{
// if(black.AgentID != UUID.Zero)
Success(string.Format("\t Banned Avatar {0}" + Environment.NewLine,
black.AgentID));
}
{
AutoResetEvent parcelOwnerWait = new AutoResetEvent(false);
EventHandler <ParcelObjectOwnersReplyEventArgs> callback =
delegate(object sender, ParcelObjectOwnersReplyEventArgs e)
{
for (int i = 0; i < e.PrimOwners.Count; i++)
{
ParcelManager.ParcelPrimOwners ownerse = e.PrimOwners[i];
if (ownerse.IsGroupOwned)
{
AddExportGroup(ownerse.OwnerID);
}
else
{
AddExportUser(ownerse.OwnerID);
}
Success(string.Format("Owner: {0} Count: {1}" + Environment.NewLine,
ownerse.OwnerID, ownerse.Count));
if (!CogbotHelpers.IsNullOrZero(ownerse.OwnerID))
{
ParcelPrimOwners.Add(ownerse.OwnerID);
}
}
parcelOwnerWait.Set();
};
Client.Parcels.ParcelObjectOwnersReply += callback;
try
{
Client.Parcels.RequestObjectOwners(CurSim, parcelID);
if (!parcelOwnerWait.WaitOne(10000, false))
{
Failure("Timed out waiting for packet.");
}
}
finally
{
Client.Parcels.ParcelObjectOwnersReply -= callback;
}
}
foreach (UUID ownerUUID in ParcelPrimOwners)
{
AutoResetEvent wait = new AutoResetEvent(false);
EventHandler <ForceSelectObjectsReplyEventArgs> callback = delegate(object sender, ForceSelectObjectsReplyEventArgs e)
{
ParcelObjectIDS.AddRange(e.ObjectIDs);
for (int i = 0; i < e.ObjectIDs.Count; i++)
{
// Success(string.Format(e.ObjectIDs[i].ToString() + " "));
// counter++;
}
if (e.ObjectIDs.Count < 251)
{
wait.Set();
}
};
Client.Parcels.ForceSelectObjectsReply += callback;
Client.Parcels.RequestSelectObjects(parcelID, (ObjectReturnType)16, ownerUUID);
wait.WaitOne(10000);
}
}
foreach (uint u in ParcelObjectIDS)
{
RequiredForExportLocalIDs.Add(u);
}
Success("Parcel LocalIDs=" + ParcelObjectIDS.Count + " ParcelOwners=" + ParcelPrimOwners.Count);
}
else
{
Failure("Failed to retrieve information on all the simulator parcels");
}
string parcelDirs = settings.OarDir + "landdata/";
Directory.CreateDirectory(parcelDirs);
SimRegion r = SimRegion.GetRegion(CurSim);
foreach (var p in r.ParcelMap)
{
Parcel parcel = p.Value;
if (CogbotHelpers.IsNullOrZero(parcel.GlobalID))
{
parcel.GlobalID = UUID.Random();
}
File.WriteAllText(parcelDirs + "" + parcel.GlobalID + ".xml", OarFile.Serialize(parcel));
}
}
private int ImportTaskFiles0(ImportSettings importSettings, bool createObjects)
{
//if (IsLocalScene) return 0;
DateTime lastProgressNotice = DateTime.Now;
int incomplete = 0;
var agentSyncFolderHolder = Exporting.FolderCalled("TaskInvHolder");
int created = 0;
foreach (var file in Directory.GetFiles(ExportCommand.dumpDir, "*.task"))
{
string fileUUID = Path.GetFileNameWithoutExtension(Path.GetFileName(file));
var ptc = APrimToCreate(UUID.Parse(fileUUID));
if (++created % 25 == 0)
{
WriteLine("tasked " + created);
}
if (ptc.PackedInsideNow)
{
continue;
}
// if (ptc.TaskInvComplete) continue;
if ((ptc.Prim.RegionHandle != importSettings.CurSim.Handle) && importSettings.Contains("CheckRegion"))
{
KillID(ptc.OldID);
continue;
}
string taskDataS = File.ReadAllText(file);
if (string.IsNullOrEmpty(taskDataS) || taskDataS.Length < 30)
{
ptc.TaskInvComplete = true;
continue;
}
ptc.CreateWorkflow(agentSyncFolderHolder);
if (!ptc.LoadTaskOSD(WriteLine))
{
//Failure("FAILED: LoadOSD " + ptc);
incomplete++;
continue;
}
if (!ptc.SyncToAgentFolder(WriteLine, createObjects))
{
//Failure("FAILED: SyncToAgentFolder " + ptc);
if (ptc.succeeded == 0)
{
continue;
}
}
if (!ptc.SyncToObject(WriteLine, createObjects))
{
//Failure("FAILED: SyncToObject " + ptc);
if (ptc.succeeded == 0)
{
continue;
}
}
if (!ptc.Complete)
{
Failure("INCOMPLETE: " + ptc);
incomplete++;
}
else
{
Success("COMPLETE: " + ptc);
}
if (!IsLocalScene)
{
Success("............");
}
if (lastProgressNotice.AddSeconds(30) < DateTime.Now)
{
lastProgressNotice = DateTime.Now;
WriteLine("Task created " + created + " incomplete=" + incomplete);
}
}
return(incomplete);
}
public static void WriteTaskInventory(Primitive sop, XmlTextWriter writer, ICollection<InventoryBase> tinv, ImportSettings options)
{
if (tinv == null)
{
return;
}
int ObjectNum = -1;
if (tinv.Count > 0) // otherwise skip this
{
writer.WriteStartElement("TaskInventory");
foreach (InventoryBase item2c in tinv)
{
InventoryItem item = item2c as InventoryItem;
if (item == null) continue;
string itemName = item.Name;
bool obj = (item.AssetType == AssetType.Object);
UUID itemAssetUUID = obj ? item.RezzID : item.AssetUUID;
if (obj)
{
ObjectNum++;
if (CogbotHelpers.IsNullOrZero(itemAssetUUID))
{
string rtiStatus = ExportCommand.dumpDir + sop.ID + "." + ObjectNum + ".rti";
lock (ExportCommand.fileWriterLock)
{
if (File.Exists(rtiStatus))
{
string[] conts = File.ReadAllText(rtiStatus).Split(',');
if (conts.Length > 2)
{
itemAssetUUID = UUID.Parse(conts[0]);
}
}
}
}
if (CogbotHelpers.IsNullOrZero(itemAssetUUID))
{
ExportCommand.LogError(sop.ID, "AssetZERO: " + item);
if (!options.ContainsKey("keepmissing")) continue;
if (options.ContainsKey("use404"))
itemAssetUUID = ImportCommand.GetMissingFiller(item.AssetType);
if (options.ContainsKey("error404") && !itemName.Contains("ERROR404"))
itemName += "ERROR404";
ImportCommand.Importing.Failure("Zero AssetID " + item.Name);
}
}
else
{
if (CogbotHelpers.IsNullOrZero(itemAssetUUID)) itemAssetUUID = item.RezzID;
if (CogbotHelpers.IsNullOrZero(itemAssetUUID))
{
ExportCommand.LogError(sop.ID, "AssetZERO: " + item);
if (!options.ContainsKey("keepmissing")) continue;
if (options.ContainsKey("use404"))
itemAssetUUID = ImportCommand.GetMissingFiller(item.AssetType);
if (options.ContainsKey("error404") && !itemName.Contains("ERROR404"))
itemName += "ERROR404";
ImportCommand.Importing.Failure("Zero AssetID " + item.Name);
}
}
writer.WriteStartElement("TaskInventoryItem");
Permissions perms = item.Permissions;
if (!options.Contains("sameperm"))
{
perms = Permissions.FullPermissions;
}
if (CogbotHelpers.IsNullOrZero(itemAssetUUID))
{
continue;
}
WriteUUID(writer, "AssetID", itemAssetUUID, options);
WriteEnum(writer, "BasePermissions", perms.BaseMask);
WriteDate(writer, "CreationDate", item.CreationDate);
WriteUUID(writer, "CreatorID", item.CreatorID, options);
/*
//todo if (item.CreatorData != null && item.CreatorData != string.Empty)
WES(writer,"CreatorData", item.CreatorData);
else if (options.ContainsKey("home"))
{
if (m_UserManagement == null)
m_UserManagement = scene.RequestModuleInterface<IUserManagement>();
string name = m_UserManagement.GetUserName(item.CreatorID);
WES(writer,"CreatorData", (string)options["home"] + ";" + name);
}
*/
WriteValue(writer, "Description", item.Description);
WriteEnum(writer, "EveryonePermissions", Reperm(perms.EveryoneMask, options));
WriteUInt(writer, "Flags", item.Flags);
WriteUUID(writer, "GroupID", item.GroupID, options);
WriteEnum(writer, "GroupPermissions", Reperm(perms.GroupMask, options));
WriteEnum(writer, "InvType", item.InventoryType);
WriteUUID(writer, "ItemID", item.UUID, options);
//todo WriteUUID(writer, "OldItemID", item.OldItemID, options);
UUID lastOwnerID = options.ContainsKey("wipe-owners") ? UUID.Zero : item.LastOwnerID;
WriteUserUUID(writer, "LastOwnerID", lastOwnerID, options);
WriteValue(writer, "Name", itemName);
WriteEnum(writer, "NextPermissions", Reperm(perms.NextOwnerMask, options));
UUID ownerID = options.ContainsKey("wipe-owners") ? UUID.Zero : item.OwnerID;
WriteUUID(writer, "OwnerID", ownerID, options);
WriteEnum(writer, "CurrentPermissions", Reperm(perms.OwnerMask, options));
WriteUUID(writer, "ParentID", item.ParentUUID, options);
/*todo
* WriteUUID(writer, "ParentPartID", item.ParentPartID, options);
WriteUUID(writer, "PermsGranter", item.PermsGranter, options);
*/
// todo what is this?
WriteEnum(writer, "PermsMask", PermissionMask.All);// perms.BaseMask);//item.PermsMask);
WriteEnum(writer, "Type", item.AssetType);
//todo WES(writer,"OwnerChanged", item.OwnerChanged.ToString().ToLower());
writer.WriteEndElement(); // TaskInventoryItem
}
writer.WriteEndElement(); // TaskInventory
}
}
internal bool SaveTaskInv(ImportSettings arglist, BotClient Client, string pathStem, SimObject exportPrim, OutputDelegate Failure)
{
string exportFile = pathStem + ".task";
if (Incremental || showsMissingOnly)
{
lock (fileWriterLock) if (File.Exists(exportFile))
{
return(true);
}
}
needFiles++;
exportPrim.StartGetTaskInventory();
bool mightHaveTaskInv = exportPrim.TaskInventoryLikely;
var ib = exportPrim.TaskInventory;
if (ib == null || ib == SimObjectImpl.ERROR_TASK_INV)
{
bool canSee = checkPerms(Client, exportPrim, SilientFailure, false);
bool canScript = checkPerms(Client, exportPrim, SilientFailure, true);
if (!canSee)
{
if (!mightHaveTaskInv)
{
LogError(exportPrim, "!canSee TaskInv");
lock (fileWriterLock) File.WriteAllText(exportFile, "!canSee");
return(true);
}
Failure("Cant get/check TaskInv of " + named(exportPrim));
}
Failure("NULL TaskInv for " + named(exportPrim));
if (!canScript)
{
LogError(exportPrim, "!canScript to get TaskInv");
lock (fileWriterLock) File.WriteAllText(exportFile, "!canScript");
return(true);
}
if (ib == SimObjectImpl.ERROR_TASK_INV)
{
LogError(exportPrim, "TaskInv Null once");
lock (fileWriterLock) File.WriteAllText(exportFile, "!error");
}
return(true);
}
if (ib.Count == 0)
{
if (!exportPrim.InventoryEmpty)
{
if (verbosely)
{
Failure("ZEROITEM TaskInv for " + named(exportPrim));
}
//return;
}
lock (fileWriterLock) File.WriteAllText(exportFile, "");
return(true);
}
if (ib.Count == 1)
{
if (ib[0].Name == "Contents" && ib[0] is InventoryFolder)
{
lock (fileWriterLock) File.WriteAllText(exportFile, "");
return(true);
}
}
SaveTaskOSD(exportPrim.ID, ib);
return(true);
OSDArray contents = new OSDArray();
string TaskInvFailures = "";
bool hasObjects = false;
foreach (InventoryBase b in ib)
{
if (b is InventoryObject)
{
hasObjects = true;
break;
}
}
bool wasShouldBeMoving = shouldBeMoving;
shouldBeMoving = false;
if (hasObjects && taskobj)
{
MoveCloseTo(exportPrim);
}
foreach (InventoryBase b in ib)
{
bool missing;
OSDMap was = SaveEachTaskItem(arglist, Client, exportPrim, b, Failure, out missing);
if (was != null)
{
contents.Add(was);
}
if (missing)
{
if (forced && false)
{
Failure("Missing but forced: " + was);
}
else
{
TaskInvFailures += was;
}
}
}
shouldBeMoving = wasShouldBeMoving;
// TaskInvFailures = GetTaskInvFailures(Failure, exportPrim, Client, folderObject, contents, TaskInvFailures);
if (showsMissingOnly)
{
Failure("NEED TASK for " + named(exportPrim));
return(false);
}
if (string.IsNullOrEmpty(TaskInvFailures))
{
lock (fileWriterLock) File.WriteAllText(exportFile, OSDParser.SerializeLLSDXmlString(contents));
}
else
{
Failure(string.Format("Skipping writting contents unil Items/Objects can be resolved: for {0}\n{1}",
named(exportPrim), TaskInvFailures));
}
var ptc = Importing.APrimToCreate(exportPrim.ID);
return(ptc.EnsureTaskInv(false));
}
void SaveLinksetInfo(BotClient Client, string pathStem, SimObject exportPrim, OutputDelegate Failure, ImportSettings settings)
{
string exportFile = pathStem + ".link";
if (Incremental || true)
{
lock (fileWriterLock) if (File.Exists(exportFile))
{
return;
}
}
if (false && exportPrim.Children.Count == 0)
{
// so we dont do it again
if (Incremental)
{
lock (fileWriterLock) File.WriteAllText(exportFile, "");
}
return;
}
if (Incremental || showsMissingOnly)
{
lock (fileWriterLock) if (File.Exists(exportFile))
{
return;
}
}
needFiles++;
if (showsMissingOnly)
{
Failure("NEED LINK for " + named(exportPrim));
return;
}
SlowlyDo(() => RequestLinksetInfo(Client, pathStem, exportPrim, Failure, settings));
}
public void ImportTaskObjects(ImportSettings importSettings)
{
DateTime lastProgressNotice = DateTime.Now;
int incomplete = 0;
var agentSyncFolderHolder = Exporting.FolderCalled("TaskInvHolder");
int created = 0;
var tos = LocalScene.TaskObjects;
foreach (var file in Directory.GetFiles(ExportCommand.dumpDir, "*.taskobj"))
{
string[] c = File.ReadAllText(file).Split(',');
TaskFileInfo to = new TaskFileInfo()
{
OldLid = uint.Parse(c[0]),
RezzedID = UUID.Parse(c[2]),
OldTaskHolder = UUID.Parse(c[3]),
AssetUUID = UUID.Parse(c[4]),
TaskItemID = UUID.Parse(c[5])
};
tos.Add(to);
created++;
}
foreach (TaskFileInfo o in tos)
{
var r = o.Rezzed;
if (r != null)
{
r.SetIsAsset();
}
}
foreach (TaskFileInfo o in tos)
{
PrimToCreate oInsideOf = o.InsideOf;
if (oInsideOf == null)
{
continue;
}
List <InventoryBase> taskInv = oInsideOf.SourceTaskInventory(true);
if (taskInv == null)
{
continue;
}
foreach (var b in taskInv)
{
InventoryItem i = b as InventoryItem;
if (i == null)
{
continue;
}
if (CogbotHelpers.IsNullOrZero(i.AssetUUID))
{
if (i.UUID == o.TaskItemID)
{
i.RezzID = o.RezzedID;
o.IsPlaced = true;
break;
}
}
}
}
foreach (TaskFileInfo o in tos)
{
if (!o.IsPlaced)
{
Failure("UNPLACED: " + o);
}
}
// this makes sure we know that late found childs are assets
foreach (PrimToCreate parent in LockInfo.CopyOf(parents))
{
if (parent.IsAsset)
{
parent.SetIsAsset();
}
}
}
static void SOPToXml(XmlTextWriter writer, Primitive sop, int linkNum, Primitive parent, ICollection<InventoryBase> taskInventory, ImportSettings options)
{
// Primitive parent = null; throw new NotImplementedException();//"GETPArent"
Primitive.ObjectProperties prop = sop.Properties;
writer.WriteStartElement("SceneObjectPart");
writer.WriteAttributeString("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
writer.WriteAttributeString("xmlns:xsd", "http://www.w3.org/2001/XMLSchema");
WriteUUID(writer, "UUID", sop.ID, options);
if (CogbotHelpers.IsNullOrZero(sop.ID))
{
throw new NullReferenceException("ID " + sop);
}
WriteValue(writer,"AllowedDrop",
((sop.Flags & PrimFlags.AllowInventoryDrop) != 0).ToString().ToLower());
WriteUserUUID(writer, "CreatorID", prop.CreatorID, options);
/*
if (sop.CreatorData != null && sop.CreatorData != string.Empty)
WES(writer,"CreatorData", sop.CreatorData);
else if (options.ContainsKey("home"))
{
if (m_UserManagement == null)
m_UserManagement = sop.ParentGroup.Scene.RequestModuleInterface<IUserManagement>();
string name = m_UserManagement.GetUserName(sop.CreatorID);
WES(writer,"CreatorData", (string)options["home"] + ";" + name);
}
*/
WriteUUID(writer, "FolderID", prop.FolderID, options);
WriteInt(writer,"InventorySerial", prop.InventorySerial);
WriteTaskInventory(sop, writer, taskInventory, options);
WriteFlags(writer, "ObjectFlags", sop.Flags, options);
WriteInt(writer,"LocalId", sop.LocalID);
WriteValue(writer,"Name", prop.Name);
WriteEnum(writer, "Material", sop.PrimData.Material);
WriteValue(writer,"PassTouches", "False");// sop.PassTouches.ToString().ToLower());
WriteUInt(writer,"RegionHandle", sop.RegionHandle);
WriteValue(writer,"ScriptAccessPin", "0");
Vector3 groupPosition;
if (parent == null)
groupPosition = sop.Position;
else
groupPosition = parent.Position;
WriteVector(writer, "GroupPosition", groupPosition);
if (sop.ParentID == 0)
WriteVector(writer, "OffsetPosition", Vector3.Zero);
else
WriteVector(writer, "OffsetPosition", sop.Position);
WriteQuaternion(writer, "RotationOffset", sop.Rotation);
WriteVector(writer, "Velocity", sop.Velocity);
WriteVector(writer, "AngularVelocity", sop.AngularVelocity);
WriteVector(writer, "Acceleration", sop.Acceleration);
WriteValue(writer,"Description", prop.Description);
writer.WriteStartElement("Color");
WriteFloat(writer,"R", sop.TextColor.R);
WriteFloat(writer,"G", sop.TextColor.G);
WriteFloat(writer,"B", sop.TextColor.B);
WriteFloat(writer,"A", sop.TextColor.G);
writer.WriteEndElement();
WriteValue(writer,"Text", sop.Text);
WriteValue(writer,"SitName", prop.SitName);
WriteValue(writer,"TouchName", prop.TouchName);
WriteInt(writer,"LinkNum", linkNum);
WriteEnum(writer,"ClickAction", sop.ClickAction);
WriteShape(writer, sop, sop.Properties, sop.PrimData, options);
WriteVector(writer, "Scale", sop.Scale);
WriteValue(writer,"UpdateFlag", "0");
WriteVector(writer, "SitTargetOrientation", Vector3.UnitZ);
WriteVector(writer, "SitTargetPosition", Vector3.Zero);
WriteVector(writer, "SitTargetPositionLL", Vector3.Zero);
WriteQuaternion(writer, "SitTargetOrientationLL", Quaternion.Identity);
WriteInt(writer,"ParentID", sop.ParentID);
WriteDate(writer, "CreationDate", sop.Properties.CreationDate);
WriteEnum(writer, "Category", sop.Properties.Category);
WriteInt(writer,"SalePrice", sop.Properties.SalePrice);
WriteEnum(writer, "ObjectSaleType", sop.Properties.SaleType);
WriteInt(writer,"OwnershipCost", sop.Properties.OwnershipCost);
WriteUUID(writer, "GroupID", sop.GroupID, options);
UUID ownerID = options.ContainsKey("wipe-owners") ? UUID.Zero : sop.OwnerID;
WriteUserUUID(writer, "OwnerID", ownerID, options);
UUID lastOwnerID = options.ContainsKey("wipe-owners") ? UUID.Zero : prop.LastOwnerID;
WriteUserUUID(writer, "LastOwnerID", lastOwnerID, options);
var perms = prop.Permissions;
if (!options.Contains("sameperm") || options.Contains("fullperm"))
{
perms = Permissions.FullPermissions;
}
WriteEnum(writer, "BaseMask", Reperm(perms.BaseMask, options));
WriteEnum(writer, "OwnerMask", Reperm(perms.OwnerMask, options));
WriteEnum(writer, "GroupMask", Reperm(perms.GroupMask, options));
WriteEnum(writer, "EveryoneMask", Reperm(perms.EveryoneMask, options));
WriteEnum(writer, "NextOwnerMask", Reperm(perms.NextOwnerMask, options));
WriteFlags(writer, "Flags", sop.Flags, options);
WriteUUID(writer, "CollisionSound", sop.Sound, options);
WriteFloat(writer,"CollisionSoundVolume", sop.SoundGain);
if (sop.MediaURL != null)
WriteValue(writer,"MediaUrl", sop.MediaURL);
WriteBytes(writer, "TextureAnimation", sop.TextureAnim.GetBytes());
WriteBytes(writer, "ParticleSystem", sop.ParticleSys.GetBytes());
/*
WES(writer,"PayPrice0", sop.PayPrice[0]);
WES(writer,"PayPrice1", sop.PayPrice[1]);
WES(writer,"PayPrice2", sop.PayPrice[2]);
WES(writer,"PayPrice3", sop.PayPrice[3]);
WES(writer,"PayPrice4", sop.PayPrice[4]);
*/
writer.WriteEndElement();
}
public void RequestLinksetInfo(BotClient Client, string pathStem, SimObject exportPrim, OutputDelegate Failure, ImportSettings settings)
{
string exportFile = pathStem + ".link";
lock (fileWriterLock) if (File.Exists(exportFile))
{
return;
}
bool canScript = checkPerms(Client, exportPrim, SilientFailure, true);
InventoryItem found = GetInvItem(Client, "LinksetSpeaker");
if (!canScript || found == null)
{
ScanForLinksets(exportPrim);
return;
}
lock (PrimWaitingLinkset)
{
if (PrimWaitingLinkset.ContainsKey(exportPrim.ID))
{
return;
}
PrimWaitingLinkset.Add(exportPrim.ID, new LinkSetBuffer {
S = "", O = exportPrim, F = pathStem
});
}
PutItemToTaskInv(Client, exportPrim.LocalID, exportPrim, "LinksetSpeaker");
}
static public string PerfectTaskOSD(UUID uuid, ImportSettings sets, bool includeRTI)
{
string exportFile = dumpDir + "" + uuid + ".task";
if (!File.Exists(exportFile))
{
return("!fnd");
}
string osdText = File.ReadAllText(exportFile);
if (osdText.Length < 20)
{
return("");
}
OSDArray osd = OSDParser.DeserializeLLSDXml(osdText) as OSDArray;
int objNum = -1;
bool writeBack = false;
string errors = "";
foreach (OSDMap array in osd)
{
var type = array["AssetType"].AsInteger();
if (type == (int)AssetType.Object)
{
objNum++;
var r = array["RezzID"];
if (r.Type == OSDType.Unknown)
{
File.Delete(exportFile);
return("old");
}
bool missingRezID = CogbotHelpers.IsNullOrZero(r.AsUUID());
if (!missingRezID)
{
continue;
}
if (!includeRTI)
{
return("!" + objNum);
}
string rtiFile = ExportCommand.dumpDir + "" + uuid + "." + objNum + ".rti";
if (!File.Exists(rtiFile))
{
return("!rti" + objNum);
}
var sf = File.ReadAllText(rtiFile).Split(',');
if (sf.Length > 2)
{
var ri = UUID.Parse(sf[0]);
if (CogbotHelpers.IsNullOrZero(ri))
{
errors += "!rti" + objNum;
continue;
}
array["RezzID"] = ri;
writeBack = true;
}
continue;
}
var o = array["AssetUUID"].AsUUID();
if (CogbotHelpers.IsNullOrZero(o))
{
return("!asset");
}
}
if (writeBack)
{
File.WriteAllText(exportFile, OSDParser.SerializeLLSDXmlString(osd));
}
return(errors);
}
public void SaveLLSD(BotClient Client, string pathStem, SimObject exportPrim, OutputDelegate Failure, ImportSettings settings)
{
if (exportPrim != null)
{
string exportFile = pathStem + ".llsd";
if (Incremental || showsMissingOnly)
{
lock (fileWriterLock) if (File.Exists(exportFile))
{
return;
}
}
needFiles++;
if (showsMissingOnly)
{
Failure("NEED LLSD for " + named(exportPrim));
AddMoveTo(exportPrim.SimPosition);
return;
}
try
{
List <string> skipTag = new List <string>()
{
"Tag"
};
Primitive prim = exportPrim.Prim;
Vector3 pp = prim.Position;
Quaternion pr = prim.Rotation;
//prim = prim.Clone();
OSDMap primOSD = (OSDMap)prim.GetOSD();
if (prim.ParentID != 0)
{
var parent = WorldSystem.GetLibOMVHostedPrim(prim.ParentID, settings.CurSim, false);
if (parent == null)
{
pp += new Vector3(128, 128, Client.Self.SimPosition.Z + 20);
Failure("YET FAILED: Cant GET parent of " + prim);
return;
}
else
{
pp = prim.Position * Matrix4.CreateFromQuaternion(parent.Rotation) + parent.Position;
pr = parent.Rotation * pr;
primOSD["ParentUUID"] = parent.ID;
}
}
primOSD["RegionPosition"] = pp;
primOSD["RegionRotation"] = pr;
if (exportPrim.PathFinding.MadeNonPhysical)
{
primOSD["physical"] = true;
primOSD["use_physics"] = true;
}
if (exportPrim.PathFinding.MadeNonTemp)
{
primOSD["temporary"] = true;
}
AddExportUser(primOSD["CreatorID"]);
AddExportGroup(primOSD["GroupID"]);
AddExportUser(primOSD["OwnerID"]);
AddExportUser(primOSD["LastOwnerID"]);
string output = OSDParser.SerializeLLSDXmlString(primOSD);
{
lock (fileWriterLock) File.WriteAllText(exportFile, output);
}
var ptc = Importing.APrimToCreate(prim);
ptc.Rezed = exportPrim;
if (forced && !verbosely)
{
return;
}
return;
Primitive prim2 = FromFile(exportFile, ExportCommand.UseBinarySerialization) as Primitive;
string memberwiseCompare = MemberwiseCompare(prim, prim2, skipTag);
if (!string.IsNullOrEmpty(memberwiseCompare))
{
string failre = "Error in LLSD: " + memberwiseCompare;
Failure(failre);
if (!forced)
{
File.Delete(exportFile);
return;
Error(failre);
}
}
}
catch (Exception e)
{
File.Delete(exportFile);
Failure("Writing file " + exportFile + " caused " + e);
}
}
}
public CmdResult Execute(string[] args, UUID fromAgentID, OutputDelegate writeLine)
{
if (!IsLocalScene)
{
ExportCommand.IsExporting = false;
}
else
{
ExportCommand.IsExporting = true;
}
const string hlp = @"
Toplevel Directives
// todo = shows what must be done for import to be complete (suggest adding verbose)
// perms = shows what perms are going to be a problem (suggest adding verbose)
// clear - clear the export dir
// reset - reset the exporter state
// cache - blow away asset cache
// prims [spec] - do only prims meeting spec (default is prims $region)
// incr - do only do what is 'todo'
// nonincr - do things 'todo' but also 'redo' things already done
// noperms = dont skip things when perms might be a problem
// quietly = terser output
// verbose = more verbose
// request = will rerequest missing things like textures
// force = will allow unequal LLSD files - this should only be used as last resort
// users - load users files
// prims - load llsd files
// trees - load trees files
// terrain - load terrain files
// links - operate on linkset
// tasks - save task files
// taskobjs - task objects
// all = users llsd tasks deps links (dl and taskobj not included)
";
if (args == null || args.Length == 0) return Failure(hlp);
ImportSettings importSettings = new ImportSettings();
ExportCommand.Exporting.settings = importSettings;
importSettings.GroupID = (args.Length > 1) ? TheBotClient.GroupID : UUID.Zero;
importSettings.CurSim = Client.Network.CurrentSim;
var arglist = importSettings;
writeLine("Starting SimImport...");
foreach (string s in args)
{
arglist.Add(s);
}
if (arglist.Contains("reoar"))
{
OarFile.PackageArchive("cog_export/oarfile/", "repack.oar", false, false);
return SuccessOrFailure();
}
if (arglist.Contains("nolldie"))
{
ReplaceLSLText(ExportCommand.assetDumpDir,"llDie()",
"llOwnerSay((string)llGetKey() + \",script caused die ,\" + llGetObjectName() + \",\" + (string)llGetPos() + \",\" + llGetScriptName() + \",\" + llGetLinkNumber())",
arglist);
return SuccessOrFailure();
}
if (arglist.Contains("hhp"))
{
//arglist.Add("keepmissing");
//arglist.Add("all");
//arglist.Add("oar");
arglist.Add("fullperms");
// arglist.Add("lslprims");
//arglist.Add("request");
//arglist.Add("KillMissing");
arglist.Add("reztaskobj");
arglist.Add("prim");
arglist.Add("confirm");
arglist.Add("link");
arglist.Add("checktasks");
arglist.Add("tasklsl");
}
bool doRez = false;
if (arglist.Contains("all"))
{
// arglist.Add("terrain");
arglist.Add("asset");
arglist.Add("user");
arglist.Add("group");
arglist.Add("prim");
arglist.Add("confirm");
arglist.Add("link");
arglist.Add("task");
arglist.Add("taskobj");
arglist.Add("CountReady");
}
if (arglist.Contains("prim"))
{
doRez = true;
arglist.Add("asset");
arglist.Add("link");
}
if (arglist.Contains("nolink"))
{
arglist.Remove("link");
}
if (arglist.Contains("noasset"))
{
arglist.Remove("asset");
}
if (arglist.Contains("link"))
{
arglist.Add("confirm");
}
if (arglist.Contains("user") || arglist.Contains("group") || true)
{
LoadUsersAndGroups(arglist);
}
if (arglist.Contains("asset") || true)
{
UploadAllAssets(arglist);
}
GleanUUIDsFrom(GetAssetUploadsFolder());
ScanForChangeList();
if (arglist.Contains("terrain")) UploadTerrain(importSettings);
WriteLine("NewAsset ChangeList Size is " + ChangeList.Count);
if (arglist.Contains("confirm")) ImportPTCFiles(importSettings, false, doRez);
if (arglist.Contains("prim")) ImportPrims(importSettings, doRez);
if (doRez) RezPrims(importSettings);
if (arglist.Contains("confirm")) ConfirmLocalIDs(importSettings);
if (arglist.Contains("link")) ImportLinks(importSettings);
if (arglist.Contains("move"))
{
MoveToKnownObjects();
Success("Moving to " + _parents.Count);
}
bool tasksObjs = arglist.Contains("taskobj") && !IsLocalScene;
if (tasksObjs || arglist.Contains("checktasks")) ImportTaskObjects(importSettings);
if (arglist.Contains("task") || tasksObjs) ImportTaskFiles(importSettings, tasksObjs);
GleanUUIDsFrom(GetAssetUploadsFolder());
SaveMissingIDs();
if (arglist.Contains("request")) RequestMissingIDs(importSettings);
if (arglist.Contains("locate"))
{
LocatePrims(importSettings);
}
DivideTaskObjects(importSettings);
if (arglist.Contains("killmissing")) KillMissing(importSettings);
if (arglist.Contains("lslprims")) ConfirmLSLPrims(importSettings);
if (arglist.Contains("todo")) DoTodo(importSettings);
if (arglist.Contains("checktasks")) CheckTasks(importSettings);
if (arglist.Contains("upackobjs")) UnpackTaskObjs(importSettings);
if (arglist.Contains("oar")) CreateOARFile(importSettings, "exported.oar");
if (arglist.Contains("CountReady")) CountReady(importSettings);
if (arglist.Contains("cleanup")) CleanupPrims(importSettings);
if (arglist.Contains("cleanuptasks")) CleanupTasks(importSettings);
writeLine("Completed SimImport");
return SuccessOrFailure();
}
public static bool IsSkipped(SimObject P, ImportSettings settings)
{
if (P is SimAvatar)
{
return(true);
}
if (P == null)
{
return(true);
}
if (IsIncluded(P.ID, P.LocalID))
{
return(false);
}
if (P.Parent != null)
{
if (IsIncluded(P.Parent.ID, P.ParentID))
{
return(false);
}
}
Primitive pp = P.Prim0;
if (P.IsKilled)
{
if (pp != null)
{
if (P.IsTemporary)
{
return(true);
}
}
}
if (P.IsTemporary)
{
return(true);
}
if (!P.HasPrim)
{
return(true);
}
if (pp == null)
{
return(true);
}
var sp = P.SimPosition;
if (!onlyObjectAt.IsInside(sp.X, sp.Y, sp.Z))
{
return(true);
}
Primitive.ObjectProperties props = pp.Properties;
if (props != null)
{
if (IsSkippedName(props.Name))
{
return(true);
}
}
if (pp.ParentID == 0)
{
return(false);
}
SimObject parent = P.Parent;
// yes SL really does have links two deep! (called attachment linksets)
if (parent == null)
{
return(true);
}
if (parent == P)
{
return(false);
}
if (!IsSkipped(parent, settings))
{
return(false);
}
return(true);
}
private void CreateOARFile(ImportSettings settings, string filename)
{
string rootDir = ExportCommand.dumpDir + "../oarfile/";
OarFile.PrepareDir(rootDir);
// Objects
foreach (PrimToCreate parent in parents)
{
var ls = new Linkset()
{
Parent = parent
};
parent.Link = ls;
LocalScene.Links.Add(ls);
}
foreach (PrimToCreate ch in childs)
{
var pp = ch.ParentPrim;
if (pp == null)
{
continue;
}
pp.Link.ChildAdd(ch);
}
foreach (var ls in LockInfo.CopyOf(LocalScene.Links))
{
ls.Children.Sort(compareLocalIDs);
if (ls.Parent.IsAsset)
{
LocalScene.AssetLinks.Add(ls);
LocalScene.Links.Remove(ls);
}
}
foreach (var ls in LocalScene.Links)
{
OarFile.SaveLinkset(ls, rootDir + "objects/" + ls.Parent.NewID + ArchiveConstants.ASSET_TYPE_TO_EXTENSION[AssetType.Object], false, settings);
}
// Assets
foreach (ItemToCreate asset in LocalScene.Assets)
{
File.WriteAllBytes(rootDir + "assets/" + asset.OldID + ArchiveConstants.ASSET_TYPE_TO_EXTENSION[asset.AssetType], asset.AssetData);
}
foreach (var ls in LocalScene.AssetLinks)
{
OarFile.SaveLinkset(ls, rootDir + "assets/" + ls.Parent.NewID + ArchiveConstants.ASSET_TYPE_TO_EXTENSION[AssetType.Object], true, settings);
}
// Terrain
if (settings.ContainsKey("terrain")) ExportCommand.Exporting.SaveTerrainRaw32(rootDir + "terrains/heightmap.raw");
string parcelDirs = rootDir + "landdata/";
Directory.CreateDirectory(parcelDirs);
OarFile.PackageArchive(rootDir, filename, settings.ContainsKey("terrain"), settings.ContainsKey("land"));
}
static public string IsComplete(UUID uuid, bool includeLink, bool includeTask, ImportSettings settings)
{
string whynotCOmplete = "";
if (ImportCommand.MissingLLSD(uuid))
{
return("!llsd");
}
if (includeLink && ImportCommand.MissingLINK(uuid))
{
whynotCOmplete += "!link";
}
if (ImportCommand.MissingTASK(uuid))
{
return(whynotCOmplete += "!task");
}
whynotCOmplete += PerfectTaskOSD(uuid, settings, true);
return(whynotCOmplete);
}
static void SOPToXml(XmlTextWriter writer, Primitive sop, int linkNum, Primitive parent, ICollection <InventoryBase> taskInventory, ImportSettings options)
{
// Primitive parent = null; throw new NotImplementedException();//"GETPArent"
Primitive.ObjectProperties prop = sop.Properties;
writer.WriteStartElement("SceneObjectPart");
writer.WriteAttributeString("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
writer.WriteAttributeString("xmlns:xsd", "http://www.w3.org/2001/XMLSchema");
WriteUUID(writer, "UUID", sop.ID, options);
if (CogbotHelpers.IsNullOrZero(sop.ID))
{
throw new NullReferenceException("ID " + sop);
}
WriteValue(writer, "AllowedDrop",
((sop.Flags & PrimFlags.AllowInventoryDrop) != 0).ToString().ToLower());
WriteUserUUID(writer, "CreatorID", prop.CreatorID, options);
/*
* if (sop.CreatorData != null && sop.CreatorData != string.Empty)
* WES(writer,"CreatorData", sop.CreatorData);
* else if (options.ContainsKey("home"))
* {
* if (m_UserManagement == null)
* m_UserManagement = sop.ParentGroup.Scene.RequestModuleInterface<IUserManagement>();
* string name = m_UserManagement.GetUserName(sop.CreatorID);
* WES(writer,"CreatorData", (string)options["home"] + ";" + name);
* }
*/
WriteUUID(writer, "FolderID", prop.FolderID, options);
WriteInt(writer, "InventorySerial", prop.InventorySerial);
WriteTaskInventory(sop, writer, taskInventory, options);
WriteFlags(writer, "ObjectFlags", sop.Flags, options);
WriteInt(writer, "LocalId", sop.LocalID);
WriteValue(writer, "Name", prop.Name);
WriteEnum(writer, "Material", sop.PrimData.Material);
WriteValue(writer, "PassTouches", "False");// sop.PassTouches.ToString().ToLower());
WriteUInt(writer, "RegionHandle", sop.RegionHandle);
WriteValue(writer, "ScriptAccessPin", "0");
Vector3 groupPosition;
if (parent == null)
{
groupPosition = sop.Position;
}
else
{
groupPosition = parent.Position;
}
WriteVector(writer, "GroupPosition", groupPosition);
if (sop.ParentID == 0)
{
WriteVector(writer, "OffsetPosition", Vector3.Zero);
}
else
{
WriteVector(writer, "OffsetPosition", sop.Position);
}
WriteQuaternion(writer, "RotationOffset", sop.Rotation);
WriteVector(writer, "Velocity", sop.Velocity);
WriteVector(writer, "AngularVelocity", sop.AngularVelocity);
WriteVector(writer, "Acceleration", sop.Acceleration);
WriteValue(writer, "Description", prop.Description);
writer.WriteStartElement("Color");
WriteFloat(writer, "R", sop.TextColor.R);
WriteFloat(writer, "G", sop.TextColor.G);
WriteFloat(writer, "B", sop.TextColor.B);
WriteFloat(writer, "A", sop.TextColor.G);
writer.WriteEndElement();
WriteValue(writer, "Text", sop.Text);
WriteValue(writer, "SitName", prop.SitName);
WriteValue(writer, "TouchName", prop.TouchName);
WriteInt(writer, "LinkNum", linkNum);
WriteEnum(writer, "ClickAction", sop.ClickAction);
WriteShape(writer, sop, sop.Properties, sop.PrimData, options);
WriteVector(writer, "Scale", sop.Scale);
WriteValue(writer, "UpdateFlag", "0");
WriteVector(writer, "SitTargetOrientation", Vector3.UnitZ);
WriteVector(writer, "SitTargetPosition", Vector3.Zero);
WriteVector(writer, "SitTargetPositionLL", Vector3.Zero);
WriteQuaternion(writer, "SitTargetOrientationLL", Quaternion.Identity);
WriteInt(writer, "ParentID", sop.ParentID);
WriteDate(writer, "CreationDate", sop.Properties.CreationDate);
WriteEnum(writer, "Category", sop.Properties.Category);
WriteInt(writer, "SalePrice", sop.Properties.SalePrice);
WriteEnum(writer, "ObjectSaleType", sop.Properties.SaleType);
WriteInt(writer, "OwnershipCost", sop.Properties.OwnershipCost);
WriteUUID(writer, "GroupID", sop.GroupID, options);
UUID ownerID = options.ContainsKey("wipe-owners") ? UUID.Zero : sop.OwnerID;
WriteUserUUID(writer, "OwnerID", ownerID, options);
UUID lastOwnerID = options.ContainsKey("wipe-owners") ? UUID.Zero : prop.LastOwnerID;
WriteUserUUID(writer, "LastOwnerID", lastOwnerID, options);
var perms = prop.Permissions;
if (!options.Contains("sameperm") || options.Contains("fullperm"))
{
perms = Permissions.FullPermissions;
}
WriteEnum(writer, "BaseMask", Reperm(perms.BaseMask, options));
WriteEnum(writer, "OwnerMask", Reperm(perms.OwnerMask, options));
WriteEnum(writer, "GroupMask", Reperm(perms.GroupMask, options));
WriteEnum(writer, "EveryoneMask", Reperm(perms.EveryoneMask, options));
WriteEnum(writer, "NextOwnerMask", Reperm(perms.NextOwnerMask, options));
WriteFlags(writer, "Flags", sop.Flags, options);
WriteUUID(writer, "CollisionSound", sop.Sound, options);
WriteFloat(writer, "CollisionSoundVolume", sop.SoundGain);
if (sop.MediaURL != null)
{
WriteValue(writer, "MediaUrl", sop.MediaURL);
}
WriteBytes(writer, "TextureAnimation", sop.TextureAnim.GetBytes());
WriteBytes(writer, "ParticleSystem", sop.ParticleSys.GetBytes());
/*
* WES(writer,"PayPrice0", sop.PayPrice[0]);
* WES(writer,"PayPrice1", sop.PayPrice[1]);
* WES(writer,"PayPrice2", sop.PayPrice[2]);
* WES(writer,"PayPrice3", sop.PayPrice[3]);
* WES(writer,"PayPrice4", sop.PayPrice[4]);
*/
writer.WriteEndElement();
}
public static void WriteTaskInventory(Primitive sop, XmlTextWriter writer, ICollection <InventoryBase> tinv, ImportSettings options)
{
if (tinv == null)
{
return;
}
int ObjectNum = -1;
if (tinv.Count > 0) // otherwise skip this
{
writer.WriteStartElement("TaskInventory");
foreach (InventoryBase item2c in tinv)
{
InventoryItem item = item2c as InventoryItem;
if (item == null)
{
continue;
}
string itemName = item.Name;
bool obj = (item.AssetType == AssetType.Object);
UUID itemAssetUUID = obj ? item.RezzID : item.AssetUUID;
if (obj)
{
ObjectNum++;
if (CogbotHelpers.IsNullOrZero(itemAssetUUID))
{
string rtiStatus = ExportCommand.dumpDir + sop.ID + "." + ObjectNum + ".rti";
lock (ExportCommand.fileWriterLock)
{
if (File.Exists(rtiStatus))
{
string[] conts = File.ReadAllText(rtiStatus).Split(',');
if (conts.Length > 2)
{
itemAssetUUID = UUID.Parse(conts[0]);
}
}
}
}
if (CogbotHelpers.IsNullOrZero(itemAssetUUID))
{
ExportCommand.LogError(sop.ID, "AssetZERO: " + item);
if (!options.ContainsKey("keepmissing"))
{
continue;
}
if (options.ContainsKey("use404"))
{
itemAssetUUID = ImportCommand.GetMissingFiller(item.AssetType);
}
if (options.ContainsKey("error404") && !itemName.Contains("ERROR404"))
{
itemName += "ERROR404";
}
ImportCommand.Importing.Failure("Zero AssetID " + item.Name);
}
}
else
{
if (CogbotHelpers.IsNullOrZero(itemAssetUUID))
{
itemAssetUUID = item.RezzID;
}
if (CogbotHelpers.IsNullOrZero(itemAssetUUID))
{
ExportCommand.LogError(sop.ID, "AssetZERO: " + item);
if (!options.ContainsKey("keepmissing"))
{
continue;
}
if (options.ContainsKey("use404"))
{
itemAssetUUID = ImportCommand.GetMissingFiller(item.AssetType);
}
if (options.ContainsKey("error404") && !itemName.Contains("ERROR404"))
{
itemName += "ERROR404";
}
ImportCommand.Importing.Failure("Zero AssetID " + item.Name);
}
}
writer.WriteStartElement("TaskInventoryItem");
Permissions perms = item.Permissions;
if (!options.Contains("sameperm"))
{
perms = Permissions.FullPermissions;
}
if (CogbotHelpers.IsNullOrZero(itemAssetUUID))
{
continue;
}
WriteUUID(writer, "AssetID", itemAssetUUID, options);
WriteEnum(writer, "BasePermissions", perms.BaseMask);
WriteDate(writer, "CreationDate", item.CreationDate);
WriteUUID(writer, "CreatorID", item.CreatorID, options);
/*
* //todo if (item.CreatorData != null && item.CreatorData != string.Empty)
* WES(writer,"CreatorData", item.CreatorData);
* else if (options.ContainsKey("home"))
* {
* if (m_UserManagement == null)
* m_UserManagement = scene.RequestModuleInterface<IUserManagement>();
* string name = m_UserManagement.GetUserName(item.CreatorID);
* WES(writer,"CreatorData", (string)options["home"] + ";" + name);
* }
*/
WriteValue(writer, "Description", item.Description);
WriteEnum(writer, "EveryonePermissions", Reperm(perms.EveryoneMask, options));
WriteUInt(writer, "Flags", item.Flags);
WriteUUID(writer, "GroupID", item.GroupID, options);
WriteEnum(writer, "GroupPermissions", Reperm(perms.GroupMask, options));
WriteEnum(writer, "InvType", item.InventoryType);
WriteUUID(writer, "ItemID", item.UUID, options);
//todo WriteUUID(writer, "OldItemID", item.OldItemID, options);
UUID lastOwnerID = options.ContainsKey("wipe-owners") ? UUID.Zero : item.LastOwnerID;
WriteUserUUID(writer, "LastOwnerID", lastOwnerID, options);
WriteValue(writer, "Name", itemName);
WriteEnum(writer, "NextPermissions", Reperm(perms.NextOwnerMask, options));
UUID ownerID = options.ContainsKey("wipe-owners") ? UUID.Zero : item.OwnerID;
WriteUUID(writer, "OwnerID", ownerID, options);
WriteEnum(writer, "CurrentPermissions", Reperm(perms.OwnerMask, options));
WriteUUID(writer, "ParentID", item.ParentUUID, options);
/*todo
* WriteUUID(writer, "ParentPartID", item.ParentPartID, options);
* WriteUUID(writer, "PermsGranter", item.PermsGranter, options);
*/
// todo what is this?
WriteEnum(writer, "PermsMask", PermissionMask.All);// perms.BaseMask);//item.PermsMask);
WriteEnum(writer, "Type", item.AssetType);
//todo WES(writer,"OwnerChanged", item.OwnerChanged.ToString().ToLower());
writer.WriteEndElement(); // TaskInventoryItem
}
writer.WriteEndElement(); // TaskInventory
}
}
public bool ExportPrim(BotClient Client, SimObject exportPrim, OutputDelegate Failure, ImportSettings settings)
{
uint localID = exportPrim.LocalID;
WorldObjects.EnsureRequested(localID + 1, settings.CurSim);
try
{
Client.Objects.SelectObject(settings.CurSim, localID);
WorldObjects.EnsureRequested(localID, settings.CurSim);
return ExportPrim0(Client, exportPrim, Failure, settings);
}
finally
{
Client.Objects.DeselectObject(settings.CurSim, localID);
}
}
public static void WriteShape(XmlTextWriter writer, Primitive prim, Primitive.ObjectProperties props, Primitive.ConstructionData shp, ImportSettings options)
{
if (true /*shp != null*/)
{
writer.WriteStartElement("Shape");
WriteEnum(writer, "ProfileCurve", shp.ProfileCurve);
writer.WriteStartElement("TextureEntry");
byte[] te;
if (prim.Textures != null)
{
te = prim.Textures.GetBytes();
}
else
{
te = Utils.EmptyBytes;
}
writer.WriteBase64(te, 0, te.Length);
writer.WriteEndElement(); // TextureEntry
writer.WriteStartElement("ExtraParams");
byte[] ep;
if (prim.GetExtraParamsBytes() != null)
{
ep = prim.GetExtraParamsBytes();
}
else
{
ep = Utils.EmptyBytes;
}
writer.WriteBase64(ep, 0, ep.Length);
writer.WriteEndElement(); // ExtraParams
writer.WriteElementString("PathBegin", Primitive.PackBeginCut(shp.PathBegin).ToString());
WriteEnum(writer, "PathCurve", shp.PathCurve);
writer.WriteElementString("PathEnd", Primitive.PackEndCut(shp.PathEnd).ToString());
writer.WriteElementString("PathRadiusOffset", Primitive.PackPathTwist(shp.PathRadiusOffset).ToString());
writer.WriteElementString("PathRevolutions", Primitive.PackPathRevolutions(shp.PathRevolutions).ToString());
writer.WriteElementString("PathScaleX", Primitive.PackPathScale(shp.PathScaleX).ToString());
writer.WriteElementString("PathScaleY", Primitive.PackPathScale(shp.PathScaleY).ToString());
writer.WriteElementString("PathShearX", ((byte)Primitive.PackPathShear(shp.PathShearX)).ToString());
writer.WriteElementString("PathShearY", ((byte)Primitive.PackPathShear(shp.PathShearY)).ToString());
writer.WriteElementString("PathSkew", Primitive.PackPathTwist(shp.PathSkew).ToString());
writer.WriteElementString("PathTaperX", Primitive.PackPathTaper(shp.PathTaperX).ToString());
writer.WriteElementString("PathTaperY", Primitive.PackPathTaper(shp.PathTaperY).ToString());
writer.WriteElementString("PathTwist", Primitive.PackPathTwist(shp.PathTwist).ToString());
writer.WriteElementString("PathTwistBegin", Primitive.PackPathTwist(shp.PathTwistBegin).ToString());
writer.WriteElementString("ProfileBegin", Primitive.PackBeginCut(shp.ProfileBegin).ToString());
writer.WriteElementString("ProfileEnd", Primitive.PackEndCut(shp.ProfileEnd).ToString());
writer.WriteElementString("ProfileHollow", Primitive.PackProfileHollow(shp.ProfileHollow).ToString());
WriteEnum(writer, "PCode", shp.PCode);
// this is Attachment in a way?
WriteInt(writer, "State", shp.State);
//WriteEnum(writer, "State", shp.AttachmentPoint);
WriteFlags(writer, "ProfileShape", shp.ProfileCurve, options);
WriteFlags(writer, "HollowShape", shp.ProfileHole, options);
var Sculpt = prim.Sculpt;
if (Sculpt != null)
{
WriteUUID(writer, "SculptTexture", Sculpt.SculptTexture, options);
WriteEnum(writer, "SculptType", Sculpt.Type);
writer.WriteStartElement("SculptData");
byte[] sd;
if (prim.Sculpt != null)
{
sd = Sculpt.GetBytes();
}
else
{
sd = Utils.EmptyBytes;
}
writer.WriteBase64(sd, 0, sd.Length);
writer.WriteEndElement(); // SculptData
}
Primitive.FlexibleData Flexi = prim.Flexible;
if (Flexi != null)
{
WriteInt(writer, "FlexiSoftness", Flexi.Softness);
WriteFloat(writer, "FlexiTension", Flexi.Tension);
WriteFloat(writer, "FlexiDrag", Flexi.Drag);
WriteFloat(writer, "FlexiGravity", Flexi.Gravity);
WriteFloat(writer, "FlexiWind", Flexi.Wind);
WriteFloat(writer, "FlexiForceX", Flexi.Force.X);
WriteFloat(writer, "FlexiForceY", Flexi.Force.Y);
WriteFloat(writer, "FlexiForceZ", Flexi.Force.Z);
}
Primitive.LightData Light = prim.Light;
if (Light != null)
{
WriteFloat(writer, "LightColorR", Light.Color.R);
WriteFloat(writer, "LightColorG", Light.Color.G);
WriteFloat(writer, "LightColorB", Light.Color.B);
WriteFloat(writer, "LightColorA", Light.Color.A);
WriteFloat(writer, "LightRadius", Light.Radius);
WriteFloat(writer, "LightCutoff", Light.Cutoff);
WriteFloat(writer, "LightFalloff", Light.Falloff);
WriteFloat(writer, "LightIntensity", Light.Intensity);
}
WriteValue(writer, "FlexiEntry", (Flexi != null).ToString().ToLower());
WriteValue(writer, "LightEntry", (Light != null).ToString().ToLower());
WriteValue(writer, "SculptEntry", (Sculpt != null).ToString().ToLower());
//todo if (shp.Media != null) WES(writer,"Media", shp.Media.ToXml());
writer.WriteEndElement(); // Shape
}
}
void SaveLinksetInfo(BotClient Client, string pathStem, SimObject exportPrim, OutputDelegate Failure, ImportSettings settings)
{
string exportFile = pathStem + ".link";
if (Incremental || true) lock (fileWriterLock) if (File.Exists(exportFile)) return;
if (false && exportPrim.Children.Count == 0)
{
// so we dont do it again
if (Incremental) lock (fileWriterLock) File.WriteAllText(exportFile, "");
return;
}
if (Incremental || showsMissingOnly) lock (fileWriterLock) if (File.Exists(exportFile)) return;
needFiles++;
if (showsMissingOnly)
{
Failure("NEED LINK for " + named(exportPrim));
return;
}
SlowlyDo(() => RequestLinksetInfo(Client, pathStem, exportPrim, Failure, settings));
}
public CmdResult Execute(string[] args, UUID fromAgentID, OutputDelegate WriteLine)
{
Client.Self.Movement.Camera.Far = 1023;
Client.Self.Movement.SendUpdate(true);
Exporting = this;
IsExporting = true;
var CurSim = Client.Network.CurrentSim;
RegionHandle = CurSim.Handle;
haveBeenTo.AddPoint(TheSimAvatar.SimPosition);
AttemptSitMover();
WorldObjects.MaintainSimObjectInfoMap = false;
SimObjectImpl.AffordinancesGuessSimObjectTypes = false;
WorldSystem.IgnoreKillObjects = true;
inventoryHolder.Clear();
lslScripts.Clear();
successfullyExportedPrims.Clear();
const string hlp = @"
Toplevel Directives
// todo = shows what must be done for export to be complete (suggest adding verbose)
// perms = shows what perms are going to be a problem (suggest adding verbose)
// clear - clear the export dir
// reset - reset the exporter state
// cache - blow away asset cache
// move - begin moving arround
// nomove - stop moving arround
// spec [spec] - do only prims meeting spec (default is 'spec $region')
// incr - do only do what is 'todo'
// nonincr - do things 'todo' but also 'redo' things already done
// noperms = dont skip things when perms might be a problem
// quietly = terser output
// verbose = more verbose
// request = will rerequest missing things like textures
// force = will allow unequal LLSD files - this should only be used as last resort
// users - users files
// groups - groups files
// terrain - terrain files
// parcels - parcels files
// estate - estate files (TODO)
// siminfo - estate files (TODO)
// llsd - llsd files
// links - operate on linset
// deps - operate on dependant assets
// dl - operate on dependant downloads
// tasks - save task files
// taskobj - task objects
// all = llsd tasks deps links (dl and taskobj not included)
";
if (args == null || args.Length == 0)
{
return(Failure(hlp));
}
string[] nargs = { "$region" };
ImportSettings arglist = new ImportSettings
{
CurSim = Client.Network.CurrentSim,
GroupID = Client.Self.ActiveGroup
};
settings = arglist;
if (args[0] == "hhp")
{
args = new string[] { "taskobjs", "nobuf", "all", "spec", "f0a89a9f-3f33-b2aa-2829-eaeec3d08b82" };
}
foreach (string s in args)
{
arglist.Add(s);
}
if (arglist.Contains("error"))
{
return(WriteErrors(args));
}
if (arglist.Contains("help"))
{
return(Success(hlp));
}
if (args.Length > 1)
{
int specIndex = Array.IndexOf(args, "spec");
if (specIndex > 0)
{
nargs = Parser.SplitOff(args, specIndex + 1);
}
int fnd = Array.IndexOf(args, "move");
if (fnd > -1 && (fnd + 1 < args.Length))
{
int mv;
if (int.TryParse(args[fnd + 1], out mv))
{
moveSleep = mv;
if ((fnd + 2 < args.Length) && int.TryParse(args[fnd + 2], out mv))
{
maxHeigth = mv;
}
}
}
}
if (arglist.Contains("move"))
{
if (arglist.Contains("wps"))
{
AddRegionWaypoints();
}
BeginMoving();
GiveStatus();
return(Success("Began moving"));
}
if (arglist.Contains("nomove"))
{
StopMoving();
GiveStatus();
return(Success("Stopped moving"));
}
quietly = arglist.Contains("quietly");
if (arglist.Contains("prim"))
{
arglist.Add("llsd");
arglist.Add("dep");
arglist.Add("link");
}
if (arglist.Contains("all"))
{
arglist.Add("llsd");
arglist.Add("task");
arglist.Add("dep");
arglist.Add("link");
}
needFiles = 0;
taskobj = arglist.Contains("taskobj");
forced = arglist.Contains("force") || arglist.Contains("forced");
if (arglist.Contains("nonincr"))
{
Incremental = false;
}
if (arglist.Contains("incr"))
{
Incremental = true;
}
bool fileOnly = false;
lock (fileWriterLock)
{
if (arglist.Contains("clear"))
{
KillAllUnpacked(WriteLine, true);
PurgeExport();
arglist.Add("reset");
}
if (!Directory.Exists(dumpDir))
{
Directory.CreateDirectory(dumpDir);
}
if (!Directory.Exists(assetDumpDir))
{
Directory.CreateDirectory(assetDumpDir);
}
if (!Directory.Exists(terrainDir))
{
Directory.CreateDirectory(terrainDir);
}
if (!Directory.Exists(siminfoDir))
{
Directory.CreateDirectory(siminfoDir);
}
if (arglist.Contains("cache"))
{
fileOnly = true;
PurgeCache();
}
}
if (arglist.Contains("reset"))
{
slowlyExport.Clear();
lock (ToDownloadAssets) ToDownloadAssets.Clear();
lock (CompletedAssets) CompletedAssets.Clear();
lock (PrimWaitingLinkset) PrimWaitingLinkset.Clear();
lock (AllRelatedAssets) AllRelatedAssets.Clear();
lock (PrimDepsAssets) PrimDepsAssets.Clear();
lock (TaskAssetWaiting) TaskAssetWaiting.Clear();
lock (CompletedTaskItem) CompletedTaskItem.Clear();
#if OBJECTUNPACKER
lock (TasksRezed) TasksRezed.Clear();
#endif
GiveStatus();
return(Success("Reset SimExport State"));
}
if (fileOnly)
{
GiveStatus();
return(Success("Manipulated filesystem"));
}
if (arglist.Contains("cleanup"))
{
return(CleanupAfterExport(fromAgentID, WriteLine));
}
if (arglist.Contains("killtasks"))
{
KillAllUnpacked(WriteLine, true);
return(SuccessOrFailure());
}
IsExporting = true;
FolderCalled("TaskInvHolder");
//string file = args[args.Length - 1];
int used;
List <SimObject> PS = WorldSystem.GetPrimitives(nargs, out used);
if (IsEmpty(PS))
{
return(Failure("Cannot find objects from " + string.Join(" ", args)));
}
showsStatus = arglist.Contains("statu");
showPermsOnly = arglist.Contains("perm");
skipPerms = !arglist.Contains("obeyperm");
showsMissingOnly = arglist.Contains("todo");
if (showsMissingOnly)
{
quietly = true;
}
verbosely = arglist.Contains("verbose");
if (verbosely && !arglist.Contains("quietly"))
{
quietly = false;
}
int missing = 0;
var canExport = new List <SimObject>();
int objects = 0;
if (arglist.Contains("terrain"))
{
SaveTerrainHeight(arglist);
StartTerrainDownload(arglist);
}
if (arglist.Contains("parcel"))
{
SaveParcelInfoCommand(arglist);
}
bool primsAtAll = arglist.Contains("link") || arglist.Contains("task") || arglist.Contains("llsd") ||
arglist.Contains("taskobj") || arglist.Contains("all");
bool wasShouldBeMoving = shouldBeMoving;
if (primsAtAll)
{
shouldBeMoving = false;
}
if (arglist.Contains("nobuf"))
{
PSBuf.Clear();
}
PSBuf.AddRange(PS);
lock (Importing.MustExport)
{
foreach (UUID id in LockInfo.CopyOf(Importing.MustExport))
{
var o = WorldObjects.GetSimObjectFromUUID(id);
if (o != null)
{
PSBuf.Add(o);
}
}
}
foreach (var P in PSBuf)
{
if (!primsAtAll)
{
break;
}
if (string.IsNullOrEmpty(IsComplete(P.ID, false, false, arglist)))
{
continue;
}
// skip attachments and avatars
if (IsSkipped(P, arglist))
{
continue;
}
if (!P.HasPrim)
{
if (!quietly)
{
Failure("Missing Prim: " + named(P));
}
continue;
}
if (P.RegionHandle != RegionHandle)
{
continue;
}
Vector3 sp;
if (!P.TryGetSimPosition(out sp))
{
continue;
}
objects++;
string issues = P.MissingData;
if (!string.IsNullOrEmpty(issues) && !arglist.Allows(issues, P))
{
missing++;
if (!quietly)
{
Failure("Issues " + issues + " " + named(P));
}
continue;
}
bool exportPossible =
checkPerms(Client, P, showPermsOnly ? (OutputDelegate)LocalFailure : SilientFailure, false) || skipPerms;
if (exportPossible)
{
SnagUsers(P);
canExport.Add(P);
}
}
Success("Can export " + canExport.Count + " of " + objects);
if (showPermsOnly)
{
return(Success("Shown perms"));
}
foreach (var P in canExport)
{
if (!primsAtAll)
{
break;
}
if (P is SimAvatar)
{
continue;
}
// skip attachments
if (P.Parent is SimAvatar)
{
continue;
}
string issues = P.MissingData;
if (!string.IsNullOrEmpty(issues) && !arglist.Allows(issues, P))
{
continue;
}
//if (exportedPrims.Contains(P)) continue;
LocalFailures = 0;
PrimDepsAssets.Clear();
ExportPrim(Client, P, LocalFailure, arglist);
if (P.IsRoot)
{
float pSimPositionZ = P.SimPosition.Z;
if (pSimPositionZ > maxHeigth)
{
maxHeigth = pSimPositionZ + 10;
}
seenObjectsAt.AddPoint(P.SimPosition);
}
if (LocalFailures == 0)
{
if (!successfullyExportedPrims.Contains(P))
{
successfullyExportedPrims.Add(P);
}
}
}
ExportRelatedAssets();
if (showsStatus)
{
arglist.Add("link");
arglist.Add("task");
arglist.Add("llsd");
}
if (arglist.Contains("link"))
{
// lock (PrimWaitingLinkset)
{
foreach (var pa in LockInfo.CopyOf(PrimWaitingLinkset))
{
var exportPrim = pa.Value.O;
if (verbosely)
{
Failure("Awaiting Linkset " + named(exportPrim));
}
if (arglist.Contains("request"))
{
RequestLinksetInfo(Client, Path.Combine(dumpDir, exportPrim.ID.ToString()), exportPrim,
WriteLine, arglist);
}
}
}
}
if (arglist.Contains("task"))
{
lock (TaskAssetWaiting)
{
foreach (var pa in LockInfo.CopyOf(TaskAssetWaiting))
{
UUID assetID = pa.Value.SourceItem.AssetUUID;
if (!CogbotHelpers.IsNullOrZero(assetID))
{
if (CompletedAssets.Contains(assetID))
{
int count = TaskAssetWaiting.Count;
TaskAssetWaiting.Remove(pa.Key);
if (TaskAssetWaiting.Count != count - 1)
{
Failure("VERY BAD!");
}
}
}
if (verbosely)
{
Failure("Awaiting TaskAsset " + pa.Value);
}
if (arglist.Contains("request"))
{
pa.Value.Request();
}
}
}
}
ExportRelatedAssets();
foreach (var assetID in LockInfo.CopyOf(ToDownloadAssets))
{
PingAssetCache(assetID);
}
if (arglist.Contains("dl"))
{
foreach (var assetID in LockInfo.CopyOf(ToDownloadAssets))
{
AssetType assetType = assetTypeOf(assetID);
if (verbosely)
{
Failure("Awaiting DL " + assetID + " " + assetType);
}
if (arglist.Contains("request"))
{
StartAssetDownload(null, assetID, assetType);
}
}
}
if (arglist.Contains("user"))
{
RequestUsersAndGroups();
}
if (arglist.Contains("siprim"))
{
foreach (SimObject o in LockInfo.CopyOf(SIPrims))
{
if (o.Prim.ParentID == 0)
{
Client.Inventory.RequestDeRezToInventory(o.LocalID, DeRezDestination.AgentInventoryCopy,
FolderCalled("UseSIForCompleteness"), UUID.Random());
}
else
{
Failure("Child SIPrim " + o);
}
}
}
Success("Missing PrimData: " + missing);
Success("Started XFERS " + ToDownloadCalledAssets.Count + " assets");
shouldBeMoving = wasShouldBeMoving;
GiveStatus();
if (primsAtAll)
{
shouldBeMoving = wasShouldBeMoving;
}
return(Success("Done"));
}
public void SaveLLSD(BotClient Client, string pathStem, SimObject exportPrim, OutputDelegate Failure, ImportSettings settings)
{
if (exportPrim != null)
{
string exportFile = pathStem + ".llsd";
if (Incremental || showsMissingOnly) lock (fileWriterLock) if (File.Exists(exportFile)) return;
needFiles++;
if (showsMissingOnly)
{
Failure("NEED LLSD for " + named(exportPrim));
AddMoveTo(exportPrim.SimPosition);
return;
}
try
{
List<string> skipTag = new List<string>() { "Tag" };
Primitive prim = exportPrim.Prim;
Vector3 pp = prim.Position;
Quaternion pr = prim.Rotation;
//prim = prim.Clone();
OSDMap primOSD = (OSDMap) prim.GetOSD();
if (prim.ParentID != 0)
{
var parent = WorldSystem.GetLibOMVHostedPrim(prim.ParentID, settings.CurSim, false);
if (parent == null)
{
pp += new Vector3(128, 128, Client.Self.SimPosition.Z + 20);
Failure("YET FAILED: Cant GET parent of " + prim);
return;
}
else
{
pp = prim.Position * Matrix4.CreateFromQuaternion(parent.Rotation) + parent.Position;
pr = parent.Rotation * pr;
primOSD["ParentUUID"] = parent.ID;
}
}
primOSD["RegionPosition"] = pp;
primOSD["RegionRotation"] = pr;
if (exportPrim.PathFinding.MadeNonPhysical)
{
primOSD["physical"] = true;
primOSD["use_physics"] = true;
}
if (exportPrim.PathFinding.MadeNonTemp)
{
primOSD["temporary"] = true;
}
AddExportUser(primOSD["CreatorID"]);
AddExportGroup(primOSD["GroupID"]);
AddExportUser(primOSD["OwnerID"]);
AddExportUser(primOSD["LastOwnerID"]);
string output = OSDParser.SerializeLLSDXmlString(primOSD);
{
lock (fileWriterLock) File.WriteAllText(exportFile, output);
}
var ptc = Importing.APrimToCreate(prim);
ptc.Rezed = exportPrim;
if (forced && !verbosely) return;
return;
Primitive prim2 = FromFile(exportFile, ExportCommand.UseBinarySerialization) as Primitive;
string memberwiseCompare = MemberwiseCompare(prim, prim2, skipTag);
if (!string.IsNullOrEmpty(memberwiseCompare))
{
string failre = "Error in LLSD: " + memberwiseCompare;
Failure(failre);
if (!forced)
{
File.Delete(exportFile);
return;
Error(failre);
}
}
}
catch (Exception e)
{
File.Delete(exportFile);
Failure("Writing file " + exportFile + " caused " + e);
}
}
}
public void SaveTerrainHeight(ImportSettings settings)
{
bool prefixFP = false;
var CurSim = settings.CurSim;
OSDMap simInfoMap = new OSDMap();
// leave these out of serialization
simInfoMap["ObjectsPrimitives"] = true;
simInfoMap["ObjectsAvatars"] = true;
simInfoMap["Client"] = true;
simInfoMap["SharedData"] = true;
simInfoMap["Caps"] = true;
simInfoMap["DeadObjects"] = true;
simInfoMap["KilledObjects"] = true;
var exceptFor = new HashSet<object>() { typeof(IList), typeof(IDictionary), typeof(object) };
OSD.AddObjectOSD0(CurSim.Stats, simInfoMap, typeof(Simulator.SimStats), exceptFor, true, prefixFP);
//@todo OSD.AddObjectOSD0(CurSim.SharedData, simInfoMap, typeof(Simulator.SimPooledData), exceptFor, true, prefixFP);
OSD.AddObjectOSD0(CurSim, simInfoMap, typeof(Simulator), exceptFor, true, prefixFP);
string output = OSDParser.SerializeLLSDXmlString(simInfoMap);
{
lock (fileWriterLock) File.WriteAllText(terrainDir + "simInfoMap.llsd", output);
}
AddRelated(CurSim.TerrainBase0, AssetType.Texture);
AddRelated(CurSim.TerrainBase1, AssetType.Texture);
AddRelated(CurSim.TerrainBase2, AssetType.Texture);
AddRelated(CurSim.TerrainBase3, AssetType.Texture);
AddRelated(CurSim.TerrainDetail0, AssetType.Texture);
AddRelated(CurSim.TerrainDetail1, AssetType.Texture);
AddRelated(CurSim.TerrainDetail2, AssetType.Texture);
AddRelated(CurSim.TerrainDetail3, AssetType.Texture);
AddExportUser(CurSim.SimOwner);
var Terrain = CurSim.Terrain;
if (Terrain == null)
{
Failure("Terrain missing completely");
return;
}
Client.Grid.RequestMapItems(CurSim.Handle, GridItemType.LandForSale, GridLayerType.Terrain);
var number = CurSim.Terrain.Length;
var missing = 0;
foreach (TerrainPatch patch in Terrain)
{
if (patch != null && patch.Data != null && patch.Data.Length > 0)
{
continue;
}
missing++;
}
var terrainReady = (missing == 0);
if (!terrainReady)
{
Failure("Terrain missing chunks/total=" + missing + "/" + number);
}
if (terrainReady || forced)
{
SaveToDisk(terrainDir + "terrain.patches", Terrain);
SaveTerrainRaw32(dumpDir + "../terrains/heightmap.r32");
if (!terrainReady)
{
Failure("SaveTerrainHeight Saved but not ready");
}
else
{
Success("SaveTerrainHeight Success");
}
return;
}
Failure("Unable to SaveTerrainHeight (use --force)");
}
static public void SaveLinkset(Linkset linkset, string filename, bool oldFormat, ImportSettings options)
{
try
{
using (StreamWriter stream = new StreamWriter(filename))
{
XmlTextWriter writer = new XmlTextWriter(stream);
SOGToXml2(writer, linkset, oldFormat, options);
writer.Flush();
}
}
catch (Exception ex)
{
Logger.Log("Failed saving linkset: " + ex.Message, Helpers.LogLevel.Error);
}
}
private void UploadAllAssets(ImportSettings arglist)
{
bool sameIds = arglist.Contains("sameid");
int uploaded = 0;
int reuploaded = 0;
int seenAsset = 0;
HashSet <ItemToCreate> ItemsToCreate = LocalScene.Assets;
bool alwayReupload = arglist.Contains("reup");
Success("Uploading assets... sameIds=" + sameIds);
var au = GetAssetUploadsFolder();
if (CogbotHelpers.IsNullOrZero(au))
{
Success("Cant get AssetUploads folder");
return;
}
foreach (var file in Directory.GetFiles(ExportCommand.assetDumpDir, "*.*"))
{
if (file.EndsWith(".object") || file.EndsWith(".simasset") || file.EndsWith(".rzi"))
{
continue;
}
string sid = file;
AssetType assetType = AssetType.Unknown;
foreach (var ate in ArchiveConstants.ASSET_TYPE_TO_EXTENSION)
{
string ateValue = ate.Value;
if (file.EndsWith(ateValue))
{
assetType = ate.Key;
sid = Path.GetFileName(file.Substring(0, file.Length - ateValue.Length));
break;
}
}
if (assetType == AssetType.Unknown)
{
if (file.EndsWith(".jp2"))
{
assetType = AssetType.Texture;
sid = Path.GetFileName(file.Substring(0, file.Length - ".jp2".Length));
}
if (file.EndsWith(".ogg"))
{
assetType = AssetType.Sound;
sid = Path.GetFileName(file.Substring(0, file.Length - ".ogg".Length));
}
}
if (assetType == AssetType.Unknown)
{
Failure("Cant guess assetyype for " + file);
continue;
}
seenAsset++;
UUID oldID = UUID.Parse(sid);
ItemToCreate itc = FindItemToCreate(oldID, assetType, sameIds);
itc.LLSDFilename = file;
ItemsToCreate.Add(itc);
}
foreach (ItemToCreate itc in ItemsToCreate)
{
if (itc.PassNumber == 1)
{
EnsureUploaded(itc, alwayReupload, ref uploaded, ref reuploaded);
}
}
foreach (ItemToCreate itc in ItemsToCreate)
{
if (itc.PassNumber == 2)
{
itc.ReplaceAll();
EnsureUploaded(itc, alwayReupload, ref uploaded, ref reuploaded);
}
}
Success("Uploaded assets=" + uploaded + " seenAssets=" + seenAsset + " reuploaded=" + reuploaded);
}
