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); }
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); }
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()); }
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; }
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)"); }
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); }