void IMyOctreeLeafNode.WriteRange(MyStorageData source, ref Vector3I readOffset, ref Vector3I min, ref Vector3I max)
{
m_octree.WriteRange(source, m_dataType, ref readOffset, ref min, ref max);
if (DEBUG_WRITES)
{
var tmp = new MyStorageData();
tmp.Resize(min, max);
m_octree.ReadRange(tmp, m_dataType, ref Vector3I.Zero, 0, ref min, ref max);
Vector3I p = Vector3I.Zero;
var cacheEnd = max - min;
int errorCounter = 0;
for (var it = new Vector3I.RangeIterator(ref Vector3I.Zero, ref cacheEnd);
it.IsValid(); it.GetNext(out p))
{
var read = readOffset + p;
if (source.Get(m_dataType, ref read) != tmp.Get(m_dataType, ref p))
{
++errorCounter;
}
}
Debug.Assert(errorCounter == 0, string.Format("{0} errors writing to leaf octree.", errorCounter));
}
}
void IMyOctreeLeafNode.WriteRange(MyStorageData source, ref Vector3I readOffset, ref Vector3I min, ref Vector3I max)
{
m_octree.WriteRange(source, m_dataType, ref readOffset, ref min, ref max);
if (DEBUG_WRITES)
{
var tmp = new MyStorageData();
tmp.Resize(min, max);
m_octree.ReadRange(tmp, m_dataType, ref Vector3I.Zero, 0, ref min, ref max);
Vector3I p = Vector3I.Zero;
var cacheEnd = max - min;
int errorCounter = 0;
for (var it = new Vector3I.RangeIterator(ref Vector3I.Zero, ref cacheEnd);
it.IsValid(); it.GetNext(out p))
{
var read = readOffset + p;
if (source.Get(m_dataType, ref read) != tmp.Get(m_dataType, ref p))
++errorCounter;
}
Debug.Assert(errorCounter == 0, string.Format("{0} errors writing to leaf octree.", errorCounter));
}
}
private unsafe void WriteRange(
MyCellCoord cell,
TLeafData defaultData,
MyStorageData source,
MyStorageDataTypeEnum type,
ref Vector3I readOffset,
ref Vector3I min,
ref Vector3I max)
{
var nodeKey = cell.PackId32();
MyOctreeNode node;
if (!m_nodes.TryGetValue(nodeKey, out node))
{
for (int i = 0; i < MyOctreeNode.CHILD_COUNT; ++i)
{
node.Data[i] = defaultData;
}
}
if (cell.Lod == 0)
{
var childBase = cell.CoordInLod << 1;
Vector3I childOffset;
for (int i = 0; i < MyOctreeNode.CHILD_COUNT; ++i)
{
ComputeChildCoord(i, out childOffset);
var child = childBase + childOffset;
if (!child.IsInsideInclusive(ref min, ref max))
{
continue;
}
child -= min;
child += readOffset;
node.Data[i] = source.Get(type, ref child);
}
m_nodes[nodeKey] = node;
}
else
{
var childBase = cell.CoordInLod << 1;
Vector3I childOffset;
var minInChild = (min >> cell.Lod) - childBase;
var maxInChild = (max >> cell.Lod) - childBase;
for (int i = 0; i < MyOctreeNode.CHILD_COUNT; ++i)
{
ComputeChildCoord(i, out childOffset);
if (!childOffset.IsInsideInclusive(ref minInChild, ref maxInChild))
{
continue;
}
var childCell = new MyCellCoord(cell.Lod - 1, childBase + childOffset);
WriteRange(childCell, node.Data[i], source, type, ref readOffset, ref min, ref max);
var childKey = childCell.PackId32();
var childNode = m_nodes[childKey];
if (!childNode.HasChildren && MyOctreeNode.AllDataSame(childNode.Data))
{
node.SetChild(i, false);
node.Data[i] = childNode.Data[0];
m_nodes.Remove(childKey);
}
else
{
node.SetChild(i, true);
node.Data[i] = m_nodeFilter(childNode.Data, cell.Lod);
}
}
m_nodes[nodeKey] = node;
}
}
public static bool DoGrading(
IReadOnlyList <IRailGradeComponent> components, Vector3D target, float radius, uint availableForDeposit,
uint availableForExcavate,
uint[] excavatedByMaterial, byte materialToDeposit, out uint totalDeposited, out uint totalExcavated,
bool testDynamic, out bool triedToChange, out bool intersectedDynamic)
{
try
{
var voxelRadius = (int)Math.Ceiling(radius);
{
_dynamicEntities.Clear();
_workingVoxels.Clear();
var sphere = new BoundingSphereD(target, voxelRadius + 2);
var tmp = MyEntities.GetEntitiesInSphere(ref sphere);
using (tmp.GetClearToken())
foreach (var e in tmp)
{
if (e is MyVoxelBase vox)
{
_workingVoxels.Add(vox);
}
if (e.Physics != null && !e.Physics.IsStatic)
{
_dynamicEntities.Add(e);
}
}
}
totalDeposited = 0;
totalExcavated = 0;
triedToChange = false;
intersectedDynamic = false;
var fill = new IGradeShape[components.Count];
var excavate = new IGradeShape[components.Count];
for (var i = 0; i < components.Count; i++)
{
components[i].Unblit(out fill[i], out excavate[i]);
}
var voxel = MyGamePruningStructureSandbox.GetClosestPlanet(target)?.RootVoxel;
if (voxel == null)
{
return(false);
}
Vector3I center;
MyVoxelCoordSystems.WorldPositionToVoxelCoord(voxel.PositionLeftBottomCorner, ref target, out center);
var voxMin = center - voxelRadius - 1;
var voxMax = center + voxelRadius + 1;
_storage.Resize(voxMin, voxMax);
voxel.Storage.ReadRange(_storage, MyStorageDataTypeFlags.ContentAndMaterial, 0, voxMin, voxMax);
var changed = false;
#region Mutate
for (var i = 0;
i <= voxelRadius && (!triedToChange || availableForExcavate > 0 || availableForDeposit > 0);
i++)
{
for (var e = new ShellEnumerator(center - i, center + i);
e.MoveNext() && (!triedToChange || availableForExcavate > 0 || availableForDeposit > 0);)
{
var vCoord = e.Current;
var dataCoord = e.Current - voxMin;
Vector3D worldCoord;
MyVoxelCoordSystems.VoxelCoordToWorldPosition(voxel.PositionLeftBottomCorner, ref vCoord,
out worldCoord);
var cval = _storage.Get(MyStorageDataTypeEnum.Content, ref dataCoord);
byte?excavationDensity = null;
if (cval > 0 && (!triedToChange || availableForExcavate > 0))
{
float density = 0;
foreach (var c in excavate.Where(x => x != null))
{
density = Math.Max(density, c.GetDensity(ref worldCoord));
}
if (density > 0)
{
excavationDensity = (byte)((1 - density) * byte.MaxValue);
}
}
byte?fillDensity = null;
if (cval < byte.MaxValue && (!triedToChange || availableForDeposit > 0))
{
float density = 0;
foreach (var c in fill.Where(x => x != null))
{
density = Math.Max(density, c.GetDensity(ref worldCoord));
}
if (density > 0)
{
fillDensity = (byte)(density * byte.MaxValue);
}
}
if ((!fillDensity.HasValue || cval >= fillDensity.Value) &&
(!excavationDensity.HasValue || cval <= excavationDensity.Value))
{
continue;
}
if (excavationDensity.HasValue && excavationDensity.Value < cval)
{
triedToChange = true;
var toExtract = (uint)Math.Min(availableForExcavate, cval - excavationDensity.Value);
if (toExtract > 0)
{
var mid = _storage.Get(MyStorageDataTypeEnum.Material, ref dataCoord);
if (excavatedByMaterial != null && mid < excavatedByMaterial.Length)
{
excavatedByMaterial[mid] += toExtract;
}
DisableFarming(worldCoord);
_storage.Set(MyStorageDataTypeEnum.Content, ref dataCoord, (byte)(cval - toExtract));
totalExcavated += toExtract;
availableForExcavate -= toExtract;
changed = true;
}
continue;
}
if (!fillDensity.HasValue || fillDensity.Value <= cval)
{
continue;
}
triedToChange = true;
var toFill = Math.Min(availableForDeposit, fillDensity.Value - cval);
if (toFill <= 0)
{
continue;
}
// would this deposit in midair?
{
var test = worldCoord;
test += 2 * Vector3D.Normalize(
MyGravityProviderSystem.CalculateNaturalGravityInPoint(worldCoord));
Vector3I vtest;
MyVoxelCoordSystems.WorldPositionToVoxelCoord(voxel.PositionLeftBottomCorner, ref test,
out vtest);
vtest = Vector3I.Clamp(vtest, voxMin, voxMax) - voxMin;
if (vtest != vCoord && _storage.Get(MyStorageDataTypeEnum.Content, ref vtest) == 0)
{
continue;
}
}
// would it touch something dynamic?
if (testDynamic)
{
var box = new BoundingBoxD(worldCoord - 0.25, worldCoord + 0.25);
var bad = false;
foreach (var k in _dynamicEntities)
{
if (k.PositionComp.WorldAABB.Contains(box) == ContainmentType.Disjoint)
{
continue;
}
var obb = new OrientedBoundingBoxD(k.PositionComp.LocalAABB, k.WorldMatrix);
if (!obb.Intersects(ref box))
{
continue;
}
bad = true;
break;
}
if (bad)
{
intersectedDynamic = true;
continue;
}
}
changed = true;
DisableFarming(worldCoord);
availableForDeposit = (uint)(availableForDeposit - toFill);
totalDeposited += (uint)toFill;
_storage.Set(MyStorageDataTypeEnum.Content, ref dataCoord, (byte)(cval + toFill));
if (fillDensity.Value <= cval * 1.25f)
{
continue;
}
var t = -Vector3I.One;
for (var itrContent = new Vector3I_RangeIterator(ref t, ref Vector3I.One);
itrContent.IsValid();
itrContent.MoveNext())
{
var tpos = dataCoord + itrContent.Current;
// var state = _storage.Get(MyStorageDataTypeEnum.Content, ref tpos);
// if (itrContent.Current == Vector3I.Zero || state == 0)
_storage.Set(MyStorageDataTypeEnum.Material, ref tpos, materialToDeposit);
}
}
}
#endregion Mutate
if (changed)
{
voxel.Storage.WriteRange(_storage, MyStorageDataTypeFlags.ContentAndMaterial, voxMin, voxMax);
}
return(changed);
}
finally
{
_dynamicEntities.Clear();
_workingVoxels.Clear();
}
}
private bool CalculateComplete()
{
if (!Definition.RequiredSupport.HasValue)
{
return(true);
}
if (_shapeDirty)
{
CalculateShape();
}
var edge = _bendy.Edges.FirstOrDefault();
var curve = edge?.Curve;
if (curve == null)
{
return(true);
}
var shape = Definition.RequiredSupport.Value;
var sphere = new BoundingSphereD(Vector3D.Transform(_localBox.Center, Entity.PositionComp.WorldMatrix), _localBox.HalfExtents.Length());
var supported = 0;
var total = 0;
var entities = MyEntities.GetTopMostEntitiesInSphere(ref sphere);
using (entities.GetClearToken())
{
var gravity = MyGravityProviderSystem.CalculateTotalGravityInPoint(Entity.GetPosition());
gravity.Normalize();
for (var i = 0; i < shape.Segments; i++)
{
var t = (i + 0.5f) / shape.Segments;
var pos = curve.Sample(t);
pos += gravity;
var aabb = new BoundingBoxD(pos - 0.5f, pos + 0.5f);
var found = false;
foreach (var e in entities)
{
var vox = e as MyVoxelBase;
var grid = e.Components.Get <MyGridDataComponent>();
if (vox != null)
{
Vector3I vc;
var test = pos;
MyVoxelCoordSystems.WorldPositionToVoxelCoord(vox.PositionLeftBottomCorner, ref test, out vc);
_voxelStorage.Resize(Vector3I.One);
vox.Storage.ReadRange(_voxelStorage, MyStorageDataTypeFlags.Content, 0, in vc, in vc);
found |= _voxelStorage.Get(MyStorageDataTypeEnum.Content, ref Vector3I.Zero) > 0;
}
else if (grid != null)
{
found |= grid.AnyBlocksInAABB(aabb);
}
if (found)
{
break;
}
}
if (found)
{
supported++;
}
total++;
}
}
return(supported >= 0.8 * total);
}