private static MyStorageBase Compatibility_LoadCellStorage(int fileVersion, Stream stream)
{
// Size of this voxel map (in voxels)
Vector3I tmpSize;
tmpSize.X = stream.ReadInt32();
tmpSize.Y = stream.ReadInt32();
tmpSize.Z = stream.ReadInt32();
var storage = new MyOctreeStorage(null, tmpSize);
// Size of data cell in voxels. Has to be the same as current size specified by our constants.
Vector3I cellSize;
cellSize.X = stream.ReadInt32();
cellSize.Y = stream.ReadInt32();
cellSize.Z = stream.ReadInt32();
Trace.Assert(cellSize.X == MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS &&
cellSize.Y == MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS &&
cellSize.Z == MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS);
Vector3I cellsCount = tmpSize / cellSize;
Dictionary<byte, MyVoxelMaterialDefinition> mappingTable = null;
if (fileVersion == STORAGE_TYPE_VERSION_CELL)
{
// loading material names->index mappings
mappingTable = Compatibility_LoadMaterialIndexMapping(stream);
}
else if (fileVersion == 1)
{
// material name->index mappings were not saved in this version
}
var startCoord = Vector3I.Zero;
var endCoord = new Vector3I(MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS - 1);
var cache = new MyStorageData();
cache.Resize(Vector3I.Zero, endCoord);
Vector3I cellCoord;
for (cellCoord.X = 0; cellCoord.X < cellsCount.X; cellCoord.X++)
{
for (cellCoord.Y = 0; cellCoord.Y < cellsCount.Y; cellCoord.Y++)
{
for (cellCoord.Z = 0; cellCoord.Z < cellsCount.Z; cellCoord.Z++)
{
MyVoxelRangeType cellType = (MyVoxelRangeType)stream.ReadByteNoAlloc();
// Cell's are FULL by default, therefore we don't need to change them
switch (cellType)
{
case MyVoxelRangeType.EMPTY: cache.ClearContent(MyVoxelConstants.VOXEL_CONTENT_EMPTY); break;
case MyVoxelRangeType.FULL: cache.ClearContent(MyVoxelConstants.VOXEL_CONTENT_FULL); break;
case MyVoxelRangeType.MIXED:
Vector3I v;
for (v.X = 0; v.X < MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS; v.X++)
{
for (v.Y = 0; v.Y < MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS; v.Y++)
{
for (v.Z = 0; v.Z < MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS; v.Z++)
{
cache.Content(ref v, stream.ReadByteNoAlloc());
}
}
}
break;
}
startCoord = cellCoord * MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS;
endCoord = startCoord + (MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS - 1);
storage.WriteRange(cache, MyStorageDataTypeFlags.Content, ref startCoord, ref endCoord);
}
}
}
try
{ // In case materials are not saved, catch any exceptions caused by this.
// Read materials and indestructible
for (cellCoord.X = 0; cellCoord.X < cellsCount.X; cellCoord.X++)
{
for (cellCoord.Y = 0; cellCoord.Y < cellsCount.Y; cellCoord.Y++)
{
for (cellCoord.Z = 0; cellCoord.Z < cellsCount.Z; cellCoord.Z++)
{
bool isSingleMaterial = stream.ReadByteNoAlloc() == 1;
MyVoxelMaterialDefinition material = null;
if (isSingleMaterial)
{
material = Compatibility_LoadCellVoxelMaterial(stream, mappingTable);
cache.ClearMaterials(material.Index);
}
else
{
byte indestructibleContent;
Vector3I voxelCoordInCell;
for (voxelCoordInCell.X = 0; voxelCoordInCell.X < MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS; voxelCoordInCell.X++)
{
for (voxelCoordInCell.Y = 0; voxelCoordInCell.Y < MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS; voxelCoordInCell.Y++)
{
for (voxelCoordInCell.Z = 0; voxelCoordInCell.Z < MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS; voxelCoordInCell.Z++)
{
material = Compatibility_LoadCellVoxelMaterial(stream, mappingTable);
indestructibleContent = stream.ReadByteNoAlloc();
cache.Material(ref voxelCoordInCell, material.Index);
}
}
}
}
startCoord = cellCoord * MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS;
endCoord = startCoord + (MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS - 1);
storage.WriteRange(cache, MyStorageDataTypeFlags.Material, ref startCoord, ref endCoord);
}
}
}
}
catch (EndOfStreamException ex)
{
MySandboxGame.Log.WriteLine(ex);
}
return storage;
}
public unsafe MyStorageBase Compatibility_LoadCellStorage(int fileVersion, Stream stream)
{
Vector3I vectori;
Vector3I vectori2;
Vector3I vectori6;
vectori.X = stream.ReadInt32();
vectori.Y = stream.ReadInt32();
vectori.Z = stream.ReadInt32();
MyOctreeStorage storage = new MyOctreeStorage(null, vectori);
vectori2.X = stream.ReadInt32();
vectori2.Y = stream.ReadInt32();
vectori2.Z = stream.ReadInt32();
Vector3I vectori3 = (Vector3I)(vectori / vectori2);
Dictionary <byte, MyVoxelMaterialDefinition> mapping = null;
if (fileVersion == 2)
{
mapping = this.Compatibility_LoadMaterialIndexMapping(stream);
}
else
{
int num2 = fileVersion;
}
Vector3I zero = Vector3I.Zero;
Vector3I end = new Vector3I(7);
MyStorageData source = new MyStorageData(MyStorageDataTypeFlags.All);
source.Resize(Vector3I.Zero, end);
vectori6.X = 0;
while (vectori6.X < vectori3.X)
{
vectori6.Y = 0;
while (true)
{
if (vectori6.Y >= vectori3.Y)
{
int *numPtr6 = (int *)ref vectori6.X;
numPtr6[0]++;
break;
}
vectori6.Z = 0;
while (true)
{
if (vectori6.Z >= vectori3.Z)
{
int *numPtr5 = (int *)ref vectori6.Y;
numPtr5[0]++;
break;
}
MyVoxelContentConstitution constitution = (MyVoxelContentConstitution)stream.ReadByteNoAlloc();
switch (constitution)
{
case MyVoxelContentConstitution.Empty:
source.ClearContent(0);
break;
case MyVoxelContentConstitution.Full:
source.ClearContent(0xff);
break;
case MyVoxelContentConstitution.Mixed:
Vector3I vectori7;
vectori7.X = 0;
while (vectori7.X < 8)
{
vectori7.Y = 0;
while (true)
{
if (vectori7.Y >= 8)
{
int *numPtr3 = (int *)ref vectori7.X;
numPtr3[0]++;
break;
}
vectori7.Z = 0;
while (true)
{
if (vectori7.Z >= 8)
{
int *numPtr2 = (int *)ref vectori7.Y;
numPtr2[0]++;
break;
}
source.Content(ref vectori7, stream.ReadByteNoAlloc());
int *numPtr1 = (int *)ref vectori7.Z;
numPtr1[0]++;
}
}
}
break;
default:
break;
}
zero = vectori6 * 8;
storage.WriteRange(source, MyStorageDataTypeFlags.Content, zero, (Vector3I)(zero + 7), true, false);
int *numPtr4 = (int *)ref vectori6.Z;
numPtr4[0]++;
}
}
}
try
{
vectori6.X = 0;
while (vectori6.X < vectori3.X)
{
vectori6.Y = 0;
while (true)
{
if (vectori6.Y >= vectori3.Y)
{
int *numPtr12 = (int *)ref vectori6.X;
numPtr12[0]++;
break;
}
vectori6.Z = 0;
while (true)
{
if (vectori6.Z >= vectori3.Z)
{
int *numPtr11 = (int *)ref vectori6.Y;
numPtr11[0]++;
break;
}
MyVoxelMaterialDefinition definition = null;
if (stream.ReadByteNoAlloc() == 1)
{
source.ClearMaterials(this.Compatibility_LoadCellVoxelMaterial(stream, mapping).Index);
}
else
{
Vector3I vectori8;
vectori8.X = 0;
while (vectori8.X < 8)
{
vectori8.Y = 0;
while (true)
{
if (vectori8.Y >= 8)
{
int *numPtr9 = (int *)ref vectori8.X;
numPtr9[0]++;
break;
}
vectori8.Z = 0;
while (true)
{
if (vectori8.Z >= 8)
{
int *numPtr8 = (int *)ref vectori8.Y;
numPtr8[0]++;
break;
}
definition = this.Compatibility_LoadCellVoxelMaterial(stream, mapping);
stream.ReadByteNoAlloc();
source.Material(ref vectori8, definition.Index);
int *numPtr7 = (int *)ref vectori8.Z;
numPtr7[0]++;
}
}
}
}
zero = vectori6 * 8;
storage.WriteRange(source, MyStorageDataTypeFlags.Material, zero, (Vector3I)(zero + 7), true, false);
int *numPtr10 = (int *)ref vectori6.Z;
numPtr10[0]++;
}
}
}
}
catch (EndOfStreamException exception)
{
MySandboxGame.Log.WriteLine(exception);
}
return(storage);
}
private static MyStorageBase Compatibility_LoadCellStorage(int fileVersion, Stream stream)
{
// Size of this voxel map (in voxels)
Vector3I tmpSize;
tmpSize.X = stream.ReadInt32();
tmpSize.Y = stream.ReadInt32();
tmpSize.Z = stream.ReadInt32();
var storage = new MyOctreeStorage(null, tmpSize);
// Size of data cell in voxels. Has to be the same as current size specified by our constants.
Vector3I cellSize;
cellSize.X = stream.ReadInt32();
cellSize.Y = stream.ReadInt32();
cellSize.Z = stream.ReadInt32();
#if !XB1
Trace.Assert(cellSize.X == MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS &&
cellSize.Y == MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS &&
cellSize.Z == MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS);
#else // XB1
System.Diagnostics.Debug.Assert(cellSize.X == MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS &&
cellSize.Y == MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS &&
cellSize.Z == MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS);
#endif // XB1
Vector3I cellsCount = tmpSize / cellSize;
Dictionary <byte, MyVoxelMaterialDefinition> mappingTable = null;
if (fileVersion == STORAGE_TYPE_VERSION_CELL)
{
// loading material names->index mappings
mappingTable = Compatibility_LoadMaterialIndexMapping(stream);
}
else if (fileVersion == 1)
{
// material name->index mappings were not saved in this version
}
var startCoord = Vector3I.Zero;
var endCoord = new Vector3I(MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS - 1);
var cache = new MyStorageData();
cache.Resize(Vector3I.Zero, endCoord);
Vector3I cellCoord;
for (cellCoord.X = 0; cellCoord.X < cellsCount.X; cellCoord.X++)
{
for (cellCoord.Y = 0; cellCoord.Y < cellsCount.Y; cellCoord.Y++)
{
for (cellCoord.Z = 0; cellCoord.Z < cellsCount.Z; cellCoord.Z++)
{
MyVoxelRangeType cellType = (MyVoxelRangeType)stream.ReadByteNoAlloc();
// Cell's are FULL by default, therefore we don't need to change them
switch (cellType)
{
case MyVoxelRangeType.EMPTY: cache.ClearContent(MyVoxelConstants.VOXEL_CONTENT_EMPTY); break;
case MyVoxelRangeType.FULL: cache.ClearContent(MyVoxelConstants.VOXEL_CONTENT_FULL); break;
case MyVoxelRangeType.MIXED:
Vector3I v;
for (v.X = 0; v.X < MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS; v.X++)
{
for (v.Y = 0; v.Y < MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS; v.Y++)
{
for (v.Z = 0; v.Z < MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS; v.Z++)
{
cache.Content(ref v, stream.ReadByteNoAlloc());
}
}
}
break;
}
startCoord = cellCoord * MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS;
endCoord = startCoord + (MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS - 1);
storage.WriteRange(cache, MyStorageDataTypeFlags.Content, ref startCoord, ref endCoord);
}
}
}
try
{ // In case materials are not saved, catch any exceptions caused by this.
// Read materials and indestructible
for (cellCoord.X = 0; cellCoord.X < cellsCount.X; cellCoord.X++)
{
for (cellCoord.Y = 0; cellCoord.Y < cellsCount.Y; cellCoord.Y++)
{
for (cellCoord.Z = 0; cellCoord.Z < cellsCount.Z; cellCoord.Z++)
{
bool isSingleMaterial = stream.ReadByteNoAlloc() == 1;
MyVoxelMaterialDefinition material = null;
if (isSingleMaterial)
{
material = Compatibility_LoadCellVoxelMaterial(stream, mappingTable);
cache.ClearMaterials(material.Index);
}
else
{
byte indestructibleContent;
Vector3I voxelCoordInCell;
for (voxelCoordInCell.X = 0; voxelCoordInCell.X < MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS; voxelCoordInCell.X++)
{
for (voxelCoordInCell.Y = 0; voxelCoordInCell.Y < MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS; voxelCoordInCell.Y++)
{
for (voxelCoordInCell.Z = 0; voxelCoordInCell.Z < MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS; voxelCoordInCell.Z++)
{
material = Compatibility_LoadCellVoxelMaterial(stream, mappingTable);
indestructibleContent = stream.ReadByteNoAlloc();
cache.Material(ref voxelCoordInCell, material.Index);
}
}
}
}
startCoord = cellCoord * MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS;
endCoord = startCoord + (MyVoxelConstants.DATA_CELL_SIZE_IN_VOXELS - 1);
storage.WriteRange(cache, MyStorageDataTypeFlags.Material, ref startCoord, ref endCoord);
}
}
}
}
catch (EndOfStreamException ex)
{
MySandboxGame.Log.WriteLine(ex);
}
return(storage);
}
void ShrinkVMap()
{
Vector3I min, max;
m_selectedVoxel.GetFilledStorageBounds(out min, out max);
MyVoxelMapStorageDefinition def = null;
if (m_selectedVoxel.AsteroidName != null)
MyDefinitionManager.Static.TryGetVoxelMapStorageDefinition(m_selectedVoxel.AsteroidName, out def);
var origSize = m_selectedVoxel.Size;
var tightSize = max - min + 1;
var storage = new MyOctreeStorage(null, tightSize);
var offset = (storage.Size - tightSize)/2 + 1;
MyStorageData data = new MyStorageData();
data.Resize(tightSize);
m_selectedVoxel.Storage.ReadRange(data, MyStorageDataTypeFlags.ContentAndMaterial, 0, min, max);
min = offset;
max = offset + tightSize - 1;
storage.WriteRange(data, MyStorageDataTypeFlags.ContentAndMaterial, ref min, ref max);
var newMap = MyWorldGenerator.AddVoxelMap(m_selectedVoxel.StorageName, storage, m_selectedVoxel.WorldMatrix);
m_selectedVoxel.Close();
newMap.Save = true;
if (def == null)
{
ShowAlert("Voxel map {0} does not have a definition, the shrunk voxel map will be saved with the world instead.", m_selectedVoxel.StorageName);
}
else
{
byte[] cVmapData;
newMap.Storage.Save(out cVmapData);
using (var ostream = MyFileSystem.OpenWrite(Path.Combine(MyFileSystem.ContentPath, def.StorageFile), FileMode.Open))
{
ostream.Write(cVmapData, 0, cVmapData.Length);
}
var notification = new MyHudNotification(MyStringId.GetOrCompute("Voxel prefab {0} updated succesfuly (size changed from {1} to {2})."), 4000);
notification.SetTextFormatArguments(def.Id.SubtypeName, origSize, storage.Size);
MyHud.Notifications.Add(notification);
}
}