public virtual void LoadTerrain(bool RevertMap, int RegionSizeX, int RegionSizeY)
{
ITerrainModule terrainModule = m_scene.RequestModuleInterface <ITerrainModule>();
if (RevertMap)
{
terrainModule.TerrainRevertMap = ReadFromData(_regionData.RevertTerrain, m_scene);
//Make sure the size is right!
if (terrainModule.TerrainRevertMap != null &&
terrainModule.TerrainRevertMap.Height != m_scene.RegionInfo.RegionSizeX)
{
terrainModule.TerrainRevertMap = null;
}
}
else
{
terrainModule.TerrainMap = ReadFromData(_regionData.Terrain, m_scene);
//Make sure the size is right!
if (terrainModule.TerrainMap != null &&
terrainModule.TerrainMap.Height != m_scene.RegionInfo.RegionSizeX)
{
terrainModule.TerrainMap = null;
}
}
}
public void ResetRegion(IScene scene)
{
if (scene == null)
{
MainConsole.Instance.Warn("You must use this command on a region. Use 'change region' to change to the region you would like to change");
return;
}
IBackupModule backup = scene.RequestModuleInterface <IBackupModule> ();
if (backup != null)
{
backup.DeleteAllSceneObjects();//Remove all the objects from the region
}
ITerrainModule module = scene.RequestModuleInterface <ITerrainModule> ();
if (module != null)
{
module.ResetTerrain();//Then remove the terrain
}
//Then reset the textures
scene.RegionInfo.RegionSettings.TerrainTexture1 = RegionSettings.DEFAULT_TERRAIN_TEXTURE_1;
scene.RegionInfo.RegionSettings.TerrainTexture2 = RegionSettings.DEFAULT_TERRAIN_TEXTURE_2;
scene.RegionInfo.RegionSettings.TerrainTexture3 = RegionSettings.DEFAULT_TERRAIN_TEXTURE_3;
scene.RegionInfo.RegionSettings.TerrainTexture4 = RegionSettings.DEFAULT_TERRAIN_TEXTURE_4;
scene.RegionInfo.RegionSettings.Save();
MainConsole.Instance.Warn("Region " + scene.RegionInfo.RegionName + " was reset");
}
/// <summary>
/// Send the region heightmap to the client
/// </summary>
/// <param name="RemoteClient">Client to send to</param>
public virtual void SendLayerData(IClientAPI RemoteClient)
{
ITerrainModule terrModule = RequestModuleInterface <ITerrainModule>();
if (terrModule != null)
{
terrModule.PushTerrain(RemoteClient);
}
}
/// <summary>
/// Send the region heightmap to the client
/// </summary>
/// <param name="RemoteClient">Client to send to</param>
public virtual void SendLayerData(IClientAPI RemoteClient)
{
// RemoteClient.SendLayerData(Heightmap.GetFloatsSerialised());
ITerrainModule terrModule = RequestModuleInterface <ITerrainModule>();
if (terrModule != null)
{
terrModule.PushTerrain(RemoteClient);
}
}
/// <summary>
/// Load terrain data
/// </summary>
/// <param name="terrainPath"></param>
/// <param name="data"></param>
/// <returns>
/// true if terrain was resolved successfully, false otherwise.
/// </returns>
private void LoadTerrain(string terrainPath, byte[] data)
{
ITerrainModule terrainModule = m_scene.RequestModuleInterface <ITerrainModule>();
MemoryStream ms = new MemoryStream(data);
terrainModule.LoadFromStream(terrainPath, ms, m_offsetX, m_offsetY);
ms.Close();
MainConsole.Instance.DebugFormat("[ARCHIVER]: Restored terrain {0}", terrainPath);
}
/// <summary>
/// Load terrain data
/// </summary>
/// <param name="scene"></param>
/// <param name="terrainPath"></param>
/// <param name="data"></param>
/// <returns>
/// true if terrain was resolved successfully, false otherwise.
/// </returns>
private bool LoadTerrain(Scene scene, string terrainPath, byte[] data)
{
ITerrainModule terrainModule = scene.RequestModuleInterface<ITerrainModule>();
MemoryStream ms = new MemoryStream(data);
terrainModule.LoadFromStream(terrainPath, ms);
ms.Close();
m_log.DebugFormat("[ARCHIVER]: Restored terrain {0}", terrainPath);
return true;
}
public void llModifyLand(int action, int brush)
{
if (!ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL", m_itemID))
{
return;
}
ITerrainModule tm = World.RequestModuleInterface <ITerrainModule>();
if (tm != null)
{
tm.ModifyTerrain(m_host.OwnerID, m_host.AbsolutePosition, (byte)brush, (byte)action, m_host.OwnerID);
}
}
public TerrainSyncInfo(Scene scene, string actorID)
{
Scene = scene;
LastUpdateValue = Scene.Heightmap.SaveToXmlString();
ActorID = actorID;
TerrainModule = scene.RequestModuleInterface <ITerrainModule>();
if (TerrainModule == null)
{
throw (new NullReferenceException("Could not get a reference to terrain module for region \"" + Scene.RegionInfo.RegionName + "\""));
}
// Initialize time stamp to 0. Any changes anywhere will cause an update after initial load.
LastUpdateTimeStamp = 0;
}
public ArchiveWriteRequestExecution(
List<SceneObjectGroup> sceneObjects,
ITerrainModule terrainModule,
IRegionSerialiserModule serialiser,
Scene scene,
TarArchiveWriter archiveWriter,
Guid requestId)
{
m_sceneObjects = sceneObjects;
m_terrainModule = terrainModule;
m_serialiser = serialiser;
m_scene = scene;
m_archiveWriter = archiveWriter;
m_requestId = requestId;
}
public ArchiveWriteRequestExecution(
List <ISceneEntity> sceneObjects,
ITerrainModule terrainModule,
IRegionSerialiserModule serialiser,
IScene scene,
TarArchiveWriter archiveWriter,
Guid requestId)
{
m_sceneObjects = sceneObjects;
m_terrainModule = terrainModule;
m_serialiser = serialiser;
m_scene = scene;
m_archiveWriter = archiveWriter;
m_requestId = requestId;
}
public ArchiveWriteRequestExecution(
List <SceneObjectGroup> sceneObjects,
ITerrainModule terrainModule,
IRegionSerialiserModule serialiser,
Scene scene,
TarArchiveWriter archiveWriter,
Guid requestId,
Dictionary <string, object> options)
{
m_sceneObjects = sceneObjects;
m_terrainModule = terrainModule;
m_serialiser = serialiser;
m_scene = scene;
m_archiveWriter = archiveWriter;
m_requestId = requestId;
m_options = options;
}
void LoadTerrain(int terrain)
{
//Load one of the numbered terrains from file
ITerrainModule terrainmod = m_scene.RequestModuleInterface <ITerrainModule>();
try
{
terrainmod.LoadFromFile(String.Format("terrain/Terrain{0}.png", terrain));
Alert("Loading terrain. Please wait...");
//Ugly hack to solve problem of clients not consistently receiving terrain updates.
//Pause and send it a second time.
Thread.Sleep(3000);
terrainmod.LoadFromFile(String.Format("terrain/Terrain{0}.png", terrain));
Alert("Loaded terrain...");
}
catch
{
Alert("Error - Requested file not found!");
}
}
public void ResetScene()
{
if (m_currentScene == null)
{
m_log.Warn("You must use this command on a region. Use 'change region' to change to the region you would like to change");
return;
}
IBackupModule backup = m_currentScene.RequestModuleInterface <IBackupModule>();
if (backup != null)
{
backup.DeleteAllSceneObjects();
}
ITerrainModule module = m_currentScene.RequestModuleInterface <ITerrainModule>();
if (module != null)
{
module.ResetTerrain();
}
}
public virtual short[] LoadWater(IScene scene, bool RevertMap, int RegionSizeX, int RegionSizeY)
{
if (!m_loaded)
{
m_loaded = true;
ReadConfig(scene, scene.Config.Configs["FileBasedSimulationData"]);
ReadBackup(scene);
}
ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule>();
if (RevertMap)
{
if (m_revertWater == null)
{
return(null);
}
terrainModule.TerrainWaterRevertMap = ReadFromData(m_revertWater, scene);
//Make sure the size is right!
if (terrainModule.TerrainWaterRevertMap.Height != scene.RegionInfo.RegionSizeX)
{
terrainModule.TerrainWaterRevertMap = null;
}
m_revertWater = null;
return(null);
}
else
{
if (m_water == null)
{
return(null);
}
terrainModule.TerrainWaterMap = ReadFromData(m_water, scene);
//Make sure the size is right!
if (terrainModule.TerrainWaterMap.Height != scene.RegionInfo.RegionSizeX)
{
terrainModule.TerrainWaterMap = null;
}
m_water = null;
return(null);
}
}
/// <summary>
/// Load terrain data
/// </summary>
/// <param name="scene"></param>
/// <param name="terrainPath"></param>
/// <param name="data"></param>
/// <returns>
/// true if terrain was resolved successfully, false otherwise.
/// </returns>
private bool LoadTerrain(Scene scene, string terrainPath, byte[] data)
{
ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule>();
using (MemoryStream ms = new MemoryStream(data))
{
if (m_displacement != Vector3.Zero || m_rotation != 0f)
{
Vector2 rotationCenter = new Vector2(m_rotationCenter.X, m_rotationCenter.Y);
terrainModule.LoadFromStream(terrainPath, m_displacement, m_rotation, rotationCenter, ms);
}
else
{
terrainModule.LoadFromStream(terrainPath, ms);
}
}
m_log.DebugFormat("[ARCHIVER]: Restored terrain {0}", terrainPath);
return(true);
}
public void ResetRegion(IScene scene)
{
IBackupModule backup = scene.RequestModuleInterface <IBackupModule>();
if (backup != null)
{
backup.DeleteAllSceneObjects(); //Remove all the objects from the region
}
ITerrainModule module = scene.RequestModuleInterface <ITerrainModule>();
if (module != null)
{
module.ResetTerrain(); //Then remove the terrain
}
//Then reset the textures
scene.RegionInfo.RegionSettings.TerrainTexture1 = RegionSettings.DEFAULT_TERRAIN_TEXTURE_1;
scene.RegionInfo.RegionSettings.TerrainTexture2 = RegionSettings.DEFAULT_TERRAIN_TEXTURE_2;
scene.RegionInfo.RegionSettings.TerrainTexture3 = RegionSettings.DEFAULT_TERRAIN_TEXTURE_3;
scene.RegionInfo.RegionSettings.TerrainTexture4 = RegionSettings.DEFAULT_TERRAIN_TEXTURE_4;
MainConsole.Instance.Warn("Region " + scene.RegionInfo.RegionName + " was reset");
}
public virtual void LoadWater(bool RevertMap, int RegionSizeX, int RegionSizeY)
{
ITerrainModule terrainModule = m_scene.RequestModuleInterface <ITerrainModule>();
if (RevertMap)
{
terrainModule.TerrainWaterRevertMap = ReadFromData(_regionData.RevertWater);
//Make sure the size is right!
if (terrainModule.TerrainWaterRevertMap.Width != m_scene.RegionInfo.RegionSizeX)
{
terrainModule.TerrainWaterRevertMap = null;
}
}
else
{
terrainModule.TerrainWaterMap = ReadFromData(_regionData.Water);
//Make sure the size is right!
if (terrainModule.TerrainWaterMap.Width != m_scene.RegionInfo.RegionSizeX)
{
terrainModule.TerrainWaterMap = null;
}
}
}
private void handleTerrainRequest(IClientAPI remote_client, string clientFileName)
{
// Save terrain here
ITerrainModule terr = m_scene.RequestModuleInterface <ITerrainModule>();
if (terr != null)
{
m_log.Warn("[CLIENT]: Got Request to Send Terrain in region " + m_scene.RegionInfo.RegionName);
if (File.Exists(Util.dataDir() + "/terrain.raw"))
{
File.Delete(Util.dataDir() + "/terrain.raw");
}
terr.SaveToFile(Util.dataDir() + "/terrain.raw");
FileStream input = new FileStream(Util.dataDir() + "/terrain.raw", FileMode.Open);
byte[] bdata = new byte[input.Length];
input.Read(bdata, 0, (int)input.Length);
remote_client.SendAlertMessage("Terrain file written, starting download...");
m_scene.XferManager.AddNewFile("terrain.raw", bdata);
// Tell client about it
m_log.Warn("[CLIENT]: Sending Terrain to " + remote_client.Name);
remote_client.SendInitiateDownload("terrain.raw", clientFileName);
}
}
public void SaveModuleToArchive(TarArchiveWriter writer, IScene scene)
{
m_isArchiving = true;
m_log.Info("[Archive]: Writing parcels to archive");
writer.WriteDir("parcels");
IParcelManagementModule module = scene.RequestModuleInterface <IParcelManagementModule>();
if (module != null)
{
List <ILandObject> landObject = module.AllParcels();
foreach (ILandObject parcel in landObject)
{
OSDMap parcelMap = parcel.LandData.ToOSD();
writer.WriteFile("parcels/" + parcel.LandData.GlobalID.ToString(), OSDParser.SerializeLLSDBinary(parcelMap));
}
}
m_log.Info("[Archive]: Finished writing parcels to archive");
m_log.Info("[Archive]: Writing terrain to archive");
writer.WriteDir("terrain");
ITerrainModule tModule = scene.RequestModuleInterface <ITerrainModule>();
if (tModule != null)
{
MemoryStream s = new MemoryStream();
tModule.SaveToStream(scene.RegionInfo.RegionID.ToString() + ".r32", s);
writer.WriteFile("terrain/" + scene.RegionInfo.RegionID.ToString() + ".r32", s.ToArray());
s.Close();
}
m_log.Info("[Archive]: Finished writing terrain to archive");
m_log.Info("[Archive]: Writing entities to archive");
ISceneEntity[] entities = scene.Entities.GetEntities();
//Get all entities, then start writing them to the database
writer.WriteDir("entities");
IDictionary <UUID, AssetType> assets = new Dictionary <UUID, AssetType>();
UuidGatherer assetGatherer = new UuidGatherer(m_scene.AssetService);
foreach (ISceneEntity entity in entities)
{
//Write all entities
writer.WriteFile("entities/" + entity.UUID.ToString(), ((ISceneObject)entity).ToXml2());
//Get all the assets too
assetGatherer.GatherAssetUuids(entity, assets, scene);
}
m_log.Info("[Archive]: Finished writing entities to archive");
m_log.Info("[Archive]: Writing assets for entities to archive");
bool foundAllAssets = true;
foreach (UUID assetID in new List <UUID>(assets.Keys))
{
AssetBase asset = m_scene.AssetService.GetCached(assetID.ToString());
if (asset != null)
{
WriteAsset(asset, writer); //Write it syncronously since we havn't
}
else
{
foundAllAssets = false; //Not all are cached
m_missingAssets.Add(assetID);
m_scene.AssetService.Get(assetID.ToString(), writer, RetrievedAsset);
}
}
if (foundAllAssets)
{
m_isArchiving = false; //We're done if all the assets were found
}
m_log.Info("[Archive]: Finished writing assets for entities to archive");
}
public virtual short[] LoadTerrain(IScene scene, bool RevertMap, int RegionSizeX, int RegionSizeY)
{
if (!m_loaded)
{
m_loaded = true;
ReadConfig(scene, scene.Config.Configs["FileBasedSimulationData"]);
ReadBackup(scene);
}
ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule>();
if (RevertMap)
{
if (m_revertTerrain == null)
{
if (m_shortrevertTerrain != null) //OpenSim style
{
terrainModule.TerrainRevertMap = new TerrainChannel(m_shortrevertTerrain, scene);
}
else if (m_oldstylerevertTerrain != null)
{
MemoryStream ms = new MemoryStream(m_oldstylerevertTerrain);
if (terrainModule != null)
{
terrainModule.LoadRevertMapFromStream(".r32", ms, 0, 0);
}
}
}
else
{
//New style
terrainModule.TerrainRevertMap = ReadFromData(m_revertTerrain, scene);
}
//Make sure the size is right!
if (terrainModule.TerrainRevertMap != null &&
terrainModule.TerrainRevertMap.Height != scene.RegionInfo.RegionSizeX)
{
terrainModule.TerrainRevertMap = null;
}
m_revertTerrain = null;
m_oldstylerevertTerrain = null;
m_shortrevertTerrain = null;
return(null);
}
else
{
if (m_terrain == null)
{
if (m_shortterrain != null) //OpenSim style
{
terrainModule.TerrainMap = new TerrainChannel(m_shortterrain, scene);
}
else if (m_oldstyleterrain != null)
{
//Old style
MemoryStream ms = new MemoryStream(m_oldstyleterrain);
if (terrainModule != null)
{
terrainModule.LoadFromStream(".r32", ms, 0, 0);
}
}
}
else
{
//New style
terrainModule.TerrainMap = ReadFromData(m_terrain, scene);
}
//Make sure the size is right!
if (terrainModule.TerrainMap != null &&
terrainModule.TerrainMap.Height != scene.RegionInfo.RegionSizeX)
{
terrainModule.TerrainMap = null;
}
m_terrain = null;
m_oldstyleterrain = null;
m_shortterrain = null;
return(null);
}
}
public void LoadModuleFromArchive(byte [] data, string filePath, TarArchiveReader.TarEntryType type,
IScene scene)
{
if (filePath.StartsWith("parcels/", StringComparison.Ordinal))
{
if (!m_merge)
{
//Only use if we are not merging
LandData parcel = new LandData();
OSD parcelData = OSDParser.DeserializeLLSDBinary(data);
parcel.FromOSD((OSDMap)parcelData);
m_parcels.Add(parcel);
}
}
#region New Style Terrain Loading
else if (filePath.StartsWith("newstyleterrain/", StringComparison.Ordinal))
{
ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule> ();
terrainModule.TerrainMap = ReadTerrain(data, scene);
}
else if (filePath.StartsWith("newstylerevertterrain/", StringComparison.Ordinal))
{
ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule> ();
terrainModule.TerrainRevertMap = ReadTerrain(data, scene);
}
else if (filePath.StartsWith("newstylewater/", StringComparison.Ordinal))
{
ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule> ();
terrainModule.TerrainWaterMap = ReadTerrain(data, scene);
}
else if (filePath.StartsWith("newstylerevertwater/", StringComparison.Ordinal))
{
ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule> ();
terrainModule.TerrainWaterRevertMap = ReadTerrain(data, scene);
}
#endregion
#region Old Style Terrain Loading
else if (filePath.StartsWith("terrain/", StringComparison.Ordinal))
{
ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule> ();
MemoryStream ms = new MemoryStream(data);
terrainModule.LoadFromStream(filePath, ms, 0, 0);
ms.Close();
}
else if (filePath.StartsWith("revertterrain/", StringComparison.Ordinal))
{
ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule> ();
MemoryStream ms = new MemoryStream(data);
terrainModule.LoadRevertMapFromStream(filePath, ms, 0, 0);
ms.Close();
}
else if (filePath.StartsWith("water/", StringComparison.Ordinal))
{
ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule> ();
MemoryStream ms = new MemoryStream(data);
terrainModule.LoadWaterFromStream(filePath, ms, 0, 0);
ms.Close();
}
else if (filePath.StartsWith("revertwater/", StringComparison.Ordinal))
{
ITerrainModule terrainModule = scene.RequestModuleInterface <ITerrainModule> ();
MemoryStream ms = new MemoryStream(data);
terrainModule.LoadWaterRevertMapFromStream(filePath, ms, 0, 0);
ms.Close();
}
#endregion
else if (filePath.StartsWith("entities/", StringComparison.Ordinal))
{
MemoryStream ms = new MemoryStream(data);
ISceneEntity sceneObject = SceneEntitySerializer.SceneObjectSerializer.FromXml2Format(ref ms, scene);
ms.Close();
m_groups.Add(sceneObject);
}
else if (filePath.StartsWith("assets/", StringComparison.Ordinal))
{
if (m_loadAssets)
{
AssetBase asset = new AssetBase();
asset.Unpack(OSDParser.DeserializeJson(Encoding.UTF8.GetString(data)));
scene.AssetService.Store(asset);
}
}
}
public SmoothModifier(ITerrainModule module) : base(module)
{
}
public MaxModifier(ITerrainModule module) : base(module)
{
}
public RevertSphere(ITerrainModule module)
{
m_module = module;
}
public LandUndoState(ITerrainModule terrainModule, ITerrainChannel terrainChannel)
{
m_terrainModule = terrainModule;
m_terrainChannel = terrainChannel;
}
private void HandleTerrainApplication(string filename, byte[] terrainData, IClientAPI remoteClient)
{
lock (TerrainUploader)
{
remoteClient.OnXferReceive -= TerrainUploader.XferReceive;
remoteClient.OnAbortXfer -= AbortTerrainXferHandler;
TerrainUploader.TerrainUploadDone -= HandleTerrainApplication;
TerrainUploader = null;
}
remoteClient.SendAlertMessage("Terrain Upload Complete. Loading....");
ITerrainModule terr = m_scene.RequestModuleInterface <ITerrainModule>();
if (terr != null)
{
m_log.Warn("[CLIENT]: Got Request to Send Terrain in region " + m_scene.RegionInfo.RegionName);
if (File.Exists(Util.dataDir() + "/terrain.raw"))
{
File.Delete(Util.dataDir() + "/terrain.raw");
}
try
{
FileStream input = new FileStream(Util.dataDir() + "/terrain.raw", FileMode.CreateNew);
input.Write(terrainData, 0, terrainData.Length);
input.Close();
}
catch (IOException e)
{
m_log.ErrorFormat("[TERRAIN]: Error Saving a terrain file uploaded via the estate tools. It gave us the following error: {0}", e.ToString());
remoteClient.SendAlertMessage("There was an IO Exception loading your terrain. Please check free space");
return;
}
catch (SecurityException e)
{
m_log.ErrorFormat("[TERRAIN]: Error Saving a terrain file uploaded via the estate tools. It gave us the following error: {0}", e.ToString());
remoteClient.SendAlertMessage("There was a security Exception loading your terrain. Please check the security on the simulator drive");
return;
}
catch (UnauthorizedAccessException e)
{
m_log.ErrorFormat("[TERRAIN]: Error Saving a terrain file uploaded via the estate tools. It gave us the following error: {0}", e.ToString());
remoteClient.SendAlertMessage("There was a security Exception loading your terrain. Please check the security on the simulator drive");
return;
}
try
{
terr.LoadFromFile(Util.dataDir() + "/terrain.raw");
remoteClient.SendAlertMessage("Your terrain was loaded. Give it a minute or two to apply");
}
catch (Exception e)
{
m_log.ErrorFormat("[TERRAIN]: Error loading a terrain file uploaded via the estate tools. It gave us the following error: {0}", e.ToString());
remoteClient.SendAlertMessage("There was a general error loading your terrain. Please fix the terrain file and try again");
}
}
else
{
remoteClient.SendAlertMessage("Unable to apply terrain. Cannot get an instance of the terrain module");
}
}
protected TerrainFeature(ITerrainModule module)
{
m_module = module;
}
public LowerModifier(ITerrainModule module) : base(module)
{
}
private void HandleRotate(string module, string[] cmd)
{
if (!(MainConsole.Instance.ConsoleScene is Scene))
{
return;
}
if ((Scene)MainConsole.Instance.ConsoleScene != m_Scene)
{
return;
}
if (cmd.Length < 3)
{
MainConsole.Instance.Output("Error: missing direction");
return;
}
Direction dir;
try
{
dir = (Direction)Enum.Parse(typeof(Simrot.SimrotModule.Direction), cmd[2]);
}
catch (Exception)
{
MainConsole.Instance.Output("Error: dorection must be left or right");
return;
}
Quaternion q = Quaternion.CreateFromEulers(0, 0, (float)((float)((int)dir) * Math.PI / 180.0));
Vector3 vc = new Vector3(128.0f, 128.0f, 128.0f);
m_Scene.ForEachSOG(delegate(SceneObjectGroup g)
{
if (g.IsAttachment)
{
return;
}
g.RootPart.UpdateRotation(q * g.GroupRotation);
Vector3 v = g.AbsolutePosition - vc;
g.AbsolutePosition = vc + v * q;
});
double[,] map = m_Scene.Heightmap.GetDoubles();
double[,] newMap =
new double[Constants.RegionSize, Constants.RegionSize];
if (dir == Direction.left)
{
for (int x = 0; x < Constants.RegionSize; ++x)
{
for (int y = 0; y < Constants.RegionSize; ++y)
{
newMap[Constants.RegionSize - y - 1, x] = map[x, y];
}
}
}
else
{
for (int x = 0; x < Constants.RegionSize; ++x)
{
for (int y = 0; y < Constants.RegionSize; ++y)
{
newMap[y, Constants.RegionSize - x - 1] = map[x, y];
}
}
}
for (int x = 0; x < Constants.RegionSize; ++x)
{
for (int y = 0; y < Constants.RegionSize; ++y)
{
m_Scene.Heightmap[x, y] = newMap[x, y];
}
}
ITerrainModule tm = m_Scene.RequestModuleInterface <ITerrainModule>();
if (tm == null)
{
MainConsole.Instance.Output("No terrain modules installed, not sending terrain");
return;
}
tm.UndoTerrain(m_Scene.Heightmap);
tm.TaintTerrain();
MainConsole.Instance.Output("Rotation done");
}
protected TerrainModifier(ITerrainModule module)
{
m_module = module;
}
/// <summary>
/// Save a backup of the sim
/// </summary>
/// <param name = "appendedFilePath">The file path where the backup will be saved</param>
protected virtual void SaveBackup(string appendedFilePath, bool saveAssets)
{
if (appendedFilePath == "/")
{
appendedFilePath = "";
}
if (m_scene.RegionInfo.HasBeenDeleted)
{
return;
}
IBackupModule backupModule = m_scene.RequestModuleInterface <IBackupModule>();
if (backupModule != null && backupModule.LoadingPrims) //Something is changing lots of prims
{
MainConsole.Instance.Info("[Backup]: Not saving backup because the backup module is loading prims");
return;
}
//Save any script state saves that might be around
IScriptModule[] engines = m_scene.RequestModuleInterfaces <IScriptModule>();
try
{
if (engines != null)
{
#if (!ISWIN)
foreach (IScriptModule engine in engines)
{
if (engine != null)
{
engine.SaveStateSaves();
}
}
#else
foreach (IScriptModule engine in engines.Where(engine => engine != null))
{
engine.SaveStateSaves();
}
#endif
}
}
catch (Exception ex)
{
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
MainConsole.Instance.Info("[FileBasedSimulationData]: Saving backup for region " + m_scene.RegionInfo.RegionName);
string fileName = appendedFilePath + m_scene.RegionInfo.RegionName + m_saveAppendedFileName + ".abackup";
if (File.Exists(fileName))
{
//Do new style saving here!
GZipStream m_saveStream = new GZipStream(new FileStream(fileName + ".tmp", FileMode.Create),
CompressionMode.Compress);
TarArchiveWriter writer = new TarArchiveWriter(m_saveStream);
GZipStream m_loadStream = new GZipStream(new FileStream(fileName, FileMode.Open),
CompressionMode.Decompress);
TarArchiveReader reader = new TarArchiveReader(m_loadStream);
writer.WriteDir("parcels");
IParcelManagementModule module = m_scene.RequestModuleInterface <IParcelManagementModule>();
if (module != null)
{
List <ILandObject> landObject = module.AllParcels();
foreach (ILandObject parcel in landObject)
{
OSDMap parcelMap = parcel.LandData.ToOSD();
var binary = OSDParser.SerializeLLSDBinary(parcelMap);
writer.WriteFile("parcels/" + parcel.LandData.GlobalID.ToString(),
binary);
binary = null;
parcelMap = null;
}
}
writer.WriteDir("newstyleterrain");
writer.WriteDir("newstylerevertterrain");
writer.WriteDir("newstylewater");
writer.WriteDir("newstylerevertwater");
ITerrainModule tModule = m_scene.RequestModuleInterface <ITerrainModule>();
if (tModule != null)
{
try
{
byte[] sdata = WriteTerrainToStream(tModule.TerrainMap);
writer.WriteFile("newstyleterrain/" + m_scene.RegionInfo.RegionID.ToString() + ".terrain", sdata);
sdata = null;
sdata = WriteTerrainToStream(tModule.TerrainRevertMap);
writer.WriteFile(
"newstylerevertterrain/" + m_scene.RegionInfo.RegionID.ToString() + ".terrain", sdata);
sdata = null;
if (tModule.TerrainWaterMap != null)
{
sdata = WriteTerrainToStream(tModule.TerrainWaterMap);
writer.WriteFile("newstylewater/" + m_scene.RegionInfo.RegionID.ToString() + ".terrain",
sdata);
sdata = null;
sdata = WriteTerrainToStream(tModule.TerrainWaterRevertMap);
writer.WriteFile(
"newstylerevertwater/" + m_scene.RegionInfo.RegionID.ToString() + ".terrain", sdata);
sdata = null;
}
}
catch (Exception ex)
{
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
}
IDictionary <UUID, AssetType> assets = new Dictionary <UUID, AssetType>();
UuidGatherer assetGatherer = new UuidGatherer(m_scene.AssetService);
ISceneEntity[] saveentities = m_scene.Entities.GetEntities();
List <UUID> entitiesToSave = new List <UUID>();
foreach (ISceneEntity entity in saveentities)
{
try
{
if (entity.IsAttachment ||
((entity.RootChild.Flags & PrimFlags.Temporary) == PrimFlags.Temporary) ||
((entity.RootChild.Flags & PrimFlags.TemporaryOnRez) == PrimFlags.TemporaryOnRez))
{
continue;
}
if (entity.HasGroupChanged)
{
entity.HasGroupChanged = false;
//Write all entities
byte[] xml = ((ISceneObject)entity).ToBinaryXml2();
writer.WriteFile("entities/" + entity.UUID.ToString(), xml);
xml = null;
}
else
{
entitiesToSave.Add(entity.UUID);
}
if (saveAssets)
{
assetGatherer.GatherAssetUuids(entity, assets, m_scene);
}
}
catch (Exception ex)
{
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
entitiesToSave.Add(entity.UUID);
}
}
byte[] data;
string filePath;
TarArchiveReader.TarEntryType entryType;
//Load the archive data that we need
try
{
while ((data = reader.ReadEntry(out filePath, out entryType)) != null)
{
if (TarArchiveReader.TarEntryType.TYPE_DIRECTORY == entryType)
{
continue;
}
if (filePath.StartsWith("entities/"))
{
UUID entityID = UUID.Parse(filePath.Remove(0, 9));
if (entitiesToSave.Contains(entityID))
{
writer.WriteFile(filePath, data);
entitiesToSave.Remove(entityID);
}
}
data = null;
}
}
catch (Exception ex)
{
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
if (entitiesToSave.Count > 0)
{
MainConsole.Instance.Fatal(entitiesToSave.Count + " PRIMS WERE NOT GOING TO BE SAVED! FORCE SAVING NOW! ");
foreach (ISceneEntity entity in saveentities)
{
if (entitiesToSave.Contains(entity.UUID))
{
if (entity.IsAttachment ||
((entity.RootChild.Flags & PrimFlags.Temporary) == PrimFlags.Temporary) ||
((entity.RootChild.Flags & PrimFlags.TemporaryOnRez) == PrimFlags.TemporaryOnRez))
{
continue;
}
//Write all entities
byte[] xml = ((ISceneObject)entity).ToBinaryXml2();
writer.WriteFile("entities/" + entity.UUID.ToString(), xml);
xml = null;
}
}
}
if (saveAssets)
{
foreach (UUID assetID in new List <UUID>(assets.Keys))
{
try
{
WriteAsset(assetID.ToString(), m_scene.AssetService.Get(assetID.ToString()), writer);
}
catch (Exception ex)
{
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
}
}
reader.Close();
writer.Close();
m_loadStream.Close();
m_saveStream.Close();
GC.Collect();
if (m_keepOldSave && !m_oldSaveHasBeenSaved)
{
//Havn't moved it yet, so make sure the directory exists, then move it
m_oldSaveHasBeenSaved = true;
if (!Directory.Exists(m_oldSaveDirectory))
{
Directory.CreateDirectory(m_oldSaveDirectory);
}
File.Copy(fileName + ".tmp",
Path.Combine(m_oldSaveDirectory,
m_scene.RegionInfo.RegionName + SerializeDateTime() + m_saveAppendedFileName +
".abackup"));
}
//Just remove the file
File.Delete(fileName);
}
else
{
//Add the .temp since we might need to make a backup and so that if something goes wrong, we don't corrupt the main backup
GZipStream m_saveStream = new GZipStream(new FileStream(fileName + ".tmp", FileMode.Create),
CompressionMode.Compress);
TarArchiveWriter writer = new TarArchiveWriter(m_saveStream);
IAuroraBackupArchiver archiver = m_scene.RequestModuleInterface <IAuroraBackupArchiver>();
//Turn off prompting so that we don't ask the user questions every time we need to save the backup
archiver.AllowPrompting = false;
archiver.SaveRegionBackup(writer, m_scene);
archiver.AllowPrompting = true;
m_saveStream.Close();
writer.Close();
GC.Collect();
}
File.Move(fileName + ".tmp", fileName);
ISceneEntity[] entities = m_scene.Entities.GetEntities();
try
{
#if (!ISWIN)
foreach (ISceneEntity entity in entities)
{
if (entity.HasGroupChanged)
{
entity.HasGroupChanged = false;
}
}
#else
foreach (ISceneEntity entity in entities.Where(entity => entity.HasGroupChanged))
{
entity.HasGroupChanged = false;
}
#endif
}
catch (Exception ex)
{
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
//Now make it the full file again
MapTileNeedsGenerated = true;
MainConsole.Instance.Info("[FileBasedSimulationData]: Saved Backup for region " + m_scene.RegionInfo.RegionName);
}
public RevertArea(ITerrainModule module)
{
m_module = module;
}
public MaxModifier(ITerrainModule module) : base(module)
{
}
public NoiseModifier(ITerrainModule module) : base(module)
{
}
/// <summary>
/// Save a backup of the sim
/// </summary>
/// <param name="isOldSave"></param>
protected virtual void SaveBackup(bool isOldSave)
{
if (m_scene == null || m_scene.RegionInfo.HasBeenDeleted)
{
return;
}
IBackupModule backupModule = m_scene.RequestModuleInterface <IBackupModule>();
if (backupModule != null && backupModule.LoadingPrims) //Something is changing lots of prims
{
MainConsole.Instance.Info("[Backup]: Not saving backup because the backup module is loading prims");
return;
}
//Save any script state saves that might be around
IScriptModule[] engines = m_scene.RequestModuleInterfaces <IScriptModule>();
try
{
if (engines != null)
{
foreach (IScriptModule engine in engines.Where(engine => engine != null))
{
engine.SaveStateSaves();
}
}
}
catch (Exception ex)
{
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
MainConsole.Instance.Info("[FileBasedSimulationData]: Saving backup for region " +
m_scene.RegionInfo.RegionName);
RegionData regiondata = new RegionData();
regiondata.Init();
regiondata.RegionInfo = m_scene.RegionInfo;
IParcelManagementModule module = m_scene.RequestModuleInterface <IParcelManagementModule>();
if (module != null)
{
List <ILandObject> landObject = module.AllParcels();
foreach (ILandObject parcel in landObject)
{
regiondata.Parcels.Add(parcel.LandData);
}
}
ITerrainModule tModule = m_scene.RequestModuleInterface <ITerrainModule>();
if (tModule != null)
{
try
{
regiondata.Terrain = WriteTerrainToStream(tModule.TerrainMap);
regiondata.RevertTerrain = WriteTerrainToStream(tModule.TerrainRevertMap);
if (tModule.TerrainWaterMap != null)
{
regiondata.Water = WriteTerrainToStream(tModule.TerrainWaterMap);
regiondata.RevertWater = WriteTerrainToStream(tModule.TerrainWaterRevertMap);
}
}
catch (Exception ex)
{
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
}
ISceneEntity[] entities = m_scene.Entities.GetEntities();
regiondata.Groups = new List <SceneObjectGroup>(entities.Cast <SceneObjectGroup>().Where((entity) =>
{
return
(!(entity
.IsAttachment ||
((entity
.RootChild
.Flags &
PrimFlags
.Temporary) ==
PrimFlags
.Temporary)
||
((entity
.RootChild
.Flags &
PrimFlags
.TemporaryOnRez) ==
PrimFlags
.TemporaryOnRez)));
}));
try
{
foreach (ISceneEntity entity in regiondata.Groups.Where(ent => ent.HasGroupChanged))
{
entity.HasGroupChanged = false;
}
}
catch (Exception ex)
{
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
string filename = isOldSave ? BuildOldSaveFileName() : BuildSaveFileName();
if (File.Exists(filename + (isOldSave ? "" : ".tmp")))
{
File.Delete(filename + (isOldSave ? "" : ".tmp")); //Remove old tmp files
}
if (!_regionLoader.SaveBackup(filename + (isOldSave ? "" : ".tmp"), regiondata))
{
if (File.Exists(filename + (isOldSave ? "" : ".tmp")))
{
File.Delete(filename + (isOldSave ? "" : ".tmp")); //Remove old tmp files
}
MainConsole.Instance.Error("[FileBasedSimulationData]: Failed to save backup for region " +
m_scene.RegionInfo.RegionName + "!");
return;
}
//RegionData data = _regionLoader.LoadBackup(filename + ".tmp");
if (!isOldSave)
{
if (File.Exists(filename))
{
File.Delete(filename);
}
File.Move(filename + ".tmp", filename);
if (m_keepOldSave && !m_oldSaveHasBeenSaved)
{
//Havn't moved it yet, so make sure the directory exists, then move it
m_oldSaveHasBeenSaved = true;
if (!Directory.Exists(m_oldSaveDirectory))
{
Directory.CreateDirectory(m_oldSaveDirectory);
}
File.Copy(filename, BuildOldSaveFileName());
}
}
regiondata.Dispose();
//Now make it the full file again
MapTileNeedsGenerated = true;
MainConsole.Instance.Info("[FileBasedSimulationData]: Saved Backup for region " +
m_scene.RegionInfo.RegionName);
}
public RevertSphere (ITerrainModule module)
{
m_module = module;
}
public LowerModifier(ITerrainModule module) : base(module)
{
}
public LandUndoState(ITerrainModule terrainModule, ITerrainChannel terrainChannel)
{
m_terrainModule = terrainModule;
m_terrainChannel = terrainChannel;
}
public RevertArea(ITerrainModule module)
{
m_module = module;
}
public FillModifier(ITerrainModule module) : base(module)
{
}
public void SaveModuleToArchive(TarArchiveWriter writer, IScene scene)
{
m_isArchiving = true;
MainConsole.Instance.Info("[Archive]: Writing parcels to archive");
writer.WriteDir("parcels");
IParcelManagementModule module = scene.RequestModuleInterface <IParcelManagementModule> ();
if (module != null)
{
List <ILandObject> landObject = module.AllParcels();
foreach (ILandObject parcel in landObject)
{
OSDMap parcelMap = parcel.LandData.ToOSD();
writer.WriteFile("parcels/" + parcel.LandData.GlobalID,
OSDParser.SerializeLLSDBinary(parcelMap));
}
}
MainConsole.Instance.Info("[Archive]: Finished writing parcels to archive");
MainConsole.Instance.Info("[Archive]: Writing terrain to archive");
writer.WriteDir("newstyleterrain");
writer.WriteDir("newstylerevertterrain");
writer.WriteDir("newstylewater");
writer.WriteDir("newstylerevertwater");
ITerrainModule tModule = scene.RequestModuleInterface <ITerrainModule> ();
if (tModule != null)
{
try {
byte [] sdata = WriteTerrainToStream(tModule.TerrainMap);
writer.WriteFile("newstyleterrain/" + scene.RegionInfo.RegionID + ".terrain", sdata);
sdata = WriteTerrainToStream(tModule.TerrainRevertMap);
writer.WriteFile("newstylerevertterrain/" + scene.RegionInfo.RegionID + ".terrain",
sdata);
sdata = null;
if (tModule.TerrainWaterMap != null)
{
sdata = WriteTerrainToStream(tModule.TerrainWaterMap);
writer.WriteFile("newstylewater/" + scene.RegionInfo.RegionID + ".terrain", sdata);
sdata = WriteTerrainToStream(tModule.TerrainWaterRevertMap);
writer.WriteFile(
"newstylerevertwater/" + scene.RegionInfo.RegionID + ".terrain", sdata);
sdata = null;
}
} catch (Exception ex) {
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
}
MainConsole.Instance.Info("[Archive]: Finished writing terrain to archive");
MainConsole.Instance.Info("[Archive]: Writing entities to archive");
ISceneEntity [] entities = scene.Entities.GetEntities();
//Get all entities, then start writing them to the database
writer.WriteDir("entities");
IDictionary <UUID, AssetType> assets = new Dictionary <UUID, AssetType> ();
UuidGatherer assetGatherer = new UuidGatherer(m_scene.AssetService);
IWhiteCoreBackupArchiver archiver = m_scene.RequestModuleInterface <IWhiteCoreBackupArchiver> ();
bool saveAssets = false;
if (archiver.AllowPrompting)
{
saveAssets =
MainConsole.Instance.Prompt("Save assets? (Will not be able to load on other grids if not saved)", "false")
.Equals("true", StringComparison.CurrentCultureIgnoreCase);
}
int count = 0;
foreach (ISceneEntity entity in entities)
{
try {
if (entity.IsAttachment ||
((entity.RootChild.Flags & PrimFlags.Temporary) == PrimFlags.Temporary) ||
((entity.RootChild.Flags & PrimFlags.TemporaryOnRez) == PrimFlags.TemporaryOnRez))
{
continue;
}
//Write all entities
byte [] xml = entity.ToBinaryXml2();
writer.WriteFile("entities/" + entity.UUID, xml);
xml = null;
count++;
if (count % 3 == 0)
{
Thread.Sleep(5);
}
//Get all the assets too
if (saveAssets)
{
assetGatherer.GatherAssetUuids(entity, assets);
}
} catch (Exception ex) {
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
}
entities = null;
MainConsole.Instance.Info("[Archive]: Finished writing entities to archive");
MainConsole.Instance.Info("[Archive]: Writing assets for entities to archive");
bool foundAllAssets = true;
foreach (UUID assetID in new List <UUID> (assets.Keys))
{
try {
foundAllAssets = false; //Not all are cached
m_scene.AssetService.Get(assetID.ToString(), writer, RetrievedAsset);
m_missingAssets.Add(assetID);
} catch (Exception ex) {
MainConsole.Instance.WarnFormat("[Backup]: Exception caught: {0}", ex);
}
}
if (foundAllAssets)
{
m_isArchiving = false; //We're done if all the assets were found
}
MainConsole.Instance.Info("[Archive]: Finished writing assets for entities to archive");
}
