public void SpawnChunksLinear()
{
SpawnChunkFeild();
Loom.QueueAsyncTask(WorldThreadName, () =>
{
TerrainModule module = new TerrainModule(VoxelSettings.seed);
for (int x = 0; x < VoxelSettings.maxChunksX; x++)
{
for (int z = 0; z < VoxelSettings.maxChunksZ; z++)
{
for (int y = 0; y < VoxelSettings.maxChunksY_M; y++)
{
Vector3Int location3D = new Vector3Int(x, y, z);
GenerateChunk(location3D, module);
}
}
}
SafeDebug.Log("Finished rendering.");
Loom.QueueOnMainThread(() =>
{
_generating = false;
OnRenderComplete();
});
});
}
public void GenerateChunks(Vector3Int[] chunkLocations, Action onComplete)
{
Loom.QueueAsyncTask(WorldThreadName, () =>
{
//SafeDebug.Log("Generating " + chunkLocations.Length + " chunks.");
TerrainModule module = new TerrainModule(VoxelSettings.seed);
foreach (Vector3Int location3D in chunkLocations)
{
GenerateChunk(location3D, module);
chunksGenerated++;
}
SetVoxelSize();
setMeshSize();
Loom.QueueOnMainThread(() =>
{
_generating = false;
chunksInQueue = 0;
chunksGenerated = 0;
GameManager.Status = "";
if (onComplete != null)
{
onComplete();
}
});
});
}
public static ISampler CreateSampler(Samplers type)
{
ISampler result = null;
switch (type)
{
case Samplers.Flat:
result = new FlatSampler(1, 1);
break;
case Samplers.Sphere:
result = new SphereSampler(new Vector3(SmoothVoxelSettings.MeterSizeX / 2f, SmoothVoxelSettings.MeterSizeY / 2f, SmoothVoxelSettings.MeterSizeZ / 2f),
SmoothVoxelSettings.MeterSizeX / 3f);
break;
case Samplers.Terrain:
TerrainModule module = new TerrainModule(SmoothVoxelSettings.seed);
result = new TerrainSampler(module,
SmoothVoxelSettings.seed,
SmoothVoxelSettings.enableCaves,
SmoothVoxelSettings.amplitude,
SmoothVoxelSettings.caveDensity,
SmoothVoxelSettings.grassOffset);
break;
}
return(result);
}
public void TestTerrainFill()
{
TestHelpers.InMethod();
// TestHelpers.EnableLogging();
//UUID userId = TestHelpers.ParseTail(0x1);
TerrainModule tm = new TerrainModule();
Scene scene = new SceneHelpers().SetupScene();
SceneHelpers.SetupSceneModules(scene, tm);
// Fillheight of 30
{
float fillHeight = 30;
tm.InterfaceFillTerrain(new object[] { fillHeight });
float height = scene.Heightmap[128, 128];
Assert.AreEqual(fillHeight, height);
}
// Max fillheight of 30
// According to http://wiki.secondlife.com/wiki/Tips_for_Creating_Heightfields_and_Details_on_Terrain_RAW_Files#Notes_for_Creating_Height_Field_Maps_for_Second_Life
{
float fillHeight = 508;
tm.InterfaceFillTerrain(new object[] { fillHeight });
float height = scene.Heightmap[128, 128];
Assert.AreEqual(fillHeight, height);
}
}
public void Load(TextAsset ta, Planet livePreview)
{
if (ta == null)
{
return;
}
savepath = AssetDatabase.GetAssetPath(ta);
windows.Clear();
settings = TerrainModule.LoadTextAsset(ta, true, 0, 1f);
if (settings != null)
{
foreach (Node n in settings.nodes)
{
NodeWindow nw = new NodeWindow(n);
if (n is OutputNode)
{
nw.livePreview = livePreview;
}
windows.Add(nw);
}
}
}
override public ModuleBase GetModule()
{
if (path == null)
{
return(null);
}
if (path == "")
{
return(null);
}
TerrainModule tm = TerrainModule.Load(path, false, 0, frequencyScale);
if (tm != null)
{
this.module = tm.module;
}
else
{
Debug.LogError("MacroNode: Terrain module could not be loaded from " + path);
this.module = new ModuleBase();
}
return(this.module);
}
/// <summary>
/// Test merging an OpenSim Region Archive into an existing scene
/// </summary>
//[Test]
public void TestMergeOar()
{
TestHelpers.InMethod();
//XmlConfigurator.Configure();
MemoryStream archiveWriteStream = new MemoryStream();
// string part2Name = "objectMerge";
// PrimitiveBaseShape part2Shape = PrimitiveBaseShape.CreateCylinder();
// Vector3 part2GroupPosition = new Vector3(90, 80, 70);
// Quaternion part2RotationOffset = new Quaternion(60, 70, 80, 90);
// Vector3 part2OffsetPosition = new Vector3(20, 25, 30);
SceneObjectPart part2 = CreateSceneObjectPart2();
// Create an oar file that we can use for the merge
{
ArchiverModule archiverModule = new ArchiverModule();
SerialiserModule serialiserModule = new SerialiserModule();
TerrainModule terrainModule = new TerrainModule();
Scene scene = m_sceneHelpers.SetupScene();
SceneHelpers.SetupSceneModules(scene, archiverModule, serialiserModule, terrainModule);
m_scene.AddNewSceneObject(new SceneObjectGroup(part2), false);
// Write out this scene
scene.EventManager.OnOarFileSaved += SaveCompleted;
lock (this)
{
m_archiverModule.ArchiveRegion(archiveWriteStream);
Monitor.Wait(this, 60000);
}
}
{
SceneObjectPart part1 = CreateSceneObjectPart1();
m_scene.AddNewSceneObject(new SceneObjectGroup(part1), false);
// Merge in the archive we created earlier
byte[] archive = archiveWriteStream.ToArray();
MemoryStream archiveReadStream = new MemoryStream(archive);
Dictionary <string, object> archiveOptions = new Dictionary <string, object>();
archiveOptions.Add("merge", null);
m_archiverModule.DearchiveRegion(archiveReadStream, Guid.Empty, archiveOptions);
SceneObjectPart object1Existing = m_scene.GetSceneObjectPart(part1.Name);
Assert.That(object1Existing, Is.Not.Null, "object1 was not present after merge");
Assert.That(object1Existing.Name, Is.EqualTo(part1.Name), "object1 names not identical after merge");
Assert.That(object1Existing.GroupPosition, Is.EqualTo(part1.GroupPosition), "object1 group position not equal after merge");
SceneObjectPart object2PartMerged = m_scene.GetSceneObjectPart(part2.Name);
Assert.That(object2PartMerged, Is.Not.Null, "object2 was not present after merge");
Assert.That(object2PartMerged.Name, Is.EqualTo(part2.Name), "object2 names not identical after merge");
Assert.That(object2PartMerged.GroupPosition, Is.EqualTo(part2.GroupPosition), "object2 group position not equal after merge");
}
}
public void SetUp()
{
m_archiverModule = new ArchiverModule();
SerialiserModule serialiserModule = new SerialiserModule();
TerrainModule terrainModule = new TerrainModule();
m_scene = SceneSetupHelpers.SetupScene();
SceneSetupHelpers.SetupSceneModules(m_scene, m_archiverModule, serialiserModule, terrainModule);
}
/// <summary>
/// Loads settings from the file
/// </summary>
public void LoadModule()
{
terrain = TerrainModule.LoadTextAsset(terrainAsset, randomizeSeeds, seed, frequencyScale);
if (terrain == null)
{
Debug.Log("TerrainModule file not found.");
return;
}
}
private void OutputGUI()
{
useLivePreview = EditorGUILayout.Foldout(useLivePreview, "Live preview");
if (useLivePreview)
{
livePreview = (Planet)EditorGUILayout.ObjectField("Live preview:", livePreview, typeof(Planet), true);
if (livePreview != null)
{
if (GUILayout.Button("Update Mesh"))
{
TerrainModule tm = new TerrainModule();
tm.module = outputNode.GetModule();
livePreview.Terrain = tm;
livePreview.Generate(null, false);
}
}
EditorGUILayout.HelpBox("Drag a planet from scene to preview mesh while editing the module", MessageType.Info);
node.rect.height += controlHeight * 2.5f;
}
node.rect.height += controlHeight * 1.5f;
// export options
showExport = EditorGUILayout.Foldout(showExport, "Export textures");
if (showExport)
{
// size
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("Texture size:");
exportSize = EditorGUILayout.IntField(exportSize);
EditorGUILayout.EndHorizontal();
if (GUILayout.Button("Save as PNG"))
{
string savepath = EditorUtility.SaveFilePanel("Export texture", Application.dataPath, "planet", "");
if (savepath.Length != 0)
{
float progress = 0;
float total = 2;
Texture2D temp;
EditorUtility.DisplayProgressBar("Planet generator", "Generating texture...", progress / total);
temp = Generate(exportSize);
progress++;
EditorUtility.DisplayProgressBar("Planet generator", "Saving texture...", progress / total);
File.WriteAllBytes(savepath + "_heightmap.png", temp.EncodeToPNG());
EditorUtility.ClearProgressBar();
AssetDatabase.Refresh();
}
}
node.rect.height += controlHeight * 2f;
}
}
public static ISampler CreateTerrainSampler()
{
TerrainModule module = new TerrainModule(SmoothVoxelSettings.seed);
ISampler result = new TerrainSampler(module,
SmoothVoxelSettings.seed,
SmoothVoxelSettings.enableCaves,
1.5f,
SmoothVoxelSettings.caveDensity,
SmoothVoxelSettings.grassOffset);
return(result);
}
public override void SetUp()
{
base.SetUp();
m_archiverModule = new ArchiverModule();
m_serialiserModule = new SerialiserModule();
TerrainModule terrainModule = new TerrainModule();
m_sceneHelpers = new SceneHelpers();
m_scene = m_sceneHelpers.SetupScene();
SceneHelpers.SetupSceneModules(m_scene, m_archiverModule, m_serialiserModule, terrainModule);
}
public override void SetUp()
{
base.SetUp();
// FIXME: Do something about this - relying on statics in unit tests causes trouble sooner or later
new SceneManager();
m_archiverModule = new ArchiverModule();
m_serialiserModule = new SerialiserModule();
TerrainModule terrainModule = new TerrainModule();
m_sceneHelpers = new SceneHelpers();
m_scene = m_sceneHelpers.SetupScene();
SceneHelpers.SetupSceneModules(m_scene, m_archiverModule, m_serialiserModule, terrainModule);
}
public void GenerateSpherical(Vector3Int center)
{
_resetEvent = new System.Threading.ManualResetEvent(false);
LODtarget = center;
//Loom.QueueAsyncTask("chunkUpdate", ChunkUpdate);
Loom.QueueAsyncTask(WorldThreadName, () => {
TerrainModule module = new TerrainModule(SmoothVoxelSettings.seed);
for (int i = 0; i < SmoothVoxelSettings.radius; i++)
{
Vector3Int[][] chunkBand = GetChunkLocationsAroundPoint(threads, i, center);
for (int threadIndex = 0; threadIndex < chunkBand.Length; threadIndex++)
{
Vector3Int[] positions = chunkBand[threadIndex];
GenerateChunks("Generator" + threadIndex, threadIndex, module, positions);
}
}
});
}
/// <summary>
/// Loads from text asset.
/// </summary>
public static TerrainModule LoadTextAsset(TextAsset ta, bool randomize, float seed, float frequencyScale)
{
TerrainModule ps = null;
try {
Stream s = new MemoryStream(ta.bytes);
BinaryFormatter formatter = new BinaryFormatter();
ps = (TerrainModule)formatter.Deserialize(s);
s.Close();
// retrieve node list
ps.randomizeSeeds = randomize;
ps.seed = seed;
ps.frequencyScale = frequencyScale;
ps.ReloadModules();
} catch (Exception e) {
Debug.Log("Terrain Module file could not be loaded. " + e.Message);
}
return(ps);
}
public void Load(string loadpath)
{
if (loadpath == "")
{
return;
}
savepath = loadpath;
if (loadpath.Length != 0)
{
windows.Clear();
settings = TerrainModule.Load(loadpath, true, 0, 1f);
if (settings != null)
{
foreach (Node n in settings.nodes)
{
windows.Add(new NodeWindow(n));
}
}
}
}
private void New()
{
// create starting nodes
settings = new TerrainModule();
savepath = "";
GeneratorNode g1 = new GeneratorNode(100, 100);
g1.seed = Random.Range(-100000, 100000);
OutputNode output = new OutputNode(700, 100);
output.Connect(g1, 0);
settings.nodes.Add(g1);
settings.nodes.Add(output);
// create windows to represent nodes
windows.Clear();
windows.Add(new NodeWindow(g1));
windows.Add(new NodeWindow(output));
}
public ISampler GetSampler()
{
if (Gpu_Acceloration)
{
ISampler result = new GPU_TerrainSampler(SmoothVoxelSettings.seed,
SmoothVoxelSettings.enableCaves,
1.5f,
SmoothVoxelSettings.caveDensity,
SmoothVoxelSettings.grassOffset);
return(result);
}
else
{
TerrainModule module = new TerrainModule(SmoothVoxelSettings.seed);
ISampler result = new TerrainSampler(module,
SmoothVoxelSettings.seed,
SmoothVoxelSettings.enableCaves,
1.5f,
SmoothVoxelSettings.caveDensity,
SmoothVoxelSettings.grassOffset);
return(result);
}
}
public void TestSaveOarV0_2()
{
TestHelper.InMethod();
//log4net.Config.XmlConfigurator.Configure();
ArchiverModule archiverModule = new ArchiverModule();
SerialiserModule serialiserModule = new SerialiserModule();
TerrainModule terrainModule = new TerrainModule();
Scene scene = SceneSetupHelpers.SetupScene(false);
SceneSetupHelpers.SetupSceneModules(scene, archiverModule, serialiserModule, terrainModule);
SceneObjectPart part1;
// Create and add prim 1
{
string partName = "My Little Pony";
UUID ownerId = UUID.Parse("00000000-0000-0000-0000-000000000015");
PrimitiveBaseShape shape = PrimitiveBaseShape.CreateSphere();
Vector3 groupPosition = new Vector3(10, 20, 30);
Quaternion rotationOffset = new Quaternion(20, 30, 40, 50);
Vector3 offsetPosition = new Vector3(5, 10, 15);
part1
= new SceneObjectPart(
ownerId, shape, groupPosition, rotationOffset, offsetPosition);
part1.Name = partName;
scene.AddNewSceneObject(new SceneObjectGroup(part1), false);
}
SceneObjectPart part2;
// Create and add prim 2
{
string partName = "Action Man";
UUID ownerId = UUID.Parse("00000000-0000-0000-0000-000000000016");
PrimitiveBaseShape shape = PrimitiveBaseShape.CreateCylinder();
Vector3 groupPosition = new Vector3(90, 80, 70);
Quaternion rotationOffset = new Quaternion(60, 70, 80, 90);
Vector3 offsetPosition = new Vector3(20, 25, 30);
part2
= new SceneObjectPart(
ownerId, shape, groupPosition, rotationOffset, offsetPosition);
part2.Name = partName;
scene.AddNewSceneObject(new SceneObjectGroup(part2), false);
}
MemoryStream archiveWriteStream = new MemoryStream();
scene.EventManager.OnOarFileSaved += SaveCompleted;
Guid requestId = new Guid("00000000-0000-0000-0000-808080808080");
lock (this)
{
archiverModule.ArchiveRegion(archiveWriteStream, requestId);
//AssetServerBase assetServer = (AssetServerBase)scene.CommsManager.AssetCache.AssetServer;
//while (assetServer.HasWaitingRequests())
// assetServer.ProcessNextRequest();
Monitor.Wait(this, 60000);
}
Assert.That(m_lastRequestId, Is.EqualTo(requestId));
byte[] archive = archiveWriteStream.ToArray();
MemoryStream archiveReadStream = new MemoryStream(archive);
TarArchiveReader tar = new TarArchiveReader(archiveReadStream);
bool gotControlFile = false;
bool gotObject1File = false;
bool gotObject2File = false;
string expectedObject1FileName = string.Format(
"{0}_{1:000}-{2:000}-{3:000}__{4}.xml",
part1.Name,
Math.Round(part1.GroupPosition.X), Math.Round(part1.GroupPosition.Y), Math.Round(part1.GroupPosition.Z),
part1.UUID);
string expectedObject2FileName = string.Format(
"{0}_{1:000}-{2:000}-{3:000}__{4}.xml",
part2.Name,
Math.Round(part2.GroupPosition.X), Math.Round(part2.GroupPosition.Y), Math.Round(part2.GroupPosition.Z),
part2.UUID);
string filePath;
TarArchiveReader.TarEntryType tarEntryType;
while (tar.ReadEntry(out filePath, out tarEntryType) != null)
{
if (ArchiveConstants.CONTROL_FILE_PATH == filePath)
{
gotControlFile = true;
}
else if (filePath.StartsWith(ArchiveConstants.OBJECTS_PATH))
{
string fileName = filePath.Remove(0, ArchiveConstants.OBJECTS_PATH.Length);
if (fileName.StartsWith(part1.Name))
{
Assert.That(fileName, Is.EqualTo(expectedObject1FileName));
gotObject1File = true;
}
else if (fileName.StartsWith(part2.Name))
{
Assert.That(fileName, Is.EqualTo(expectedObject2FileName));
gotObject2File = true;
}
}
}
Assert.That(gotControlFile, Is.True, "No control file in archive");
Assert.That(gotObject1File, Is.True, "No object1 file in archive");
Assert.That(gotObject2File, Is.True, "No object2 file in archive");
// TODO: Test presence of more files and contents of files.
}
/// <summary>
/// Test merging a V0.2 OpenSim Region Archive into an existing scene
/// </summary>
//[Test]
public void TestMergeOarV0_2()
{
TestHelper.InMethod();
//XmlConfigurator.Configure();
MemoryStream archiveWriteStream = new MemoryStream();
string part2Name = "objectMerge";
PrimitiveBaseShape part2Shape = PrimitiveBaseShape.CreateCylinder();
Vector3 part2GroupPosition = new Vector3(90, 80, 70);
Quaternion part2RotationOffset = new Quaternion(60, 70, 80, 90);
Vector3 part2OffsetPosition = new Vector3(20, 25, 30);
// Create an oar file that we can use for the merge
{
ArchiverModule archiverModule = new ArchiverModule();
SerialiserModule serialiserModule = new SerialiserModule();
TerrainModule terrainModule = new TerrainModule();
Scene scene = SceneSetupHelpers.SetupScene();
SceneSetupHelpers.SetupSceneModules(scene, archiverModule, serialiserModule, terrainModule);
SceneObjectPart part2
= new SceneObjectPart(
UUID.Zero, part2Shape, part2GroupPosition, part2RotationOffset, part2OffsetPosition);
part2.Name = part2Name;
SceneObjectGroup object2 = new SceneObjectGroup(part2);
scene.AddNewSceneObject(object2, false);
// Write out this scene
scene.EventManager.OnOarFileSaved += SaveCompleted;
lock (this)
{
archiverModule.ArchiveRegion(archiveWriteStream);
Monitor.Wait(this, 60000);
}
}
{
ArchiverModule archiverModule = new ArchiverModule();
SerialiserModule serialiserModule = new SerialiserModule();
TerrainModule terrainModule = new TerrainModule();
Scene scene = SceneSetupHelpers.SetupScene();
SceneSetupHelpers.SetupSceneModules(scene, archiverModule, serialiserModule, terrainModule);
string part1Name = "objectExisting";
PrimitiveBaseShape part1Shape = PrimitiveBaseShape.CreateCylinder();
Vector3 part1GroupPosition = new Vector3(80, 70, 60);
Quaternion part1RotationOffset = new Quaternion(50, 60, 70, 80);
Vector3 part1OffsetPosition = new Vector3(15, 20, 25);
SceneObjectPart part1
= new SceneObjectPart(
UUID.Zero, part1Shape, part1GroupPosition, part1RotationOffset, part1OffsetPosition);
part1.Name = part1Name;
SceneObjectGroup object1 = new SceneObjectGroup(part1);
scene.AddNewSceneObject(object1, false);
// Merge in the archive we created earlier
byte[] archive = archiveWriteStream.ToArray();
MemoryStream archiveReadStream = new MemoryStream(archive);
archiverModule.DearchiveRegion(archiveReadStream, true, Guid.Empty);
SceneObjectPart object1Existing = scene.GetSceneObjectPart(part1Name);
Assert.That(object1Existing, Is.Not.Null, "object1 was not present after merge");
Assert.That(object1Existing.Name, Is.EqualTo(part1Name), "object1 names not identical after merge");
Assert.That(object1Existing.GroupPosition, Is.EqualTo(part1GroupPosition), "object1 group position not equal after merge");
SceneObjectPart object2PartMerged = scene.GetSceneObjectPart(part2Name);
Assert.That(object2PartMerged, Is.Not.Null, "object2 was not present after merge");
Assert.That(object2PartMerged.Name, Is.EqualTo(part2Name), "object2 names not identical after merge");
Assert.That(object2PartMerged.GroupPosition, Is.EqualTo(part2GroupPosition), "object2 group position not equal after merge");
}
}
// Create an OpenSimulator Scene and add enough auxillery services and objects
// to it so it will allow the loading of assets.
public Scene CreateScene(IAssetService memAssetService, string regionName)
{
RegionInfo regionInfo = new RegionInfo(0, 0, null, regionName);
regionInfo.RegionName = regionName;
regionInfo.RegionSizeX = regionInfo.RegionSizeY = Constants.RegionSize;
regionInfo.RegionID = OMV.UUID.Random();
var estateSettings = new EstateSettings();
estateSettings.EstateOwner = OMV.UUID.Random();
regionInfo.EstateSettings = estateSettings;
Scene scene = new Scene(regionInfo);
// Add an in-memory asset service for all the loaded assets to go into
scene.RegisterModuleInterface <IAssetService>(memAssetService);
ISimulationDataService simulationDataService = new NullDataService();
scene.RegisterModuleInterface <ISimulationDataService>(simulationDataService);
IRegionSerialiserModule serializerModule = new SerialiserModule();
scene.RegisterModuleInterface <IRegionSerialiserModule>(serializerModule);
IUserAccountService userAccountService = new NullUserAccountService();
scene.RegisterModuleInterface <IUserAccountService>(userAccountService);
PhysicsScene physScene = CreateSimplePhysicsEngine();
((INonSharedRegionModule)physScene).AddRegion(scene);
((INonSharedRegionModule)physScene).RegionLoaded(scene);
scene.PhysicsScene = physScene;
scene.LandChannel = new TestLandChannel(scene); // simple land with no parcels
Nini.Config.IConfigSource config = new Nini.Config.IniConfigSource();
config.AddConfig("Terrain");
config.Configs["Terrain"].Set("InitialTerrain", "flat");
var terrainModule = new TerrainModule();
try {
terrainModule.Initialise(config);
terrainModule.AddRegion(scene);
}
catch (ReflectionTypeLoadException e) {
// The terrain module loads terrain brushes and they might not all have been included
StringBuilder sb = new StringBuilder();
foreach (Exception exSub in e.LoaderExceptions)
{
sb.AppendLine(exSub.Message);
FileNotFoundException exFileNotFound = exSub as FileNotFoundException;
if (exFileNotFound != null)
{
if (!string.IsNullOrEmpty(exFileNotFound.FusionLog))
{
sb.AppendLine("Fusion Log:");
sb.AppendLine(exFileNotFound.FusionLog);
}
}
sb.AppendLine();
}
string errorMessage = sb.ToString();
ConvOAR.Globals.log.Log("BConverterOS.CreateScene: exception adding region:");
ConvOAR.Globals.log.Log(errorMessage);
}
catch (Exception e) {
ConvOAR.Globals.log.Log("BConverterOS.CreateScene: exception adding region: {0}", e);
}
SceneManager.Instance.Add(scene);
return(scene);
}
public void TestLoadPublishedOar()
{
TestHelpers.InMethod();
// log4net.Config.XmlConfigurator.Configure();
SceneObjectPart part1 = CreateSceneObjectPart1();
SceneObjectGroup sog1 = new SceneObjectGroup(part1);
m_scene.AddNewSceneObject(sog1, false);
SceneObjectPart part2 = CreateSceneObjectPart2();
AssetNotecard nc = new AssetNotecard();
nc.BodyText = "Hello World!";
nc.Encode();
UUID ncAssetUuid = new UUID("00000000-0000-0000-1000-000000000000");
UUID ncItemUuid = new UUID("00000000-0000-0000-1100-000000000000");
AssetBase ncAsset
= AssetHelpers.CreateAsset(ncAssetUuid, AssetType.Notecard, nc.AssetData, UUID.Zero);
m_scene.AssetService.Store(ncAsset);
SceneObjectGroup sog2 = new SceneObjectGroup(part2);
TaskInventoryItem ncItem
= new TaskInventoryItem {
Name = "ncItem", AssetID = ncAssetUuid, ItemID = ncItemUuid
};
part2.Inventory.AddInventoryItem(ncItem, true);
m_scene.AddNewSceneObject(sog2, false);
MemoryStream archiveWriteStream = new MemoryStream();
m_scene.EventManager.OnOarFileSaved += SaveCompleted;
Guid requestId = new Guid("00000000-0000-0000-0000-808080808080");
lock (this)
{
m_archiverModule.ArchiveRegion(
archiveWriteStream, requestId, new Dictionary <string, Object>()
{
{ "wipe-owners", Boolean.TrueString }
});
Monitor.Wait(this, 60000);
}
Assert.That(m_lastRequestId, Is.EqualTo(requestId));
byte[] archive = archiveWriteStream.ToArray();
MemoryStream archiveReadStream = new MemoryStream(archive);
{
UUID estateOwner = TestHelpers.ParseTail(0x4747);
UUID objectOwner = TestHelpers.ParseTail(0x15);
// Reload to new scene
ArchiverModule archiverModule = new ArchiverModule();
SerialiserModule serialiserModule = new SerialiserModule();
TerrainModule terrainModule = new TerrainModule();
SceneHelpers m_sceneHelpers2 = new SceneHelpers();
TestScene scene2 = m_sceneHelpers2.SetupScene();
SceneHelpers.SetupSceneModules(scene2, archiverModule, serialiserModule, terrainModule);
// Make sure there's a valid owner for the owner we saved (this should have been wiped if the code is
// behaving correctly
UserAccountHelpers.CreateUserWithInventory(scene2, objectOwner);
scene2.RegionInfo.EstateSettings.EstateOwner = estateOwner;
lock (this)
{
scene2.EventManager.OnOarFileLoaded += LoadCompleted;
archiverModule.DearchiveRegion(archiveReadStream);
}
Assert.That(m_lastErrorMessage, Is.Null);
SceneObjectGroup loadedSog = scene2.GetSceneObjectGroup(part1.Name);
Assert.That(loadedSog.OwnerID, Is.EqualTo(estateOwner));
Assert.That(loadedSog.LastOwnerID, Is.EqualTo(estateOwner));
}
}
