public MyProviderLeaf(IMyStorageDataProvider provider, MyStorageDataTypeEnum dataType, ref Vector3I leafMin, ref Vector3I leafMax)
{
m_provider = provider;
m_dataType = dataType;
m_leafMin = leafMin;
m_leafMax = leafMax;
}
public MyProviderLeaf(IMyStorageDataProvider provider, MyStorageDataTypeEnum dataType, ref Vector3I leafMin, ref Vector3I leafMax)
{
m_provider = provider;
m_dataType = dataType;
m_leafMin = leafMin;
m_leafMax = leafMax;
}
private void RemoveAllAsteroids(MyGuiControlButton sender)
{
MyCsgShapePlanetShapeAttributes shapeAttributes = new MyCsgShapePlanetShapeAttributes();
shapeAttributes.Seed = 12345;
shapeAttributes.Diameter = 60;
shapeAttributes.Radius = 60 / 2.0f;
shapeAttributes.DeviationScale = 0.003f;
float maxHillSize = 10;
float planetHalfDeviation = (shapeAttributes.Diameter * shapeAttributes.DeviationScale) / 2.0f;
float hillHalfDeviation = planetHalfDeviation * maxHillSize;
float canyonHalfDeviation = 1;
float averagePlanetRadius = shapeAttributes.Radius - hillHalfDeviation;
float outerRadius = averagePlanetRadius + hillHalfDeviation;
float innerRadius = averagePlanetRadius - canyonHalfDeviation;
float atmosphereRadius = MathHelper.Max(outerRadius, averagePlanetRadius * 1.08f);
float minPlanetRadius = MathHelper.Min(innerRadius, averagePlanetRadius - planetHalfDeviation * 2 * 2.5f);
MyCsgShapePlanetMaterialAttributes materialAttributes = new MyCsgShapePlanetMaterialAttributes();
materialAttributes.OreStartDepth = innerRadius;
materialAttributes.OreEndDepth = innerRadius;
materialAttributes.OreEndDepth = MathHelper.Max(materialAttributes.OreEndDepth, 0);
materialAttributes.OreStartDepth = MathHelper.Max(materialAttributes.OreStartDepth, 0);
materialAttributes.OreProbabilities = new MyOreProbability[10];
for (int i = 0; i < 10; ++i)
{
materialAttributes.OreProbabilities[i] = new MyOreProbability();
materialAttributes.OreProbabilities[i].OreName = "Ice_01";
materialAttributes.OreProbabilities[i].CummulativeProbability = 0.0f;
}
shapeAttributes.AveragePlanetRadius = averagePlanetRadius;
IMyStorageDataProvider dataProvider = MyCompositeShapeProvider.CreatePlanetShape(0, ref shapeAttributes, maxHillSize, ref materialAttributes);
IMyStorage storage = new MyOctreeStorage(dataProvider, MyVoxelCoordSystems.FindBestOctreeSize(shapeAttributes.Diameter));
MyStorageDataCache cache = new MyStorageDataCache();
cache.Resize(storage.Size);
Vector3I start = Vector3I.Zero;
Vector3I end = storage.Size;
storage.ReadRange(cache, MyStorageDataTypeFlags.Content, 1, ref start, ref end);
dataProvider.ReleaseHeightMaps();
}
private static void WriteDataProvider(Stream stream, IMyStorageDataProvider provider)
{
if (provider == null)
{
return;
}
ChunkHeader header = new ChunkHeader()
{
ChunkType = ChunkTypeEnum.DataProvider,
Version = 2,
Size = provider.SerializedSize + sizeof(Int32),
};
header.WriteTo(stream);
stream.WriteNoAlloc(m_attributesByType[provider.GetType()].ProviderTypeId);
provider.WriteTo(stream);
}
public MyOctreeStorage(IMyStorageDataProvider dataProvider, Vector3I size)
{
{
int tmp = MathHelper.Max(size.X, size.Y, size.Z);
tmp = MathHelper.GetNearestBiggerPowerOfTwo(tmp);
if (tmp < LeafSizeInVoxels)
{
tmp = LeafSizeInVoxels;
}
Size = new Vector3I(tmp);
}
m_dataProvider = dataProvider;
InitTreeHeight();
Debug.Assert(m_treeHeight < MyCellCoord.MAX_LOD_COUNT);
ResetInternal(MyStorageDataTypeFlags.All);
base.Geometry.Init(this);
}
void IMyOctreeLeafNode.OnDataProviderChanged(IMyStorageDataProvider newProvider)
{
// do nothing, doesn't depend on provider
}
void IMyOctreeLeafNode.OnDataProviderChanged(IMyStorageDataProvider newProvider)
{
m_provider = newProvider;
}
public MyOctreeStorage(IMyStorageDataProvider dataProvider, Vector3I size)
{
{
int tmp = MathHelper.Max(size.X, size.Y, size.Z);
tmp = MathHelper.GetNearestBiggerPowerOfTwo(tmp);
if (tmp < LeafSizeInVoxels)
tmp = LeafSizeInVoxels;
Size = new Vector3I(tmp);
}
m_dataProvider = dataProvider;
InitTreeHeight();
Debug.Assert(m_treeHeight < MyCellCoord.MAX_LOD_COUNT);
ResetInternal(MyStorageDataTypeFlags.All);
base.Geometry.Init(this);
}
private static bool ResetOutsideBorders(
IMyStorageDataProvider provider,
MyStorageDataTypeEnum dataType,
int lodIdx,
Dictionary<UInt64, MyOctreeNode> nodes,
Dictionary<UInt64, IMyOctreeLeafNode> leaves,
Vector3I lodCoord,
Vector3I minVoxel,
Vector3I maxVoxel,
out bool canCollapse,
Dictionary<UInt64, IMyOctreeLeafNode> outResetLeaves = null)
{
canCollapse = false;
bool changed = false;
var currentCell = new MyCellCoord(lodIdx, lodCoord);
var key = currentCell.PackId64();
var leafCell = currentCell;
var leafKey = leafCell.PackId64();
IMyOctreeLeafNode leaf;
if (leaves.TryGetValue(leafKey, out leaf))
{
canCollapse = leaf.ReadOnly;
if (leafCell.Lod != 0)
{
Debug.Assert(leaf.ReadOnly);
return false;
}
else if (!leaf.ReadOnly)
{
var minCell = minVoxel >> (LeafLodCount + leafCell.Lod);
var maxCell = maxVoxel >> (LeafLodCount + leafCell.Lod);
if (!leafCell.CoordInLod.IsInsideInclusive(ref minCell, ref maxCell))
{
canCollapse = true;
leaves.Remove(leafKey);
var leafCellCopy = leafCell;
leafCellCopy.Lod += LeafLodCount;
var leafNew = new MyProviderLeaf(provider, dataType, ref leafCellCopy);
leaves.Add(leafKey, leafNew);
changed = true;
if (outResetLeaves != null)
outResetLeaves.Add(leafKey, leafNew);
}
}
}
else
{
currentCell.Lod -= 1;
key = currentCell.PackId64();
var nodeCell = currentCell;
var nodeKey = currentCell.PackId64();
var node = nodes[nodeKey];
var childBase = lodCoord << 1;
Vector3I childOffset;
var minInChild = (minVoxel >> (LeafLodCount + currentCell.Lod)) - childBase;
var maxInChild = (maxVoxel >> (LeafLodCount + currentCell.Lod)) - childBase;
var leafSize = LeafSizeInVoxels << currentCell.Lod;
unsafe
{
canCollapse = true;
for (int i = 0; i < MyOctreeNode.CHILD_COUNT; i++)
{
ComputeChildCoord(i, out childOffset);
if (childOffset.IsInsideExclusive(ref minInChild, ref maxInChild))
{
canCollapse = false;
continue;
}
currentCell.CoordInLod = childBase + childOffset;
if (node.HasChild(i))
{
bool localCanCollapse;
bool resetChanged = ResetOutsideBorders(provider, dataType, currentCell.Lod, nodes, leaves, currentCell.CoordInLod, minVoxel, maxVoxel, out localCanCollapse, outResetLeaves: outResetLeaves);
changed = changed || resetChanged;
canCollapse = localCanCollapse && canCollapse;
}
else
{
var currentCellCopy = currentCell;
currentCellCopy.Lod += LeafLodCount;
IMyOctreeLeafNode octreeLeaf = new MyProviderLeaf(provider, dataType, ref currentCellCopy);
leaves.Add(currentCell.PackId64(), octreeLeaf);
node.SetChild(i, true);
node.SetData(i, octreeLeaf.GetFilteredValue());
changed = true;
}
}
nodes[nodeKey] = node;
if (canCollapse)
{
// Remove leaves
for (int i = 0; i < MyOctreeNode.CHILD_COUNT; i++)
{
if (node.HasChild(i))
{
ComputeChildCoord(i, out childOffset);
currentCell.CoordInLod = childBase + childOffset;
var childKey = currentCell.PackId64();
leaves.Remove(childKey);
node.SetChild(i, false);
}
}
// Remove node
nodes.Remove(nodeKey);
// Add leaf
var leafCellCopy = leafCell;
leafCellCopy.Lod += LeafLodCount;
var leafNew = new MyProviderLeaf(provider, dataType, ref leafCellCopy);
leaves.Add(leafKey, leafNew);
}
}
}
return changed;
}
void IMyOctreeLeafNode.OnDataProviderChanged(IMyStorageDataProvider newProvider)
{
// do nothing, doesn't depend on provider
}
private static void ReadDataProvider(Stream stream, ChunkHeader header, ref bool isOldFormat, out IMyStorageDataProvider provider)
{
const int TERRAIN_DATA_ID = 1;
switch (header.Version)
{
case 2: // this could be any provider
{
Int32 providerTypeId = stream.ReadInt32();
provider = (IMyStorageDataProvider)Activator.CreateInstance(m_attributesById[providerTypeId].ProviderType);
header.Size -= sizeof(Int32);
provider.ReadFrom(ref header, stream, ref isOldFormat);
}
break;
case 1: // Version 1 is only used for terrain data and nothing else can be there. Terrain data has ID 1
provider = (IMyStorageDataProvider)Activator.CreateInstance(m_attributesById[TERRAIN_DATA_ID].ProviderType);
provider.ReadFrom(ref header, stream, ref isOldFormat);
isOldFormat = true;
break;
default:
throw new InvalidBranchException();
}
}
void IMyOctreeLeafNode.OnDataProviderChanged(IMyStorageDataProvider newProvider)
{
m_provider = newProvider;
}
public MyProviderLeaf(IMyStorageDataProvider provider, MyStorageDataTypeEnum dataType, ref MyCellCoord cell)
{
m_provider = provider;
m_dataType = dataType;
m_cell = cell;
}
public MyProviderLeaf(IMyStorageDataProvider provider, MyStorageDataTypeEnum dataType, ref MyCellCoord cell)
{
m_provider = provider;
m_dataType = dataType;
m_cell = cell;
}
private static bool ResetOutsideBorders(
IMyStorageDataProvider provider,
MyStorageDataTypeEnum dataType,
int lodIdx,
Dictionary <UInt64, MyOctreeNode> nodes,
Dictionary <UInt64, IMyOctreeLeafNode> leaves,
Vector3I lodCoord,
Vector3I minVoxel,
Vector3I maxVoxel,
out bool canCollapse,
Dictionary <UInt64, IMyOctreeLeafNode> outResetLeaves = null)
{
canCollapse = false;
bool changed = false;
var currentCell = new MyCellCoord(lodIdx, lodCoord);
var key = currentCell.PackId64();
var leafCell = currentCell;
var leafKey = leafCell.PackId64();
IMyOctreeLeafNode leaf;
if (leaves.TryGetValue(leafKey, out leaf))
{
canCollapse = leaf.ReadOnly;
if (leafCell.Lod != 0)
{
Debug.Assert(leaf.ReadOnly);
return(false);
}
else if (!leaf.ReadOnly)
{
var minCell = minVoxel >> (LeafLodCount + leafCell.Lod);
var maxCell = maxVoxel >> (LeafLodCount + leafCell.Lod);
if (!leafCell.CoordInLod.IsInsideInclusive(ref minCell, ref maxCell))
{
canCollapse = true;
leaves.Remove(leafKey);
var leafCellCopy = leafCell;
leafCellCopy.Lod += LeafLodCount;
var leafNew = new MyProviderLeaf(provider, dataType, ref leafCellCopy);
leaves.Add(leafKey, leafNew);
changed = true;
if (outResetLeaves != null)
{
outResetLeaves.Add(leafKey, leafNew);
}
}
}
}
else
{
currentCell.Lod -= 1;
key = currentCell.PackId64();
var nodeCell = currentCell;
var nodeKey = currentCell.PackId64();
var node = nodes[nodeKey];
var childBase = lodCoord << 1;
Vector3I childOffset;
var minInChild = (minVoxel >> (LeafLodCount + currentCell.Lod)) - childBase;
var maxInChild = (maxVoxel >> (LeafLodCount + currentCell.Lod)) - childBase;
var leafSize = LeafSizeInVoxels << currentCell.Lod;
unsafe
{
canCollapse = true;
for (int i = 0; i < MyOctreeNode.CHILD_COUNT; i++)
{
ComputeChildCoord(i, out childOffset);
if (childOffset.IsInsideExclusive(ref minInChild, ref maxInChild))
{
canCollapse = false;
continue;
}
currentCell.CoordInLod = childBase + childOffset;
if (node.HasChild(i))
{
bool localCanCollapse;
bool resetChanged = ResetOutsideBorders(provider, dataType, currentCell.Lod, nodes, leaves, currentCell.CoordInLod, minVoxel, maxVoxel, out localCanCollapse, outResetLeaves: outResetLeaves);
changed = changed || resetChanged;
canCollapse = localCanCollapse && canCollapse;
}
else
{
var currentCellCopy = currentCell;
currentCellCopy.Lod += LeafLodCount;
IMyOctreeLeafNode octreeLeaf = new MyProviderLeaf(provider, dataType, ref currentCellCopy);
leaves.Add(currentCell.PackId64(), octreeLeaf);
node.SetChild(i, true);
node.SetData(i, octreeLeaf.GetFilteredValue());
changed = true;
}
}
nodes[nodeKey] = node;
if (canCollapse)
{
// Remove leaves
for (int i = 0; i < MyOctreeNode.CHILD_COUNT; i++)
{
if (node.HasChild(i))
{
ComputeChildCoord(i, out childOffset);
currentCell.CoordInLod = childBase + childOffset;
var childKey = currentCell.PackId64();
leaves.Remove(childKey);
node.SetChild(i, false);
}
}
// Remove node
nodes.Remove(nodeKey);
// Add leaf
var leafCellCopy = leafCell;
leafCellCopy.Lod += LeafLodCount;
var leafNew = new MyProviderLeaf(provider, dataType, ref leafCellCopy);
leaves.Add(leafKey, leafNew);
}
}
}
return(changed);
}
