// Actually, this function marks even cubes around the block to make sure that any changes caused in their triangles
// will be reflected in the navigation mesh.
public void MarkBlockChanged(MySlimBlock block)
{
Vector3I min = block.Min - Vector3I.One;
Vector3I max = block.Max + Vector3I.One;
Vector3I pos = min;
for (var it = new Vector3I.RangeIterator(ref block.Min, ref block.Max); it.IsValid(); it.GetNext(out pos))
{
m_changedCubes.Add(pos);
}
Vector3I minCell = CubeToCell(ref min);
Vector3I maxCell = CubeToCell(ref max);
pos = minCell;
for (var it = new Vector3I.RangeIterator(ref minCell, ref maxCell); it.IsValid(); it.GetNext(out pos))
{
m_changedCells.Add(pos);
MyCellCoord cellCoord = new MyCellCoord(0, pos);
ulong packedCell = cellCoord.PackId64();
TryClearCell(packedCell);
}
}
internal void InvalidateRange(Vector3I lodMin, Vector3I lodMax)
{
var cell = new MyCellCoord(m_lodIndex, lodMin);
for (var it = new Vector3I.RangeIterator(ref lodMin, ref lodMax);
it.IsValid(); it.GetNext(out cell.CoordInLod))
{
CellData data;
var id = cell.PackId64();
using (m_storedCellDataLock.AcquireSharedUsing())
{
if (m_storedCellData.TryGetValue(id, out data))
{
data.State = CellState.Invalid;
}
}
}
}
// Actually, this function marks even cubes around the block to make sure that any changes caused in their triangles
// will be reflected in the navigation mesh.
public void MarkBlockChanged(MySlimBlock block)
{
Vector3I min = block.Min - Vector3I.One;
Vector3I max = block.Max + Vector3I.One;
Vector3I pos = min;
for (var it = new Vector3I.RangeIterator(ref block.Min, ref block.Max); it.IsValid(); it.GetNext(out pos))
{
m_changedCubes.Add(pos);
}
Vector3I minCell = CubeToCell(ref min);
Vector3I maxCell = CubeToCell(ref max);
pos = minCell;
for (var it = new Vector3I.RangeIterator(ref minCell, ref maxCell); it.IsValid(); it.GetNext(out pos))
{
m_changedCells.Add(pos);
}
}
/// <summary>
/// Writes multiblocks (compound block and block ID) to outMultiBlocks collection with the same multiblockId.
/// </summary>
public static void GetBlocksInMultiBlock(MyCubeGrid grid, Vector3I minPosition, Vector3I maxPosition, MyMultiBlockDefinition multiBlockDefinition, int multiBlockId,
HashSet<Tuple<MySlimBlock, ushort?>> outMultiBlocks)
{
Debug.Assert(multiBlockId != 0);
if (multiBlockId == 0)
return;
Vector3I cube = minPosition;
for (Vector3I.RangeIterator it = new Vector3I.RangeIterator(ref minPosition, ref maxPosition); it.IsValid(); it.GetNext(out cube))
{
MySlimBlock slimBlock = grid.GetCubeBlock(cube);
if (slimBlock == null)
continue;
MyCompoundCubeBlock compound = slimBlock.FatBlock as MyCompoundCubeBlock;
if (compound != null)
{
m_tmpSlimBlocks.Clear();
foreach (var blockInCompound in compound.GetBlocks(m_tmpSlimBlocks))
{
if (blockInCompound.MultiBlockDefinition == multiBlockDefinition && blockInCompound.MultiBlockId == multiBlockId)
{
ushort? blockInCompoundId = compound.GetBlockId(blockInCompound);
outMultiBlocks.Add(new Tuple<MySlimBlock, ushort?>(slimBlock, blockInCompoundId));
}
}
m_tmpSlimBlocks.Clear();
}
else
{
MyFracturedBlock fracturedBlock = slimBlock.FatBlock as MyFracturedBlock;
if (fracturedBlock != null)
{
if (fracturedBlock.IsMultiBlockPart(multiBlockDefinition.Id, multiBlockId))
outMultiBlocks.Add(new Tuple<MySlimBlock, ushort?>(slimBlock, null));
}
else
{
if (slimBlock.MultiBlockDefinition == multiBlockDefinition && slimBlock.MultiBlockId == multiBlockId)
outMultiBlocks.Add(new Tuple<MySlimBlock, ushort?>(slimBlock, null));
}
}
}
}
/// <param name="minVoxelChanged">Inclusive min.</param>
/// <param name="maxVoxelChanged">Inclusive max.</param>
internal void InvalidateRange(Vector3I minVoxelChanged, Vector3I maxVoxelChanged)
{
MyPrecalcComponent.AssertUpdateThread();
ProfilerShort.Begin("MyVoxelPhysicsBody.InvalidateRange");
minVoxelChanged -= MyPrecalcComponent.InvalidatedRangeInflate;
maxVoxelChanged += MyPrecalcComponent.InvalidatedRangeInflate;
m_voxelMap.Storage.ClampVoxelCoord(ref minVoxelChanged);
m_voxelMap.Storage.ClampVoxelCoord(ref maxVoxelChanged);
Vector3I minCellChanged, maxCellChanged;
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref minVoxelChanged, out minCellChanged);
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref maxVoxelChanged, out maxCellChanged);
Vector3I minCellChangedVoxelMap, maxCellChangedVoxelMap;
minCellChangedVoxelMap = minCellChanged - m_cellsOffset;
maxCellChangedVoxelMap = maxCellChanged - m_cellsOffset;
Debug.Assert(RigidBody != null, "RigidBody in voxel physics is null! This must not happen.");
if (RigidBody != null)
{
var shape = (HkUniformGridShape)RigidBody.GetShape();
var tmpBuffer = m_cellsToGenerateBuffer;
int invalidCount = shape.InvalidateRange(ref minCellChangedVoxelMap, ref maxCellChangedVoxelMap, tmpBuffer);
if (invalidCount > tmpBuffer.Length)
{
// Not storing this new buffer in static variable since this is just temporary and potentially large.
// Static variable could be potentially the same as leak.
tmpBuffer = new Vector3I[invalidCount];
int invalidCount2 = shape.InvalidateRange(ref minCellChangedVoxelMap, ref maxCellChangedVoxelMap, tmpBuffer);
Debug.Assert(invalidCount == invalidCount2);
invalidCount = invalidCount2;
}
Debug.Assert(invalidCount <= tmpBuffer.Length);
for (int i = 0; i < invalidCount; i++)
{
InvalidCells.Add(tmpBuffer[i]);
}
if (RunningBatchTask != null)
{
RunningBatchTask.Cancel();
foreach (var oldInvalidCell in RunningBatchTask.CellBatch)
{
InvalidCells.Add(oldInvalidCell);
}
RunningBatchTask = null;
}
if (InvalidCells.Count != 0)
MyPrecalcComponent.PhysicsWithInvalidCells.Add(this);
}
var cell = minCellChanged;
for (var it = new Vector3I.RangeIterator(ref minCellChanged, ref maxCellChanged);
it.IsValid(); it.GetNext(out cell))
{
m_workTracker.Cancel(cell);
}
m_needsShapeUpdate = true;
ProfilerShort.End();
}
public void Submit()
{
ProfilerShort.Begin("RequestCollector.Submit");
MyCellCoord cell = default(MyCellCoord);
foreach (var cellId in m_cancelRequests)
{
cell.SetUnpack(cellId);
MyRenderProxy.CancelClipmapCell(m_clipmapId, cell);
bool removed = m_sentRequests.Remove(cellId);
Debug.Assert(removed);
}
foreach (var highPriorityRequest in m_unsentRequestsHigh)
{
cell.SetUnpack(highPriorityRequest);
MyRenderProxy.RequireClipmapCell(m_clipmapId, cell, highPriority: true);
}
m_unsentRequestsHigh.Clear();
int addedCount = 0;
for (int i = m_unsentRequestsLow.Length - 1; i >= 0; i--)
{
var unsent = m_unsentRequestsLow[i];
while (0 < unsent.Count && m_sentRequests.Count < m_maxRequests)
{
var cellId = unsent.FirstElement();
cell.SetUnpack(cellId);
// Do Z-order style iteration of siblings that also need to
// be requested. This ensures faster processing of cells and
// shorter time when both lods are rendered.
var baseCoord = (cell.CoordInLod >> 1) << 1;
var offset = Vector3I.Zero;
for (var it = new Vector3I.RangeIterator(ref Vector3I.Zero, ref Vector3I.One);
it.IsValid(); it.GetNext(out offset))
{
cell.CoordInLod = baseCoord + offset;
cellId = cell.PackId64();
if (!unsent.Remove(cellId))
{
continue;
}
Debug.Assert(!m_cancelRequests.Contains(cellId));
MyRenderProxy.RequireClipmapCell(m_clipmapId, cell, highPriority: false);
bool added = m_sentRequests.Add(cellId);
Debug.Assert(added);
addedCount++;
}
}
// When set reaches reasonably small size, stop freeing memory
if (unsent.Count > 100)
unsent.TrimExcess();
}
m_cancelRequests.Clear();
ProfilerShort.End();
}
private void FixCacheMaterial(Vector3I voxelStart, Vector3I voxelEnd)
{
var mcount = Sandbox.Definitions.MyDefinitionManager.Static.VoxelMaterialCount;
voxelEnd = Vector3I.Min(voxelEnd - voxelStart, m_cache.Size3D);
voxelStart = Vector3I.Zero;
var it = new Vector3I.RangeIterator(ref voxelStart, ref voxelEnd);
var pos = it.Current;
for(;it.IsValid();it.GetNext(out pos))
{
var lin = m_cache.ComputeLinear(ref pos);
if (m_cache.Material(lin) >= mcount)
m_cache.Material(lin, 0);
}
}
public void TestVoxelNavmeshTriangle(ref Vector3D a, ref Vector3D b, ref Vector3D c, List<MyCubeGrid> gridsToTest, List<MyGridPathfinding.CubeId> linkCandidatesOutput, out bool intersecting)
{
ProfilerShort.Begin("TestVoxelNavmeshTriangle");
ProfilerShort.Begin("Triangle-obstacle tests");
Vector3D s = (a + b + c) / 3.0;
if (m_obstacles.IsInObstacle(s))
{
intersecting = true;
ProfilerShort.End();
ProfilerShort.End();
return;
}
ProfilerShort.End();
BoundingBoxD triBB;
Vector3D aLocal, bLocal, cLocal, gLocal;
Vector3D g = Vector3D.Zero;
if (MyPerGameSettings.NavmeshPresumesDownwardGravity)
{
g = Vector3.Down * 2.0f;
}
m_tmpLinkCandidates.Clear();
intersecting = false;
foreach (var grid in gridsToTest)
{
MatrixD mat = grid.PositionComp.WorldMatrixNormalizedInv;
Vector3D.Transform(ref a, ref mat, out aLocal);
Vector3D.Transform(ref b, ref mat, out bLocal);
Vector3D.Transform(ref c, ref mat, out cLocal);
Vector3D.TransformNormal(ref g, ref mat, out gLocal);
triBB = new BoundingBoxD(Vector3D.MaxValue, Vector3D.MinValue);
triBB.Include(ref aLocal, ref bLocal, ref cLocal);
Vector3I min = grid.LocalToGridInteger(triBB.Min);
Vector3I max = grid.LocalToGridInteger(triBB.Max);
Vector3I pos = min - Vector3I.One;
Vector3I max2 = max + Vector3I.One;
for (var it = new Vector3I.RangeIterator(ref pos, ref max2); it.IsValid(); it.GetNext(out pos))
{
if (grid.GetCubeBlock(pos) != null)
{
Vector3 largeMin = (pos - Vector3.One) * grid.GridSize;
Vector3 largeMax = (pos + Vector3.One) * grid.GridSize;
Vector3 smallMin = (pos - Vector3.Half) * grid.GridSize;
Vector3 smallMax = (pos + Vector3.Half) * grid.GridSize;
BoundingBoxD largeBb = new BoundingBoxD(largeMin, largeMax);
BoundingBoxD bb = new BoundingBoxD(smallMin, smallMax);
largeBb.Include(largeMin + gLocal);
largeBb.Include(largeMax + gLocal);
bb.Include(smallMin + gLocal);
bb.Include(smallMax + gLocal);
ProfilerShort.Begin("Triangle intersection tests");
if (largeBb.IntersectsTriangle(ref aLocal, ref bLocal, ref cLocal))
{
if (bb.IntersectsTriangle(ref aLocal, ref bLocal, ref cLocal))
{
intersecting = true;
ProfilerShort.End();
break;
}
else
{
int dx = Math.Min(Math.Abs(min.X - pos.X), Math.Abs(max.X - pos.X));
int dy = Math.Min(Math.Abs(min.Y - pos.Y), Math.Abs(max.Y - pos.Y));
int dz = Math.Min(Math.Abs(min.Z - pos.Z), Math.Abs(max.Z - pos.Z));
if ((dx + dy + dz) < 3)
m_tmpLinkCandidates.Add(new MyGridPathfinding.CubeId() { Grid = grid, Coords = pos });
}
}
ProfilerShort.End();
}
}
if (intersecting) break;
}
if (!intersecting)
{
for (int i = 0; i < m_tmpLinkCandidates.Count; ++i)
{
linkCandidatesOutput.Add(m_tmpLinkCandidates[i]);
}
}
m_tmpLinkCandidates.Clear();
ProfilerShort.End();
}
internal void InvalidateRange(Vector3I minVoxelChanged, Vector3I maxVoxelChanged, int lod)
{
MyPrecalcComponent.AssertUpdateThread();
// No physics there ever was so we don't care.
if (!m_bodiesInitialized) return;
if (m_queueInvalidation)
{
if (m_queuedRange.Max.X < 0)
{
m_queuedRange = new BoundingBoxI(minVoxelChanged, maxVoxelChanged);
}
else
{
var bb = new BoundingBoxI(minVoxelChanged, maxVoxelChanged);
m_queuedRange.Include(ref bb);
}
return;
}
ProfilerShort.Begin("MyVoxelPhysicsBody.InvalidateRange");
minVoxelChanged -= MyPrecalcComponent.InvalidatedRangeInflate;
maxVoxelChanged += MyPrecalcComponent.InvalidatedRangeInflate;
m_voxelMap.Storage.ClampVoxelCoord(ref minVoxelChanged);
m_voxelMap.Storage.ClampVoxelCoord(ref maxVoxelChanged);
Vector3I minCellChanged, maxCellChanged;
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref minVoxelChanged, out minCellChanged);
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref maxVoxelChanged, out maxCellChanged);
Vector3I minCellChangedVoxelMap, maxCellChangedVoxelMap;
minCellChangedVoxelMap = (minCellChanged - m_cellsOffset) >> lod;
maxCellChangedVoxelMap = (maxCellChanged - m_cellsOffset) >> lod;
var maxCell = m_voxelMap.Size - 1;
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref maxCell, out maxCell);
maxCell >>= lod;
Vector3I.Min(ref maxCellChangedVoxelMap, ref maxCell, out maxCellChangedVoxelMap);
Debug.Assert(RigidBody != null, "RigidBody in voxel physics is null! This must not happen.");
var rb = GetRigidBody(lod);
Debug.Assert(rb != null, "RigidBody in voxel physics is null! This must not happen.");
if (rb != null)
{
HkUniformGridShape shape = (HkUniformGridShape) rb.GetShape();
Debug.Assert(shape.Base.IsValid);
var tmpBuffer = m_cellsToGenerateBuffer;
int invalidCount = shape.InvalidateRange(ref minCellChangedVoxelMap, ref maxCellChangedVoxelMap, tmpBuffer);
if (invalidCount > tmpBuffer.Length)
{
// Not storing this new buffer in static variable since this is just temporary and potentially large.
// Static variable could be potentially the same as leak.
tmpBuffer = new Vector3I[invalidCount];
int invalidCount2 = shape.InvalidateRange(ref minCellChangedVoxelMap, ref maxCellChangedVoxelMap, tmpBuffer);
Debug.Assert(invalidCount == invalidCount2);
invalidCount = invalidCount2;
}
shape.InvalidateRangeImmediate(ref minCellChangedVoxelMap, ref maxCellChangedVoxelMap);
Debug.Assert(invalidCount <= tmpBuffer.Length);
for (int i = 0; i < invalidCount; i++)
{
InvalidCells.Add(tmpBuffer[i]);
}
if (RunningBatchTask == null && InvalidCells.Count != 0)
{
MyPrecalcComponent.PhysicsWithInvalidCells.Add(this);
}
}
if (minCellChangedVoxelMap == Vector3I.Zero && maxCellChangedVoxelMap == maxCell)
{
m_workTracker.CancelAll();
}
else
{
var cell = minCellChanged;
for (var it = new Vector3I.RangeIterator(ref minCellChanged, ref maxCellChanged);
it.IsValid(); it.GetNext(out cell))
{
m_workTracker.Cancel(new MyCellCoord(lod, cell));
}
}
m_needsShapeUpdate = true;
ProfilerShort.End();
m_voxelMap.RaisePhysicsChanged();
}
// Precalculate voxel cell into cache (makes triangles and vertex buffer from voxels)
public void Precalc(MyVoxelPrecalcTaskItem task)
{
Profiler.Begin("MyVoxelPrecalcTask.Precalc");
m_precalcType = task.Type;
m_resultVerticesCounter = 0;
m_resultTrianglesCounter = 0;
m_edgeVertexCalcCounter++;
m_voxelMap = task.VoxelMap;
m_voxelStart = task.VoxelStart;
int lodIdx = MyVoxelGeometry.GetLodIndex(m_precalcType);
CalcPolygCubeSize(lodIdx);
// Copy voxels into temp array
//using (Stats.Timing.Measure("NewPrecalc.CopyVoxelContents", MyStatTypeEnum.Sum, clearRateMs: TIMEOUT))
Profiler.Begin("NewPrecalc.CopyVoxelContents");
bool isMixed = CopyVoxelContents() == MyVoxelRangeType.MIXED;
Profiler.End();
//using (Stats.Timing.Measure("Precalc.Geometry generation", MyStatTypeEnum.Sum, clearRateMs: TIMEOUT))
Profiler.Begin("Precalc.Geometry generation");
{
if (isMixed)
{
var cache = ThreadLocalCache;
// Size of voxel or cell (in meters) and size of voxel map / voxel cells
ComputeSizeAndOrigin(lodIdx);
var start = Vector3I.One;
var end = m_polygCubes - 1;
Vector3I coord0 = start;
for (var it = new Vector3I.RangeIterator(ref start, ref end); it.IsValid(); it.GetNext(out coord0))
{
// We can get this voxel content right from cache (not using GetVoxelContent method), because after CopyVoxelContents these array must be filled. But only content, not material, normal, etc.
int cubeIndex = 0;
if (cache.Content(coord0.X + 0, coord0.Y + 0, coord0.Z + 0) < MyVoxelConstants.VOXEL_ISO_LEVEL) cubeIndex |= 1;
if (cache.Content(coord0.X + 1, coord0.Y + 0, coord0.Z + 0) < MyVoxelConstants.VOXEL_ISO_LEVEL) cubeIndex |= 2;
if (cache.Content(coord0.X + 1, coord0.Y + 0, coord0.Z + 1) < MyVoxelConstants.VOXEL_ISO_LEVEL) cubeIndex |= 4;
if (cache.Content(coord0.X + 0, coord0.Y + 0, coord0.Z + 1) < MyVoxelConstants.VOXEL_ISO_LEVEL) cubeIndex |= 8;
if (cache.Content(coord0.X + 0, coord0.Y + 1, coord0.Z + 0) < MyVoxelConstants.VOXEL_ISO_LEVEL) cubeIndex |= 16;
if (cache.Content(coord0.X + 1, coord0.Y + 1, coord0.Z + 0) < MyVoxelConstants.VOXEL_ISO_LEVEL) cubeIndex |= 32;
if (cache.Content(coord0.X + 1, coord0.Y + 1, coord0.Z + 1) < MyVoxelConstants.VOXEL_ISO_LEVEL) cubeIndex |= 64;
if (cache.Content(coord0.X + 0, coord0.Y + 1, coord0.Z + 1) < MyVoxelConstants.VOXEL_ISO_LEVEL) cubeIndex |= 128;
// Cube is entirely in/out of the surface
if (MyMarchingCubesConstants.EdgeTable[cubeIndex] == 0)
{
continue;
}
// We can get this voxel content right from cache (not using GetVoxelContent method), because after CopyVoxelContents these array must be filled. But only content, not material, normal, etc.
Vector3I tempVoxelCoord0 = ComputeTemporaryVoxelData(cache, ref coord0, cubeIndex);
// Create the triangles
CreateTriangles(ref coord0, cubeIndex, ref tempVoxelCoord0);
}
}
}
Profiler.End();
//using (Stats.Timing.Measure("Precalc.PrepareCache", MyStatTypeEnum.Sum, clearRateMs: TIMEOUT))
Profiler.Begin("Precalc.PrepareCache");
{
// Cache the vertices and triangles and precalculate the octree
task.Cache.PrepareCache(m_resultVertices, m_resultVerticesCounter, m_resultTriangles, m_resultTrianglesCounter, m_positionScale, m_originPosition, task.Type == MyLodTypeEnum.LOD0);
}
Profiler.End();
Profiler.End();
}
public void DebugDraw()
{
if (m_lodIndex > 5)
{
return;
}
if (m_lodIndex == 1)
{
float sizeInMetres = MyVoxelCoordSystems.RenderCellSizeInMeters(m_lodIndex);
//var start = localFarCameraBox.Min;
//var end = localFarCameraBox.Max;
var start = m_localNearCameraBox.Min;
var end = m_localNearCameraBox.Max;
Vector3I coord = start;
Color nearColor = Color.Yellow;
Color farColor = Color.White;
var startF = m_localFarCameraBox.Min;
var endF = m_localFarCameraBox.Max;
Vector3I coordF = startF;
// for (var it = new Vector3I.RangeIterator(ref startF, ref endF);
//it.IsValid(); it.GetNext(out coordF))
// {
// Vector3D min = Vector3D.Transform((Vector3D)(sizeInMetres * coordF), m_parent.m_worldMatrix);
// Vector3D max = Vector3D.Transform((Vector3D)(sizeInMetres * coordF + new Vector3(sizeInMetres)), m_parent.m_worldMatrix);
// BoundingBoxD aabb = new BoundingBoxD(min, max);
// MyRenderProxy.DebugDrawAABB(aabb, farColor, 1, 1, false);
// if (Vector3D.Distance(CameraFrustumGetter().Matrix.Translation, aabb.Center) < 200)
// MyRenderProxy.DebugDrawText3D(aabb.Center, coordF.ToString(), farColor, 0.5f, false);
// }
for (var it = new Vector3I.RangeIterator(ref start, ref end);
it.IsValid(); it.GetNext(out coord))
{
Vector3D min = Vector3D.Transform((Vector3D)(sizeInMetres * coord), m_clipmap.m_worldMatrix);
Vector3D max = Vector3D.Transform((Vector3D)(sizeInMetres * coord + new Vector3(sizeInMetres)), m_clipmap.m_worldMatrix);
BoundingBoxD aabb = new BoundingBoxD(min, max);
MyRenderProxy.DebugDrawAABB(aabb, nearColor, 1, 1, false);
}
Vector3D center = Vector3D.Transform(m_localPosition, m_clipmap.m_worldMatrix);
MyRenderProxy.DebugDrawSphere(center, m_nearDistance, nearColor, 1, false);
MyRenderProxy.DebugDrawSphere(center, m_farDistance, farColor, 1, false);
}
//if (m_lodIndex == 1)
{
float sizeInMetres = MyVoxelCoordSystems.RenderCellSizeInMeters(m_lodIndex);
Color color = LOD_COLORS[m_lodIndex] + new Vector4(0.2f);
foreach (var cell in m_storedCellData)
{
if (!cell.Value.InScene)
{
continue;
}
MyCellCoord cellStr = new MyCellCoord();
cellStr.SetUnpack(cell.Key);
var coordF = cellStr.CoordInLod;
Vector3D min = Vector3D.Transform((Vector3D)(sizeInMetres * coordF), m_clipmap.m_worldMatrix);
Vector3D max = Vector3D.Transform((Vector3D)(sizeInMetres * coordF + new Vector3(sizeInMetres)), m_clipmap.m_worldMatrix);
BoundingBoxD aabb = new BoundingBoxD(min, max);
MyRenderProxy.DebugDrawAABB(aabb, color, 1, 1, false);
if (Vector3D.Distance(CameraFrustumGetter().Matrix.Translation, aabb.Center) < 200)
{
MyRenderProxy.DebugDrawText3D(aabb.Center, coordF.ToString(), color, 0.5f, false);
}
}
if (m_storedCellData.Count > 0)
{
Vector3D center = Vector3D.Transform(m_localPosition, m_clipmap.m_worldMatrix);
//MyRenderProxy.DebugDrawSphere(center, m_farDistance, color, 1, false);
}
}
}
/// <summary>
/// Recursive clipping function requests cells in provided range and
/// cells needed from parent to wrap the lod safely
/// </summary>
/// <param name="collector"></param>
/// <param name="it0">requested range</param>
/// <param name="ignore">inner range filled by children</param>
private void DoClipping(RequestCollector collector, Vector3I min, Vector3I max, ref BoundingBox ignore)
{
LodLevel parentLod, clevel;
GetNearbyLodLevels(out parentLod, out clevel);
MyCellCoord cell = new MyCellCoord(m_lodIndex, Vector3I.Zero);
//if (collector.SentRequestsEmpty)
{
MyUtils.Swap(ref m_storedCellData, ref m_clippedCells);
m_storedCellData.Clear();
}
var it0 = new Vector3I.RangeIterator(ref min, ref max);
cell.CoordInLod = it0.Current;
var shiftToParent = MyVoxelCoordSystems.RenderCellSizeShiftToLessDetailed(cell.Lod);
var parentCell = parentLod != null ? new MyCellCoord(parentLod.m_lodIndex, cell.CoordInLod >> shiftToParent) : cell;
var parentIgnore = new BoundingBox(parentCell.CoordInLod, parentCell.CoordInLod);
BoundingBox bb = new BoundingBox(cell.CoordInLod, cell.CoordInLod);
for (; it0.IsValid(); it0.GetNext(out cell.CoordInLod)) //cells to be loaded
{
if (ignore.Contains((Vector3)cell.CoordInLod) == ContainmentType.Contains)
{
continue; //lower lod requested
}
if (parentLod != null) //get also their lodcell mates
{
parentCell = new MyCellCoord(parentLod.m_lodIndex, cell.CoordInLod >> shiftToParent);
var it = GetChildrenCoords(this, ref parentCell);
bb.Include(it);
parentIgnore.Max = parentCell.CoordInLod;
}
}
if (parentLod != null)
{
Vector3I parentMinI = Vector3I.Round(parentIgnore.Min - Vector3.One);
Vector3I parentMaxI = Vector3I.Round(parentIgnore.Max + Vector3.One);
//Vector3I.Clamp(ref parentMinI, ref Vector3I.Zero, ref m_lodSizeMinusOne, out parentMinI);
//Vector3I.Clamp(ref parentMaxI, ref Vector3I.Zero, ref m_lodSizeMinusOne, out parentMaxI);
var parentIterator = new Vector3I.RangeIterator(ref parentMinI, ref parentMaxI);
parentLod.DoClipping(collector, parentMinI, parentMaxI, ref parentIgnore);
}
Vector3I start, end;
start = Vector3I.Round(bb.Min); end = Vector3I.Round(bb.Max);
Vector3I.Clamp(ref start, ref Vector3I.Zero, ref m_lodSizeMinusOne, out start);
Vector3I.Clamp(ref end, ref Vector3I.Zero, ref m_lodSizeMinusOne, out end);
it0 = new Vector3I.RangeIterator(ref start, ref end);
cell.CoordInLod = it0.Current;
for (; it0.IsValid(); it0.GetNext(out cell.CoordInLod)) //cells to be loaded
{
if (ignore.Contains((Vector3)cell.CoordInLod) == ContainmentType.Contains)
{
continue; //lower lod requested
}
var cellId = cell.PackId64();
CellData data;
if (m_clippedCells.TryGetValue(cellId, out data))
{
m_clippedCells.Remove(cellId);
}
else
{
var clipmapCellId = MyCellCoord.GetClipmapCellHash(m_clipmap.Id, cellId);
data = CellsCache.Read(clipmapCellId);
if (data == null) //cache miss
{
data = new CellData();
ClippingCacheMisses++;
}
else
{
//cache hit
ClippingCacheHits++;
data.InScene = false;
if (data.Cell != null)
{
m_nonEmptyCells[cellId] = data;
}
}
}
if (data.State == CellState.Invalid)
{
if (!TryAddCellRequest(collector, parentLod, cell, cellId, data))
{
continue;
}
}
if (!m_storedCellData.ContainsKey(cellId))
{
m_storedCellData.Add(cellId, data);
}
}
}
/// <summary>
/// Whether connection is allowed to any of the positions between otherBlockMinPos and otherBlockMaxPos (both inclusive).
/// Default implementation calls ConnectionAllowed(ref Vector3I otherBlockPos, ref Vector3I faceNormal) in a for loop.
/// Override this in a subclass if this is not needed (for example, because all calls would return the same value for the same face)
/// </summary>
public virtual bool ConnectionAllowed(ref Vector3I otherBlockMinPos, ref Vector3I otherBlockMaxPos, ref Vector3I faceNormal, MyCubeBlockDefinition def)
{
Vector3I pos = otherBlockMinPos;
for (Vector3I.RangeIterator it = new Vector3I.RangeIterator(ref otherBlockMinPos, ref otherBlockMaxPos); it.IsValid(); it.GetNext(out pos))
{
if (ConnectionAllowed(ref pos, ref faceNormal, def))
{
return(true);
}
}
return(false);
}
internal void InvalidateRange(Vector3I minVoxelChanged, Vector3I maxVoxelChanged, int lod)
{
MyPrecalcComponent.AssertUpdateThread();
// No physics there ever was so we don't care.
if (!m_bodiesInitialized)
{
return;
}
if (m_queueInvalidation)
{
if (m_queuedRange.Max.X < 0)
{
m_queuedRange = new BoundingBoxI(minVoxelChanged, maxVoxelChanged);
}
else
{
var bb = new BoundingBoxI(minVoxelChanged, maxVoxelChanged);
m_queuedRange.Include(ref bb);
}
return;
}
ProfilerShort.Begin("MyVoxelPhysicsBody.InvalidateRange");
minVoxelChanged -= 1; // MyPrecalcComponent.InvalidatedRangeInflate;
maxVoxelChanged += 1; //MyPrecalcComponent.InvalidatedRangeInflate;
m_voxelMap.Storage.ClampVoxelCoord(ref minVoxelChanged);
m_voxelMap.Storage.ClampVoxelCoord(ref maxVoxelChanged);
Vector3I minCellChanged, maxCellChanged;
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref minVoxelChanged, out minCellChanged);
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref maxVoxelChanged, out maxCellChanged);
Vector3I minCellChangedVoxelMap, maxCellChangedVoxelMap;
minCellChangedVoxelMap = (minCellChanged - m_cellsOffset) >> lod;
maxCellChangedVoxelMap = (maxCellChanged - m_cellsOffset) >> lod;
var maxCell = m_voxelMap.Size - 1;
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref maxCell, out maxCell);
maxCell >>= lod;
Vector3I.Min(ref maxCellChangedVoxelMap, ref maxCell, out maxCellChangedVoxelMap);
Debug.Assert(RigidBody != null, "RigidBody in voxel physics is null! This must not happen.");
var rb = GetRigidBody(lod);
Debug.Assert(rb != null, "RigidBody in voxel physics is null! This must not happen.");
if (rb != null)
{
HkUniformGridShape shape = (HkUniformGridShape)rb.GetShape();
Debug.Assert(shape.Base.IsValid);
var numCells = (maxCellChangedVoxelMap - minCellChangedVoxelMap + 1).Size;
if (numCells >= m_cellsToGenerateBuffer.Length)
{
m_cellsToGenerateBuffer = new Vector3I[MathHelper.GetNearestBiggerPowerOfTwo(numCells)];
}
var tmpBuffer = m_cellsToGenerateBuffer;
int invalidCount = shape.InvalidateRange(ref minCellChangedVoxelMap, ref maxCellChangedVoxelMap, tmpBuffer);
Debug.Assert(invalidCount <= tmpBuffer.Length);
//if (numCells <= 8)
//shape.InvalidateRangeImmediate(ref minCellChangedVoxelMap, ref maxCellChangedVoxelMap);
Debug.Assert(invalidCount <= tmpBuffer.Length);
for (int i = 0; i < invalidCount; i++)
{
InvalidCells[lod].Add(tmpBuffer[i]);
}
if (RunningBatchTask[lod] == null && InvalidCells[lod].Count != 0)
{
MyPrecalcComponent.PhysicsWithInvalidCells.Add(this);
}
}
if (minCellChangedVoxelMap == Vector3I.Zero && maxCellChangedVoxelMap == maxCell)
{
m_workTracker.CancelAll();
}
else
{
var cell = minCellChanged;
for (var it = new Vector3I.RangeIterator(ref minCellChanged, ref maxCellChanged);
it.IsValid(); it.GetNext(out cell))
{
m_workTracker.Cancel(new MyCellCoord(lod, cell));
}
}
m_needsShapeUpdate = true;
ProfilerShort.End();
m_voxelMap.RaisePhysicsChanged();
}
public void Submit()
{
ProfilerShort.Begin("RequestCollector.Submit");
MyCellCoord cell = default(MyCellCoord);
foreach (var cellId in m_cancelRequests)
{
cell.SetUnpack(cellId);
MyRenderProxy.CancelClipmapCell(m_clipmapId, cell);
bool removed = m_sentRequests.Remove(cellId);
Debug.Assert(removed);
}
foreach (var request in m_unsentRequests)
{
m_sentRequests.Add(request.Key);
cell.SetUnpack(request.Key);
MyRenderProxy.RequireClipmapCell(m_clipmapId, cell, true, request.Value.PriorityFunc, request.Value.DebugDraw);
}
m_unsentRequests.Clear();
//foreach (var highPriorityRequest in m_unsentRequestsHigh)
//{
// cell.SetUnpack(highPriorityRequest);
// MyRenderProxy.RequireClipmapCell(m_clipmapId, cell, highPriority: true);
//}
//m_unsentRequestsHigh.Clear();
int addedCount = 0;
for (int i = m_unsentRequestsLow.Length - 1; i >= 0; i--)
{
var unsent = m_unsentRequestsLow[i];
while (0 < unsent.Count)// && m_sentRequests.Count < m_maxRequests*1000)
{
var pair = unsent.FirstPair();
var cellId = pair.Key;
var hs = new HashSet <object>();
cell.SetUnpack(cellId);
// Do Z-order style iteration of siblings that also need to
// be requested. This ensures faster processing of cells and
// shorter time when both lods are rendered.
var baseCoord = (cell.CoordInLod >> 1) << 1;
var offset = Vector3I.Zero;
for (var it = new Vector3I.RangeIterator(ref Vector3I.Zero, ref Vector3I.One);
it.IsValid(); it.GetNext(out offset))
{
cell.CoordInLod = baseCoord + offset;
cellId = cell.PackId64();
if (!unsent.Remove(cellId))
{
continue;
}
Debug.Assert(!m_cancelRequests.Contains(cellId));
MyRenderProxy.RequireClipmapCell(m_clipmapId, cell, false, pair.Value.PriorityFunc, pair.Value.DebugDraw);
bool added = m_sentRequests.Add(cellId);
Debug.Assert(added);
addedCount++;
}
}
// When set reaches reasonably small size, stop freeing memory
//if (unsent.Count > 100) no trim for dictionary :(
// unsent.TrimExcess();
}
m_cancelRequests.Clear();
ProfilerShort.End();
}
public void TestVoxelNavmeshTriangle(ref Vector3D a, ref Vector3D b, ref Vector3D c, List <MyCubeGrid> gridsToTest, List <MyGridPathfinding.CubeId> linkCandidatesOutput, out bool intersecting)
{
ProfilerShort.Begin("TestVoxelNavmeshTriangle");
BoundingBoxD triBB;
Vector3D aLocal, bLocal, cLocal, gLocal;
Vector3D g = Vector3D.Zero;
if (MyFakes.NAVMESH_PRESUMES_DOWNWARD_GRAVITY)
{
g = Vector3.Down * 2.0f;
}
m_tmpLinkCandidates.Clear();
intersecting = false;
foreach (var grid in gridsToTest)
{
MatrixD mat = grid.PositionComp.WorldMatrixNormalizedInv;
Vector3D.Transform(ref a, ref mat, out aLocal);
Vector3D.Transform(ref b, ref mat, out bLocal);
Vector3D.Transform(ref c, ref mat, out cLocal);
Vector3D.TransformNormal(ref g, ref mat, out gLocal);
triBB = new BoundingBoxD(Vector3D.MaxValue, Vector3D.MinValue);
triBB.Include(ref aLocal, ref bLocal, ref cLocal);
Vector3I min = grid.LocalToGridInteger(triBB.Min);
Vector3I max = grid.LocalToGridInteger(triBB.Max);
Vector3I pos = min - Vector3I.One;
Vector3I max2 = max + Vector3I.One;
for (var it = new Vector3I.RangeIterator(ref pos, ref max2); it.IsValid(); it.GetNext(out pos))
{
if (grid.GetCubeBlock(pos) != null)
{
Vector3 largeMin = (pos - Vector3.One) * grid.GridSize;
Vector3 largeMax = (pos + Vector3.One) * grid.GridSize;
Vector3 smallMin = (pos - Vector3.Half) * grid.GridSize;
Vector3 smallMax = (pos + Vector3.Half) * grid.GridSize;
BoundingBoxD largeBb = new BoundingBoxD(largeMin, largeMax);
BoundingBoxD bb = new BoundingBoxD(smallMin, smallMax);
largeBb.Include(largeMin + gLocal);
largeBb.Include(largeMax + gLocal);
bb.Include(smallMin + gLocal);
bb.Include(smallMax + gLocal);
ProfilerShort.Begin("Triangle intersection tests");
if (largeBb.IntersectsTriangle(ref aLocal, ref bLocal, ref cLocal))
{
if (bb.IntersectsTriangle(ref aLocal, ref bLocal, ref cLocal))
{
intersecting = true;
ProfilerShort.End();
break;
}
else
{
int dx = Math.Min(Math.Abs(min.X - pos.X), Math.Abs(max.X - pos.X));
int dy = Math.Min(Math.Abs(min.Y - pos.Y), Math.Abs(max.Y - pos.Y));
int dz = Math.Min(Math.Abs(min.Z - pos.Z), Math.Abs(max.Z - pos.Z));
if ((dx + dy + dz) < 3)
{
m_tmpLinkCandidates.Add(new MyGridPathfinding.CubeId()
{
Grid = grid, Coords = pos
});
}
}
}
ProfilerShort.End();
}
}
if (intersecting)
{
break;
}
}
if (!intersecting)
{
for (int i = 0; i < m_tmpLinkCandidates.Count; ++i)
{
linkCandidatesOutput.Add(m_tmpLinkCandidates[i]);
}
}
m_tmpLinkCandidates.Clear();
ProfilerShort.End();
}
internal void DoClipping(Vector3D localPosition, float farPlaneDistance, RequestCollector collector)
{
MyClipmap.ComputeLodViewBounds(m_parent.m_scaleGroup, m_lodIndex, out m_nearDistance, out m_farDistance);
m_fitsInFrustum = (farPlaneDistance * 1.25f) > m_nearDistance;
if (!m_fitsInFrustum)
return;
Vector3I min, max;
{
var minD = localPosition - m_farDistance;
var maxD = localPosition + m_farDistance;
MyVoxelCoordSystems.LocalPositionToRenderCellCoord(ref minD, out min);
MyVoxelCoordSystems.LocalPositionToRenderCellCoord(ref maxD, out max);
Vector3I.Max(ref min, ref Vector3I.Zero, out min);
Vector3I.Max(ref max, ref Vector3I.Zero, out max);
min >>= m_lodIndex;
max >>= m_lodIndex;
Vector3I.Min(ref min, ref m_lodSizeMinusOne, out min);
Vector3I.Min(ref max, ref m_lodSizeMinusOne, out max);
}
if (m_lastMin == min && m_lastMax == max && !m_parent.m_updateClipping)
return;
m_lastMin = min;
m_lastMax = max;
LodLevel parentLod, childLod;
GetNearbyLodLevels(out parentLod, out childLod);
// Moves cells which are still needed from one collection to another.
// All that is left behind is unloaded as no longer needed.
// Move everything in range to collection of next stored cells.
MyUtils.Swap(ref m_storedCellData, ref m_clippedCells);
m_storedCellData.Clear();
MyCellCoord cell = new MyCellCoord(m_lodIndex, ref min);
for (var it = new Vector3I.RangeIterator(ref min, ref max);
it.IsValid(); it.GetNext(out cell.CoordInLod))
{
if (!WasAncestorCellLoaded(parentLod, ref cell))
continue;
var cellId = cell.PackId64();
CellData data;
if (m_clippedCells.TryGetValue(cellId, out data))
m_clippedCells.Remove(cellId);
else
data = new CellData();
if (data.State == CellState.Invalid)
{
collector.AddRequest(cellId, data.WasLoaded);
data.State = CellState.Pending;
}
m_storedCellData.Add(cellId, data);
}
}
private static void WriteRange(
ref WriteRangeArgs args,
byte defaultData,
int lodIdx,
Vector3I lodCoord,
ref Vector3I min,
ref Vector3I max)
{
MyOctreeNode node = new MyOctreeNode();
{
MyCellCoord leaf = new MyCellCoord(lodIdx - LeafLodCount, ref lodCoord);
var leafKey = leaf.PackId64();
if (args.Leaves.ContainsKey(leafKey))
{
args.Leaves.Remove(leafKey);
var childBase = lodCoord << 1;
Vector3I childOffset;
MyCellCoord child = new MyCellCoord();
child.Lod = leaf.Lod - 1;
var leafSize = LeafSizeInVoxels << child.Lod;
for (int i = 0; i < MyOctreeNode.CHILD_COUNT; ++i)
{
ComputeChildCoord(i, out childOffset);
child.CoordInLod = childBase + childOffset;
var childCopy = child;
childCopy.Lod += LeafLodCount;
IMyOctreeLeafNode octreeLeaf = new MyProviderLeaf(args.Provider, args.DataType, ref childCopy);
args.Leaves.Add(child.PackId64(), octreeLeaf);
node.SetChild(i, true);
node.SetData(i, octreeLeaf.GetFilteredValue());
}
}
else
{
leaf.Lod -= 1; // changes to node coord instead of leaf coord
var nodeKey = leaf.PackId64();
if (!args.Nodes.TryGetValue(nodeKey, out node))
{
for (int i = 0; i < MyOctreeNode.CHILD_COUNT; ++i)
{
node.SetData(i, defaultData);
}
}
}
}
if (lodIdx == (LeafLodCount + 1))
{
MyCellCoord child = new MyCellCoord();
Vector3I childBase = lodCoord << 1;
Vector3I minInLod = min >> LeafLodCount;
Vector3I maxInLod = max >> LeafLodCount;
Vector3I leafSizeMinusOne = new Vector3I(LeafSizeInVoxels - 1);
Vector3I childOffset;
for (int i = 0; i < MyOctreeNode.CHILD_COUNT; ++i)
{
ComputeChildCoord(i, out childOffset);
child.CoordInLod = childBase + childOffset;
if (!child.CoordInLod.IsInsideInclusive(ref minInLod, ref maxInLod))
{
continue;
}
var childMin = child.CoordInLod << LeafLodCount;
var childMax = childMin + LeafSizeInVoxels - 1;
Vector3I.Max(ref childMin, ref min, out childMin);
Vector3I.Min(ref childMax, ref max, out childMax);
var readOffset = childMin - min;
IMyOctreeLeafNode leaf;
var leafKey = child.PackId64();
var startInChild = childMin - (child.CoordInLod << LeafLodCount);
var endInChild = childMax - (child.CoordInLod << LeafLodCount);
args.Leaves.TryGetValue(leafKey, out leaf);
byte uniformValue;
bool uniformLeaf;
{
// ensure leaf exists and is writable
// the only writable leaf type is MicroOctree at this point
byte childDefaultData = node.GetData(i);
if (leaf == null)
{
var octree = new MyMicroOctreeLeaf(args.DataType, LeafLodCount, child.CoordInLod << (child.Lod + LeafLodCount));
octree.BuildFrom(childDefaultData);
leaf = octree;
}
if (leaf.ReadOnly)
{
var rangeEnd = new Vector3I(LeafSizeInVoxels - 1);
m_temporaryCache.Resize(Vector3I.Zero, rangeEnd);
leaf.ReadRange(m_temporaryCache, ref Vector3I.Zero, 0, ref Vector3I.Zero, ref rangeEnd);
var inCell = startInChild;
for (var it2 = new Vector3I.RangeIterator(ref startInChild, ref endInChild);
it2.IsValid(); it2.GetNext(out inCell))
{
var read = readOffset + (inCell - startInChild);
m_temporaryCache.Set(args.DataType, ref inCell, args.Source.Get(args.DataType, ref read));
}
var octree = new MyMicroOctreeLeaf(args.DataType, LeafLodCount, child.CoordInLod << (child.Lod + LeafLodCount));
octree.BuildFrom(m_temporaryCache);
leaf = octree;
}
else
{
leaf.WriteRange(args.Source, ref readOffset, ref startInChild, ref endInChild);
}
uniformLeaf = ((MyMicroOctreeLeaf)leaf).TryGetUniformValue(out uniformValue);
}
if (!uniformLeaf)
{
args.Leaves[leafKey] = leaf;
node.SetChild(i, true);
}
else
{
args.Leaves.Remove(leafKey);
node.SetChild(i, false);
}
node.SetData(i, leaf.GetFilteredValue());
}
args.Nodes[new MyCellCoord(lodIdx - 1 - LeafLodCount, ref lodCoord).PackId64()] = node;
}
else
{
MyCellCoord child = new MyCellCoord();
child.Lod = lodIdx - 2 - LeafLodCount;
var childBase = lodCoord << 1;
Vector3I childOffset;
var minInChild = (min >> (lodIdx - 1)) - childBase;
var maxInChild = (max >> (lodIdx - 1)) - childBase;
for (int i = 0; i < MyOctreeNode.CHILD_COUNT; ++i)
{
ComputeChildCoord(i, out childOffset);
if (!childOffset.IsInsideInclusive(ref minInChild, ref maxInChild))
{
continue;
}
child.CoordInLod = childBase + childOffset;
WriteRange(ref args, node.GetData(i), lodIdx - 1, child.CoordInLod, ref min, ref max);
var childKey = child.PackId64();
var childNode = args.Nodes[childKey];
if (!childNode.HasChildren && childNode.AllDataSame())
{
node.SetChild(i, false);
node.SetData(i, childNode.GetData(0));
args.Nodes.Remove(childKey);
}
else
{
node.SetChild(i, true);
node.SetData(i, childNode.ComputeFilteredValue(args.DataFilter));
}
}
args.Nodes[new MyCellCoord(lodIdx - 1 - LeafLodCount, ref lodCoord).PackId64()] = node;
}
}
internal void DoClipping_Old(Vector3D localPosition, float farPlaneDistance, RequestCollector collector)
{
m_localPosition = localPosition;
MyClipmap.ComputeLodViewBounds(m_clipmap.m_scaleGroup, m_lodIndex, out m_nearDistance, out m_farDistance);
m_fitsInFrustum = (farPlaneDistance * 1.25f) > m_nearDistance;
if (!m_fitsInFrustum)
{
return;
}
//var localFrustum = new BoundingFrustumD(CameraFrustumGetter().Matrix * m_parent.m_invWorldMatrix);
var frustum = CameraFrustumGetter();
Vector3I min, max;
Vector3I ignoreMin, ignoreMax;
var minD = m_localPosition - m_farDistance;
var maxD = m_localPosition + m_farDistance;
MyVoxelCoordSystems.LocalPositionToRenderCellCoord(m_lodIndex, ref minD, out min);
MyVoxelCoordSystems.LocalPositionToRenderCellCoord(m_lodIndex, ref maxD, out max);
BoundingBoxI lodBox = new BoundingBoxI(Vector3I.Zero, m_lodSizeMinusOne);
bool intersects = false;
bool intersectsNear = false;
m_localFarCameraBox = new BoundingBoxI(min, max);
m_localNearCameraBox = new BoundingBoxI(min, max);
if (lodBox.Intersects(m_localFarCameraBox))
{
intersects = true;
var intersection = lodBox.Intersect(m_localFarCameraBox);
min = intersection.Min;
max = intersection.Max;
//Optimize only LOD2 and higher by two lods, because neighbour cells shares border cells
if (m_lodIndex > 1)
{
float lowerFar, lowerNear;
MyClipmap.ComputeLodViewBounds(m_clipmap.m_scaleGroup, m_lodIndex - 2, out lowerFar, out lowerNear);
var minNear = m_localPosition - (lowerNear - MyVoxelCoordSystems.RenderCellSizeInMeters(m_lodIndex) / 2);
var maxNear = m_localPosition + (lowerNear - MyVoxelCoordSystems.RenderCellSizeInMeters(m_lodIndex) / 2);
MyVoxelCoordSystems.LocalPositionToRenderCellCoord(m_lodIndex, ref minNear, out ignoreMin);
MyVoxelCoordSystems.LocalPositionToRenderCellCoord(m_lodIndex, ref maxNear, out ignoreMax);
m_localNearCameraBox = new BoundingBoxI(ignoreMin, ignoreMax);
if (lodBox.Intersects(m_localNearCameraBox))
{
intersectsNear = false;
}
}
}
if (m_lastMin == min && m_lastMax == max && !m_clipmap.m_updateClipping)
{
return;
}
m_lastMin = min;
m_lastMax = max;
LodLevel parentLod, childLod;
GetNearbyLodLevels(out parentLod, out childLod);
// Moves cells which are still needed from one collection to another.
// All that is left behind is unloaded as no longer needed.
// Move everything in range to collection of next stored cells.
MyUtils.Swap(ref m_storedCellData, ref m_clippedCells);
m_storedCellData.Clear();
if (intersects)
{
float sizeInMetres = MyVoxelCoordSystems.RenderCellSizeInMeters(m_lodIndex);
MyCellCoord cell = new MyCellCoord(m_lodIndex, ref min);
for (var it = new Vector3I.RangeIterator(ref min, ref max);
it.IsValid(); it.GetNext(out cell.CoordInLod))
{
if (intersectsNear &&
m_localNearCameraBox.Contains(cell.CoordInLod) == ContainmentType.Contains)
{
continue;
}
//if (!WasAncestorCellLoaded(parentLod, ref cell))
// continue;
Vector3D minAABB = Vector3D.Transform((Vector3D)(sizeInMetres * (cell.CoordInLod - 2)), m_clipmap.m_worldMatrix);
Vector3D maxAABB = Vector3D.Transform((Vector3D)(sizeInMetres * (cell.CoordInLod + 2) + new Vector3(sizeInMetres)), m_clipmap.m_worldMatrix);
if (frustum.Contains(new BoundingBoxD(minAABB, maxAABB)) == ContainmentType.Disjoint)
{
continue;
}
var cellId = cell.PackId64();
CellData data;
if (m_clippedCells.TryGetValue(cellId, out data))
{
m_clippedCells.Remove(cellId);
}
else
{
var clipmapCellId = MyCellCoord.GetClipmapCellHash(m_clipmap.Id, cellId);
data = CellsCache.Read(clipmapCellId);
if (data == null) //cache miss
{
data = new CellData();
ClippingCacheMisses++;
}
else
{
//cache hit
ClippingCacheHits++;
//System.Diagnostics.Debug.Assert((!data.InScene && data.Cell != null) || data.Cell == null, "Not allowed cell state");
data.InScene = false;
if (data.Cell != null)
{
m_nonEmptyCells[cellId] = data;
}
}
}
if (data.State == CellState.Invalid)
{
if (!TryAddCellRequest(collector, parentLod, cell, cellId, data))
{
continue;
}
}
m_storedCellData.Add(cellId, data);
}
}
}
protected override MyProceduralCell GenerateProceduralCell(ref VRageMath.Vector3I cellId)
{
MyProceduralCell cell = new MyProceduralCell(cellId, this);
ProfilerShort.Begin("GenerateObjectSeedsCell");
IMyModule densityFunctionFilled = GetCellDensityFunctionFilled(cell.BoundingVolume);
if (densityFunctionFilled == null)
{
ProfilerShort.End();
return null;
}
IMyModule densityFunctionRemoved = GetCellDensityFunctionRemoved(cell.BoundingVolume);
int cellSeed = GetCellSeed(ref cellId);
var random = MyRandom.Instance;
using (random.PushSeed(cellSeed))
{
int index = 0;
Vector3I subCellId = Vector3I.Zero;
Vector3I max = new Vector3I(SUBCELLS - 1);
for (var iter = new Vector3I.RangeIterator(ref Vector3I.Zero, ref max); iter.IsValid(); iter.GetNext(out subCellId))
{
// there is a bug in the position calculation which can very rarely cause overlaping objects but backwards compatibility so meh
Vector3D position = new Vector3D(random.NextDouble(), random.NextDouble(), random.NextDouble());
position += (Vector3D)subCellId / SUBCELL_SIZE;
position += cellId;
position *= CELL_SIZE;
if (!MyEntities.IsInsideWorld(position))
{
continue;
}
ProfilerShort.Begin("Density functions");
double valueRemoved = -1;
if (densityFunctionRemoved != null)
{
valueRemoved = densityFunctionRemoved.GetValue(position.X, position.Y, position.Z);
if (valueRemoved <= -1)
{
ProfilerShort.End();
continue;
}
}
var valueFilled = densityFunctionFilled.GetValue(position.X, position.Y, position.Z);
if (densityFunctionRemoved != null)
{
if (valueRemoved < valueFilled)
{
ProfilerShort.End();
continue;
}
}
ProfilerShort.End();
if (valueFilled < m_objectDensity) // -1..+1
{
var objectSeed = new MyObjectSeed(cell, position, GetObjectSize(random.NextDouble()));
objectSeed.Type = GetSeedType(random.NextDouble());
objectSeed.Seed = random.Next();
objectSeed.Index = index++;
GenerateObject(cell, objectSeed, ref index, random, densityFunctionFilled, densityFunctionRemoved);
}
}
}
ProfilerShort.End();
return cell;
}
public void InvalidateRange(Vector3I minVoxelChanged, Vector3I maxVoxelChanged)
{
minVoxelChanged -= MyPrecalcComponent.InvalidatedRangeInflate;
maxVoxelChanged += MyPrecalcComponent.InvalidatedRangeInflate;
m_voxelMap.Storage.ClampVoxelCoord(ref minVoxelChanged);
m_voxelMap.Storage.ClampVoxelCoord(ref maxVoxelChanged);
Vector3I minCell, maxCell;
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref minVoxelChanged, out minCell);
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref maxVoxelChanged, out maxCell);
Vector3I currentCell = minCell;
for (var it = new Vector3I.RangeIterator(ref minCell, ref maxCell); it.IsValid(); it.GetNext(out currentCell))
{
if (m_processedCells.Contains(ref currentCell))
{
RemoveCell(currentCell);
}
MyCellCoord coord = new MyCellCoord(NAVMESH_LOD, currentCell);
m_higherLevelHelper.TryClearCell(coord.PackId64());
}
}
private MySlimBlock GetBlockInMergeArea()
{
Vector3I minI, maxI;
CalculateMergeArea(out minI, out maxI);
Vector3I pos = minI;
for (Vector3I.RangeIterator it = new Vector3I.RangeIterator(ref minI, ref maxI); it.IsValid(); it.GetNext(out pos))
{
var block = this.CubeGrid.GetCubeBlock(pos);
if (block != null)
{
return(block);
}
}
return(null);
}
public void MarkBoxForAddition(BoundingBoxD box)
{
ProfilerShort.Begin("VoxelNavMesh.MarkBoxForAddition");
Vector3I pos, end;
MyVoxelCoordSystems.WorldPositionToVoxelCoord(m_voxelMap.PositionLeftBottomCorner, ref box.Min, out pos);
MyVoxelCoordSystems.WorldPositionToVoxelCoord(m_voxelMap.PositionLeftBottomCorner, ref box.Max, out end);
m_voxelMap.Storage.ClampVoxelCoord(ref pos);
m_voxelMap.Storage.ClampVoxelCoord(ref end);
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref pos, out pos);
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref end, out end);
Vector3 center = pos + end;
center = center * 0.5f;
pos /= 1 << NAVMESH_LOD;
end /= 1 << NAVMESH_LOD;
for (var it = new Vector3I.RangeIterator(ref pos, ref end); it.IsValid(); it.GetNext(out pos))
{
if (!m_processedCells.Contains(ref pos) && !m_markedForAddition.Contains(ref pos))
{
float weight = 1.0f / (0.01f + Vector3.RectangularDistance(pos, center));
if (!m_toAdd.Full)
{
m_toAdd.Insert(pos, weight);
m_markedForAddition.Add(ref pos);
}
else
{
float min = m_toAdd.MinKey();
if (weight > min)
{
Vector3I posRemoved = m_toAdd.RemoveMin();
m_markedForAddition.Remove(ref posRemoved);
m_toAdd.Insert(pos, weight);
m_markedForAddition.Add(ref pos);
}
}
}
}
ProfilerShort.End();
}
public void InvalidateRange(Vector3I minVoxelChanged, Vector3I maxVoxelChanged)
{
minVoxelChanged -= MyPrecalcComponent.InvalidatedRangeInflate + 1;
maxVoxelChanged += MyPrecalcComponent.InvalidatedRangeInflate + 1;
m_voxelMap.Storage.ClampVoxelCoord(ref minVoxelChanged);
m_voxelMap.Storage.ClampVoxelCoord(ref maxVoxelChanged);
Vector3I minCellLod0, maxCellLod0;
minVoxelChanged -= m_voxelMap.StorageMin;
maxVoxelChanged -= m_voxelMap.StorageMin;
MyVoxelCoordSystems.VoxelCoordToRenderCellCoord(ref minVoxelChanged, out minCellLod0);
MyVoxelCoordSystems.VoxelCoordToRenderCellCoord(ref maxVoxelChanged, out maxCellLod0);
MyRenderProxy.InvalidateClipmapRange(m_renderObjectIDs[0], minCellLod0, maxCellLod0);
if (minCellLod0 == Vector3I.Zero &&
maxCellLod0 == ((m_voxelMap.Storage.Geometry.CellsCount - 1) >> MyVoxelConstants.RENDER_CELL_SIZE_IN_GEOMETRY_CELLS_BITS))
{
m_renderWorkTracker.InvalidateAll();
}
else
{
for (int i = 0; i < MyCellCoord.MAX_LOD_COUNT; ++i)
{
var minCell = minCellLod0 >> i;
var maxCell = maxCellLod0 >> i;
var cellCoord = new MyCellCoord(i, ref minCell);
for (var it = new Vector3I.RangeIterator(ref minCell, ref maxCell);
it.IsValid(); it.GetNext(out cellCoord.CoordInLod))
{
m_renderWorkTracker.Invalidate(cellCoord.PackId64());
}
}
}
}
private MyShipMergeBlock GetOtherMergeBlock()
{
Vector3I minI, maxI;
CalculateMergeArea(out minI, out maxI);
Vector3I pos = minI;
for (Vector3I.RangeIterator it = new Vector3I.RangeIterator(ref minI, ref maxI); it.IsValid(); it.GetNext(out pos))
{
var block = this.CubeGrid.GetCubeBlock(pos);
if (block != null && block.FatBlock != null)
{
var mergeBlock = block.FatBlock as MyShipMergeBlock;
if (mergeBlock == null)
{
continue;
}
Vector3I otherMinI, otherMaxI;
mergeBlock.CalculateMergeArea(out otherMinI, out otherMaxI);
Vector3I faceNormal = Base6Directions.GetIntVector(this.Orientation.TransformDirection(m_forward));
// Bounding box test of minI <-> maxI and otherMinI(shifted by faceNormal) <-> otherMaxI(shifted by faceNormal)
otherMinI = maxI - (otherMinI + faceNormal);
otherMaxI = otherMaxI + faceNormal - minI;
if (otherMinI.X < 0)
{
continue;
}
if (otherMinI.Y < 0)
{
continue;
}
if (otherMinI.Z < 0)
{
continue;
}
if (otherMaxI.X < 0)
{
continue;
}
if (otherMaxI.Y < 0)
{
continue;
}
if (otherMaxI.Z < 0)
{
continue;
}
return(mergeBlock);
}
}
return(null);
}
private void Segment()
{
m_segmentation.ClearInput();
foreach (var block in m_grid.CubeBlocks)
{
Vector3I begin = block.Min;
Vector3I end = block.Max;
Vector3I pos = begin;
for (var it = new Vector3I.RangeIterator(ref begin, ref end); it.IsValid(); it.GetNext(out pos))
m_segmentation.AddInput(pos);
}
var segmentList = m_segmentation.FindSegments(MyVoxelSegmentationType.Simple2);
m_segments = new List<BoundingBox>(segmentList.Count);
for (int i = 0; i < segmentList.Count; ++i)
{
BoundingBox bb = new BoundingBox();
bb.Min = (new Vector3(segmentList[i].Min) - Vector3.Half) * m_grid.GridSize - Vector3.Half; // The another half is here to just add some head space
bb.Max = (new Vector3(segmentList[i].Max) + Vector3.Half) * m_grid.GridSize + Vector3.Half;
m_segments.Add(bb);
}
m_segmentation.ClearInput();
}
internal void DoClipping_Old(Vector3D localPosition, float farPlaneDistance, RequestCollector collector)
{
m_localPosition = localPosition;
MyClipmap.ComputeLodViewBounds(m_clipmap.m_scaleGroup, m_lodIndex, out m_nearDistance, out m_farDistance);
m_fitsInFrustum = (farPlaneDistance * 1.25f) > m_nearDistance;
if (!m_fitsInFrustum)
return;
//var localFrustum = new BoundingFrustumD(CameraFrustumGetter().Matrix * m_parent.m_invWorldMatrix);
var frustum = CameraFrustumGetter();
Vector3I min, max;
Vector3I ignoreMin, ignoreMax;
var minD = m_localPosition - m_farDistance;
var maxD = m_localPosition + m_farDistance;
MyVoxelCoordSystems.LocalPositionToRenderCellCoord(m_lodIndex, ref minD, out min);
MyVoxelCoordSystems.LocalPositionToRenderCellCoord(m_lodIndex, ref maxD, out max);
BoundingBoxI lodBox = new BoundingBoxI(Vector3I.Zero, m_lodSizeMinusOne);
bool intersects = false;
bool intersectsNear = false;
m_localFarCameraBox = new BoundingBoxI(min, max);
m_localNearCameraBox = new BoundingBoxI(min, max);
if (lodBox.Intersects(m_localFarCameraBox))
{
intersects = true;
var intersection = lodBox.Intersect(m_localFarCameraBox);
min = intersection.Min;
max = intersection.Max;
//Optimize only LOD2 and higher by two lods, because neighbour cells shares border cells
if (m_lodIndex > 1)
{
float lowerFar, lowerNear;
MyClipmap.ComputeLodViewBounds(m_clipmap.m_scaleGroup, m_lodIndex - 2, out lowerFar, out lowerNear);
var minNear = m_localPosition - (lowerNear - MyVoxelCoordSystems.RenderCellSizeInMeters(m_lodIndex) / 2);
var maxNear = m_localPosition + (lowerNear - MyVoxelCoordSystems.RenderCellSizeInMeters(m_lodIndex) / 2);
MyVoxelCoordSystems.LocalPositionToRenderCellCoord(m_lodIndex, ref minNear, out ignoreMin);
MyVoxelCoordSystems.LocalPositionToRenderCellCoord(m_lodIndex, ref maxNear, out ignoreMax);
m_localNearCameraBox = new BoundingBoxI(ignoreMin, ignoreMax);
if (lodBox.Intersects(m_localNearCameraBox))
intersectsNear = false;
}
}
if (m_lastMin == min && m_lastMax == max && !m_clipmap.m_updateClipping)
return;
m_lastMin = min;
m_lastMax = max;
LodLevel parentLod, childLod;
GetNearbyLodLevels(out parentLod, out childLod);
// Moves cells which are still needed from one collection to another.
// All that is left behind is unloaded as no longer needed.
// Move everything in range to collection of next stored cells.
MyUtils.Swap(ref m_storedCellData, ref m_clippedCells);
m_storedCellData.Clear();
if (intersects)
{
float sizeInMetres = MyVoxelCoordSystems.RenderCellSizeInMeters(m_lodIndex);
MyCellCoord cell = new MyCellCoord(m_lodIndex, ref min);
for (var it = new Vector3I.RangeIterator(ref min, ref max);
it.IsValid(); it.GetNext(out cell.CoordInLod))
{
if (intersectsNear &&
m_localNearCameraBox.Contains(cell.CoordInLod) == ContainmentType.Contains)
continue;
//if (!WasAncestorCellLoaded(parentLod, ref cell))
// continue;
Vector3D minAABB = Vector3D.Transform((Vector3D)(sizeInMetres * (cell.CoordInLod - 2)), m_clipmap.m_worldMatrix);
Vector3D maxAABB = Vector3D.Transform((Vector3D)(sizeInMetres * (cell.CoordInLod + 2) + new Vector3(sizeInMetres)), m_clipmap.m_worldMatrix);
if (frustum.Contains(new BoundingBoxD(minAABB, maxAABB)) == ContainmentType.Disjoint)
continue;
var cellId = cell.PackId64();
CellData data;
if (m_clippedCells.TryGetValue(cellId, out data))
{
m_clippedCells.Remove(cellId);
}
else
{
var clipmapCellId = MyCellCoord.GetClipmapCellHash(m_clipmap.Id, cellId);
data = CellsCache.Read(clipmapCellId);
if (data == null) //cache miss
{
data = new CellData();
ClippingCacheMisses++;
}
else
{
//cache hit
ClippingCacheHits++;
//System.Diagnostics.Debug.Assert((!data.InScene && data.Cell != null) || data.Cell == null, "Not allowed cell state");
data.InScene = false;
if (data.Cell != null)
{
m_nonEmptyCells[cellId] = data;
}
}
}
if (data.State == CellState.Invalid)
{
if (!TryAddCellRequest(collector, parentLod, cell, cellId, data))
continue;
}
m_storedCellData.Add(cellId, data);
}
}
}
protected override void Init(MyObjectBuilder_DefinitionBase ob)
{
base.Init(ob);
var objectBuilder = ob as MyObjectBuilder_BlockNavigationDefinition;
Debug.Assert(ob != null);
if (ob == null) return;
if (objectBuilder.NoEntry || objectBuilder.Triangles == null)
{
NoEntry = true;
}
else
{
NoEntry = false;
var newMesh = new MyGridNavigationMesh(null, null, objectBuilder.Triangles.Length);
Vector3I maxPos = objectBuilder.Size - Vector3I.One - objectBuilder.Center;
Vector3I minPos = - (Vector3I)(objectBuilder.Center);
foreach (var triOb in objectBuilder.Triangles)
{
Vector3 pa = (Vector3)triOb.Points[0];
Vector3 pb = (Vector3)triOb.Points[1];
Vector3 pc = (Vector3)triOb.Points[2];
var tri = newMesh.AddTriangle(ref pa, ref pb, ref pc);
var center = (pa + pb + pc) / 3.0f;
// We want to move the triangle vertices more towards the triangle center to ensure correct calculation of containing cube
Vector3 cvA = (center - pa) * 0.0001f;
Vector3 cvB = (center - pb) * 0.0001f;
Vector3 cvC = (center - pc) * 0.0001f;
Vector3I gridPosA = Vector3I.Round(pa + cvA);
Vector3I gridPosB = Vector3I.Round(pb + cvB);
Vector3I gridPosC = Vector3I.Round(pc + cvC);
Vector3I.Clamp(ref gridPosA, ref minPos, ref maxPos, out gridPosA);
Vector3I.Clamp(ref gridPosB, ref minPos, ref maxPos, out gridPosB);
Vector3I.Clamp(ref gridPosC, ref minPos, ref maxPos, out gridPosC);
Vector3I min, max;
Vector3I.Min(ref gridPosA, ref gridPosB, out min);
Vector3I.Min(ref min, ref gridPosC, out min);
Vector3I.Max(ref gridPosA, ref gridPosB, out max);
Vector3I.Max(ref max, ref gridPosC, out max);
Vector3I pos = min;
for (var it = new Vector3I.RangeIterator(ref min, ref max); it.IsValid(); it.GetNext(out pos))
{
newMesh.RegisterTriangle(tri, ref pos);
}
}
m_mesh = newMesh;
}
}
private static void WriteRange(
ref WriteRangeArgs args,
byte defaultData,
int lodIdx,
Vector3I lodCoord,
ref Vector3I min,
ref Vector3I max)
{
MyOctreeNode node = new MyOctreeNode();
{
MyCellCoord leaf = new MyCellCoord(lodIdx - LeafLodCount, ref lodCoord);
var leafKey = leaf.PackId64();
if (args.Leaves.ContainsKey(leafKey))
{
args.Leaves.Remove(leafKey);
var childBase = lodCoord << 1;
Vector3I childOffset;
MyCellCoord child = new MyCellCoord();
child.Lod = leaf.Lod - 1;
var leafSize = LeafSizeInVoxels << child.Lod;
for (int i = 0; i < MyOctreeNode.CHILD_COUNT; ++i)
{
ComputeChildCoord(i, out childOffset);
child.CoordInLod = childBase + childOffset;
var childCopy = child;
childCopy.Lod += LeafLodCount;
IMyOctreeLeafNode octreeLeaf = new MyProviderLeaf(args.Provider, args.DataType, ref childCopy);
args.Leaves.Add(child.PackId64(), octreeLeaf);
node.SetChild(i, true);
node.SetData(i, octreeLeaf.GetFilteredValue());
}
}
else
{
leaf.Lod -= 1; // changes to node coord instead of leaf coord
var nodeKey = leaf.PackId64();
if (!args.Nodes.TryGetValue(nodeKey, out node))
{
for (int i = 0; i < MyOctreeNode.CHILD_COUNT; ++i)
node.SetData(i, defaultData);
}
}
}
if (lodIdx == (LeafLodCount + 1))
{
MyCellCoord child = new MyCellCoord();
Vector3I childBase = lodCoord << 1;
Vector3I minInLod = min >> LeafLodCount;
Vector3I maxInLod = max >> LeafLodCount;
Vector3I leafSizeMinusOne = new Vector3I(LeafSizeInVoxels - 1);
Vector3I childOffset;
for (int i = 0; i < MyOctreeNode.CHILD_COUNT; ++i)
{
ComputeChildCoord(i, out childOffset);
child.CoordInLod = childBase + childOffset;
if (!child.CoordInLod.IsInsideInclusive(ref minInLod, ref maxInLod))
continue;
var childMin = child.CoordInLod << LeafLodCount;
var childMax = childMin + LeafSizeInVoxels - 1;
Vector3I.Max(ref childMin, ref min, out childMin);
Vector3I.Min(ref childMax, ref max, out childMax);
var readOffset = childMin - min;
IMyOctreeLeafNode leaf;
var leafKey = child.PackId64();
var startInChild = childMin - (child.CoordInLod << LeafLodCount);
var endInChild = childMax - (child.CoordInLod << LeafLodCount);
args.Leaves.TryGetValue(leafKey, out leaf);
byte uniformValue;
bool uniformLeaf;
{
// ensure leaf exists and is writable
// the only writable leaf type is MicroOctree at this point
byte childDefaultData = node.GetData(i);
if (leaf == null)
{
var octree = new MyMicroOctreeLeaf(args.DataType, LeafLodCount, child.CoordInLod << (child.Lod + LeafLodCount));
octree.BuildFrom(childDefaultData);
leaf = octree;
}
if (leaf.ReadOnly)
{
var rangeEnd = new Vector3I(LeafSizeInVoxels - 1);
m_temporaryCache.Resize(Vector3I.Zero, rangeEnd);
leaf.ReadRange(m_temporaryCache, ref Vector3I.Zero, 0, ref Vector3I.Zero, ref rangeEnd);
var inCell = startInChild;
for (var it2 = new Vector3I.RangeIterator(ref startInChild, ref endInChild);
it2.IsValid(); it2.GetNext(out inCell))
{
var read = readOffset + (inCell - startInChild);
m_temporaryCache.Set(args.DataType, ref inCell, args.Source.Get(args.DataType, ref read));
}
var octree = new MyMicroOctreeLeaf(args.DataType, LeafLodCount, child.CoordInLod << (child.Lod + LeafLodCount));
octree.BuildFrom(m_temporaryCache);
leaf = octree;
}
else
{
leaf.WriteRange(args.Source, ref readOffset, ref startInChild, ref endInChild);
}
uniformLeaf = ((MyMicroOctreeLeaf)leaf).TryGetUniformValue(out uniformValue);
}
if (!uniformLeaf)
{
args.Leaves[leafKey] = leaf;
node.SetChild(i, true);
}
else
{
args.Leaves.Remove(leafKey);
node.SetChild(i, false);
}
node.SetData(i, leaf.GetFilteredValue());
}
args.Nodes[new MyCellCoord(lodIdx - 1 - LeafLodCount, ref lodCoord).PackId64()] = node;
}
else
{
MyCellCoord child = new MyCellCoord();
child.Lod = lodIdx - 2 - LeafLodCount;
var childBase = lodCoord << 1;
Vector3I childOffset;
var minInChild = (min >> (lodIdx-1)) - childBase;
var maxInChild = (max >> (lodIdx-1)) - childBase;
for (int i = 0; i < MyOctreeNode.CHILD_COUNT; ++i)
{
ComputeChildCoord(i, out childOffset);
if (!childOffset.IsInsideInclusive(ref minInChild, ref maxInChild))
continue;
child.CoordInLod = childBase + childOffset;
WriteRange(ref args, node.GetData(i), lodIdx - 1, child.CoordInLod, ref min, ref max);
var childKey = child.PackId64();
var childNode = args.Nodes[childKey];
if (!childNode.HasChildren && childNode.AllDataSame())
{
node.SetChild(i, false);
node.SetData(i, childNode.GetData(0));
args.Nodes.Remove(childKey);
}
else
{
node.SetChild(i, true);
node.SetData(i, childNode.ComputeFilteredValue(args.DataFilter));
}
}
args.Nodes[new MyCellCoord(lodIdx - 1 - LeafLodCount, ref lodCoord).PackId64()] = node;
}
}
internal void DoClipping(Vector3D localPosition, float farPlaneDistance, RequestCollector collector)
{
MyClipmap.ComputeLodViewBounds(m_parent.m_scaleGroup, m_lodIndex, out m_nearDistance, out m_farDistance);
m_fitsInFrustum = (farPlaneDistance * 1.25f) > m_nearDistance;
if (!m_fitsInFrustum)
return;
Vector3I min, max;
{
var minD = localPosition - m_farDistance;
var maxD = localPosition + m_farDistance;
MyVoxelCoordSystems.LocalPositionToRenderCellCoord(ref minD, out min);
MyVoxelCoordSystems.LocalPositionToRenderCellCoord(ref maxD, out max);
Vector3I.Max(ref min, ref Vector3I.Zero, out min);
Vector3I.Max(ref max, ref Vector3I.Zero, out max);
min >>= m_lodIndex;
max >>= m_lodIndex;
Vector3I.Min(ref min, ref m_lodSizeMinusOne, out min);
Vector3I.Min(ref max, ref m_lodSizeMinusOne, out max);
}
if (m_lastMin == min && m_lastMax == max && !m_parent.m_updateClipping)
return;
m_lastMin = min;
m_lastMax = max;
LodLevel parentLod, childLod;
GetNearbyLodLevels(out parentLod, out childLod);
// Moves cells which are still needed from one collection to another.
// All that is left behind is unloaded as no longer needed.
// Move everything in range to collection of next stored cells.
MyUtils.Swap(ref m_storedCellData, ref m_clippedCells);
m_storedCellData.Clear();
MyCellCoord cell = new MyCellCoord(m_lodIndex, ref min);
for (var it = new Vector3I.RangeIterator(ref min, ref max);
it.IsValid(); it.GetNext(out cell.CoordInLod))
{
if (!WasAncestorCellLoaded(parentLod, ref cell))
continue;
var cellId = cell.PackId64();
CellData data;
if (m_clippedCells.TryGetValue(cellId, out data))
m_clippedCells.Remove(cellId);
else
data = new CellData();
if (data.State == CellState.Invalid)
{
collector.AddRequest(cellId, data.WasLoaded);
data.State = CellState.Pending;
}
m_storedCellData.Add(cellId, data);
}
}
private MySlimBlock GetBlockInMergeArea()
{
Vector3I minI, maxI;
CalculateMergeArea(out minI, out maxI);
Vector3I pos = minI;
for (Vector3I.RangeIterator it = new Vector3I.RangeIterator(ref minI, ref maxI); it.IsValid(); it.GetNext(out pos))
{
var block = this.CubeGrid.GetCubeBlock(pos);
if (block != null)
return block;
}
return null;
}
void IMyOctreeLeafNode.WriteRange(MyStorageDataCache 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 MyStorageDataCache();
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));
}
}
public void InvalidateRange(Vector3I minVoxelChanged, Vector3I maxVoxelChanged)
{
minVoxelChanged -= MyPrecalcComponent.InvalidatedRangeInflate;
maxVoxelChanged += MyPrecalcComponent.InvalidatedRangeInflate;
m_voxelMap.Storage.ClampVoxelCoord(ref minVoxelChanged);
m_voxelMap.Storage.ClampVoxelCoord(ref maxVoxelChanged);
Vector3I minCell, maxCell;
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref minVoxelChanged, out minCell);
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref maxVoxelChanged, out maxCell);
Vector3I currentCell = minCell;
for (var it = new Vector3I.RangeIterator(ref minCell, ref maxCell); it.IsValid(); it.GetNext(out currentCell))
{
if (m_processedCells.Contains(ref currentCell))
{
RemoveCell(currentCell);
}
MyCellCoord coord = new MyCellCoord(NAVMESH_LOD, currentCell);
m_higherLevelHelper.TryClearCell(coord.PackId64());
}
}
/// <summary>
/// For debugging/testing only! This can be very slow for large storage.
/// </summary>
public void Voxelize(MyStorageDataTypeFlags data)
{
var cache = new MyStorageDataCache();
cache.Resize(new Vector3I(LeafSizeInVoxels));
var leafCount = (Size / LeafSizeInVoxels);
Vector3I leaf = Vector3I.Zero;
var end = leafCount - 1;
for (var it = new Vector3I.RangeIterator(ref Vector3I.Zero, ref end);
it.IsValid();
it.GetNext(out leaf))
{
Debug.WriteLine("Processing {0} / {1}", leaf, end);
var min = leaf * LeafSizeInVoxels;
var max = min + (LeafSizeInVoxels - 1);
ReadRangeInternal(cache, ref Vector3I.Zero, data, 0, ref min, ref max);
WriteRangeInternal(cache, data, ref min, ref max);
}
OnRangeChanged(Vector3I.Zero, Size - 1, data);
}
/// <param name="minVoxelChanged">Inclusive min.</param>
/// <param name="maxVoxelChanged">Inclusive max.</param>
internal void InvalidateRange(Vector3I minVoxelChanged, Vector3I maxVoxelChanged)
{
MyPrecalcComponent.AssertUpdateThread();
ProfilerShort.Begin("MyVoxelPhysicsBody.InvalidateRange");
minVoxelChanged -= MyPrecalcComponent.InvalidatedRangeInflate;
maxVoxelChanged += MyPrecalcComponent.InvalidatedRangeInflate;
m_voxelMap.Storage.ClampVoxelCoord(ref minVoxelChanged);
m_voxelMap.Storage.ClampVoxelCoord(ref maxVoxelChanged);
Vector3I minCellChanged, maxCellChanged;
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref minVoxelChanged, out minCellChanged);
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref maxVoxelChanged, out maxCellChanged);
Vector3I minCellChangedVoxelMap, maxCellChangedVoxelMap;
minCellChangedVoxelMap = minCellChanged - m_cellsOffset;
maxCellChangedVoxelMap = maxCellChanged - m_cellsOffset;
var maxCell = m_voxelMap.Size - 1;
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref maxCell, out maxCell);
Vector3I.Min(ref maxCellChangedVoxelMap, ref maxCell, out maxCellChangedVoxelMap);
Debug.Assert(RigidBody != null, "RigidBody in voxel physics is null! This must not happen.");
if (RigidBody != null)
{
var shape = (HkUniformGridShape)RigidBody.GetShape();
var tmpBuffer = m_cellsToGenerateBuffer;
int invalidCount = shape.InvalidateRange(ref minCellChangedVoxelMap, ref maxCellChangedVoxelMap, tmpBuffer);
if (invalidCount > tmpBuffer.Length)
{
// Not storing this new buffer in static variable since this is just temporary and potentially large.
// Static variable could be potentially the same as leak.
tmpBuffer = new Vector3I[invalidCount];
int invalidCount2 = shape.InvalidateRange(ref minCellChangedVoxelMap, ref maxCellChangedVoxelMap, tmpBuffer);
Debug.Assert(invalidCount == invalidCount2);
invalidCount = invalidCount2;
}
Debug.Assert(invalidCount <= tmpBuffer.Length);
for (int i = 0; i < invalidCount; i++)
{
InvalidCells.Add(tmpBuffer[i]);
}
if (RunningBatchTask == null && InvalidCells.Count != 0)
{
MyPrecalcComponent.PhysicsWithInvalidCells.Add(this);
}
}
if (minCellChangedVoxelMap == Vector3I.Zero && maxCellChangedVoxelMap == maxCell)
{
m_workTracker.CancelAll();
}
else
{
var cell = minCellChanged;
for (var it = new Vector3I.RangeIterator(ref minCellChanged, ref maxCellChanged);
it.IsValid(); it.GetNext(out cell))
{
m_workTracker.Cancel(cell);
}
}
m_needsShapeUpdate = true;
ProfilerShort.End();
}
public MyIsoMesh Precalc(IMyStorage storage, int lod, Vector3I voxelStart, Vector3I voxelEnd, bool generateMaterials, bool useAmbient)
{
m_resultVerticesCounter = 0;
m_resultTrianglesCounter = 0;
m_edgeVertexCalcCounter++;
m_temporaryVoxelsCounter++;
CalcPolygCubeSize(lod, storage.Size);
m_voxelStart = voxelStart;
//voxelStart = voxelStart;
//voxelEnd = voxelEnd;
var ssize = storage.Size;
m_cache.Resize(voxelStart, voxelEnd);
// Load content first, check it if it contains isosurface, early exit if it doesn't.
storage.ReadRange(m_cache, MyStorageDataTypeFlags.Content, lod, ref voxelStart, ref voxelEnd);
if (!m_cache.ContainsIsoSurface())
return null;
storage.ReadRange(m_cache, MyStorageDataTypeFlags.Material, lod, ref voxelStart, ref voxelEnd);
ProfilerShort.Begin("Marching cubes");
{
// Size of voxel or cell (in meters) and size of voxel map / voxel cells
ComputeSizeAndOrigin(lod, storage.Size);
var start = Vector3I.Zero;
var end = voxelEnd - voxelStart - 3;
Vector3I coord0 = start;
for (var it = new Vector3I.RangeIterator(ref start, ref end); it.IsValid(); it.GetNext(out coord0))
{
int cubeIndex = 0;
if (m_cache.Content(coord0.X + 0, coord0.Y + 0, coord0.Z + 0) < MyVoxelConstants.VOXEL_ISO_LEVEL) cubeIndex |= 1;
if (m_cache.Content(coord0.X + 1, coord0.Y + 0, coord0.Z + 0) < MyVoxelConstants.VOXEL_ISO_LEVEL) cubeIndex |= 2;
if (m_cache.Content(coord0.X + 1, coord0.Y + 0, coord0.Z + 1) < MyVoxelConstants.VOXEL_ISO_LEVEL) cubeIndex |= 4;
if (m_cache.Content(coord0.X + 0, coord0.Y + 0, coord0.Z + 1) < MyVoxelConstants.VOXEL_ISO_LEVEL) cubeIndex |= 8;
if (m_cache.Content(coord0.X + 0, coord0.Y + 1, coord0.Z + 0) < MyVoxelConstants.VOXEL_ISO_LEVEL) cubeIndex |= 16;
if (m_cache.Content(coord0.X + 1, coord0.Y + 1, coord0.Z + 0) < MyVoxelConstants.VOXEL_ISO_LEVEL) cubeIndex |= 32;
if (m_cache.Content(coord0.X + 1, coord0.Y + 1, coord0.Z + 1) < MyVoxelConstants.VOXEL_ISO_LEVEL) cubeIndex |= 64;
if (m_cache.Content(coord0.X + 0, coord0.Y + 1, coord0.Z + 1) < MyVoxelConstants.VOXEL_ISO_LEVEL) cubeIndex |= 128;
// Cube is entirely in/out of the surface
if (MyMarchingCubesConstants.EdgeTable[cubeIndex] == 0)
{
continue;
}
// We can get this voxel content right from cache (not using GetVoxelContent method), because after CopyVoxelContents these array must be filled. But only content, not material, normal, etc.
Vector3I tempVoxelCoord0 = ComputeTemporaryVoxelData(m_cache, ref coord0, cubeIndex, lod);
// Create the triangles
CreateTriangles(ref coord0, cubeIndex, ref tempVoxelCoord0);
}
}
ProfilerShort.End();
double numCellsHalf = 0.5f * (m_cache.Size3D.X);
var voxelSize = MyVoxelConstants.VOXEL_SIZE_IN_METRES * (1 << lod);
var vertexCellOffset = voxelStart - AffectedRangeOffset;
IMyIsoMesherOutputBuffer isomesh = new MyIsoMesh();
for (int i = 0; i < m_resultVerticesCounter; i++)
{
var pos = (m_resultVertices[i].Position - (Vector3)storage.Size / 2) / storage.Size;
m_resultVertices[i].Position = pos;
m_resultVertices[i].PositionMorph = pos;
m_resultVertices[i].NormalMorph = m_resultVertices[i].Normal;
m_resultVertices[i].MaterialMorph = m_resultVertices[i].Material;
m_resultVertices[i].AmbientMorph = m_resultVertices[i].Ambient;
}
for (int i = 0; i < m_resultVerticesCounter; i++)
{
isomesh.WriteVertex(ref m_resultVertices[i].Cell, ref m_resultVertices[i].Position, ref m_resultVertices[i].Normal, (byte)m_resultVertices[i].Material, m_resultVertices[i].Ambient);
}
for (int i = 0; i < m_resultTrianglesCounter; i++)
{
isomesh.WriteTriangle(m_resultTriangles[i].VertexIndex0, m_resultTriangles[i].VertexIndex1, m_resultTriangles[i].VertexIndex2);
}
var mIsoMesh = (MyIsoMesh)isomesh;
mIsoMesh.PositionOffset = storage.Size / 2;
mIsoMesh.PositionScale = storage.Size;
mIsoMesh.CellStart = voxelStart;
mIsoMesh.CellEnd = voxelEnd;
var vertexCells = mIsoMesh.Cells.GetInternalArray();
for (int i = 0; i < mIsoMesh.VerticesCount; i++)
{
vertexCells[i] += vertexCellOffset;
}
return (MyIsoMesh)isomesh;
}
public void ProcessChangedCellComponents()
{
ProfilerShort.Begin("ProcessChangedCellComponents");
m_currentHelper = this;
Vector3I min, max, pos;
List<int> triangles = null;
foreach (var cell in m_changedCells)
{
min = CellToLowestCube(cell);
max = min + m_cellSize - Vector3I.One;
// Save a hashset of all the triangles in the current cell
pos = min;
for (var it = new Vector3I.RangeIterator(ref min, ref max); it.IsValid(); it.GetNext(out pos))
{
if (!m_triangleRegistry.TryGetValue(pos, out triangles)) continue;
foreach (var triIndex in triangles)
{
m_tmpCellTriangles.Add(triIndex);
}
}
if (m_tmpCellTriangles.Count == 0) continue;
MyCellCoord cellCoord = new MyCellCoord(0, cell);
ulong packedCell = cellCoord.PackId64();
m_components.OpenCell(packedCell);
long timeBegin = m_mesh.GetCurrentTimestamp() + 1;
long timeEnd = timeBegin;
m_currentComponentRel = 0;
m_tmpComponentTriangles.Clear();
foreach (var triIndex in m_tmpCellTriangles)
{
// Skip already visited triangles
var triangle = m_mesh.GetTriangle(triIndex);
if (m_currentComponentRel != 0 && m_mesh.VisitedBetween(triangle, timeBegin, timeEnd)) continue;
m_components.OpenComponent();
// Make sure we have place in m_currentCellConnections
if (m_currentComponentRel >= m_currentCellConnections.Count)
{
m_currentCellConnections.Add(new List<int>());
}
// Find connected component from an unvisited triangle and mark its connections
m_components.AddComponentTriangle(triangle, triangle.Center);
triangle.ComponentIndex = m_currentComponentRel;
m_tmpComponentTriangles.Add(triangle);
m_mesh.PrepareTraversal(triangle, null, m_processTrianglePredicate);
m_mesh.PerformTraversal();
m_tmpComponentTriangles.Add(null);
m_components.CloseComponent();
timeEnd = m_mesh.GetCurrentTimestamp();
if (m_currentComponentRel == 0)
{
timeBegin = timeEnd;
}
m_currentComponentRel++;
}
m_tmpCellTriangles.Clear();
MyNavmeshComponents.ClosedCellInfo cellInfo = new MyNavmeshComponents.ClosedCellInfo();
m_components.CloseAndCacheCell(ref cellInfo);
// Renumber triangles from the old indices to the newly assigned index from m_components
int componentIndex = cellInfo.StartingIndex;
foreach (var triangle in m_tmpComponentTriangles)
{
if (triangle == null)
{
componentIndex++;
continue;
}
triangle.ComponentIndex = componentIndex;
}
m_tmpComponentTriangles.Clear();
// Remove old component primitives
if (!cellInfo.NewCell && cellInfo.ComponentNum != cellInfo.OldComponentNum)
{
for (int i = 0; i < cellInfo.OldComponentNum; ++i)
{
m_mesh.HighLevelGroup.RemovePrimitive(cellInfo.OldStartingIndex + i);
}
}
// Add new component primitives
if (cellInfo.NewCell || cellInfo.ComponentNum != cellInfo.OldComponentNum)
{
for (int i = 0; i < cellInfo.ComponentNum; ++i)
{
m_mesh.HighLevelGroup.AddPrimitive(cellInfo.StartingIndex + i, m_components.GetComponentCenter(i));
}
}
// Update existing component primitives
if (!cellInfo.NewCell && cellInfo.ComponentNum == cellInfo.OldComponentNum)
{
for (int i = 0; i < cellInfo.ComponentNum; ++i)
{
var primitive = m_mesh.HighLevelGroup.GetPrimitive(cellInfo.StartingIndex + i);
primitive.UpdatePosition(m_components.GetComponentCenter(i));
}
}
// Connect new components with the others in the neighboring cells
for (int i = 0; i < cellInfo.ComponentNum; ++i)
{
int compIndex = cellInfo.StartingIndex + i;
var primitive = m_mesh.HighLevelGroup.GetPrimitive(compIndex);
primitive.GetNeighbours(m_tmpNeighbors);
// Connect to disconnected components
foreach (var connection in m_currentCellConnections[i])
{
if (!m_tmpNeighbors.Remove(connection))
{
m_mesh.HighLevelGroup.ConnectPrimitives(compIndex, connection);
}
}
// Disconnect neighbors that should be no longer connected
foreach (var neighbor in m_tmpNeighbors)
{
// Only disconnect from the other cell if it is expanded and there was no connection found
var neighborPrimitive = m_mesh.HighLevelGroup.TryGetPrimitive(neighbor);
if (neighborPrimitive != null && neighborPrimitive.IsExpanded)
{
m_mesh.HighLevelGroup.DisconnectPrimitives(compIndex, neighbor);
}
}
m_tmpNeighbors.Clear();
m_currentCellConnections[i].Clear();
}
// Set all the components as expanded
for (int i = 0; i < cellInfo.ComponentNum; ++i)
{
componentIndex = cellInfo.StartingIndex + i;
var component = m_mesh.HighLevelGroup.GetPrimitive(componentIndex);
if (component != null)
{
component.IsExpanded = true;
}
}
}
m_changedCells.Clear();
m_currentHelper = null;
ProfilerShort.End();
}
private MyShipMergeBlock GetOtherMergeBlock()
{
Vector3I minI, maxI;
CalculateMergeArea(out minI, out maxI);
Vector3I pos = minI;
for (Vector3I.RangeIterator it = new Vector3I.RangeIterator(ref minI, ref maxI); it.IsValid(); it.GetNext(out pos))
{
var block = this.CubeGrid.GetCubeBlock(pos);
if (block != null && block.FatBlock != null)
{
var mergeBlock = block.FatBlock as MyShipMergeBlock;
if (mergeBlock == null) continue;
Vector3I otherMinI, otherMaxI;
mergeBlock.CalculateMergeArea(out otherMinI, out otherMaxI);
Vector3I faceNormal = Base6Directions.GetIntVector(this.Orientation.TransformDirection(m_forward));
// Bounding box test of minI <-> maxI and otherMinI(shifted by faceNormal) <-> otherMaxI(shifted by faceNormal)
otherMinI = maxI - (otherMinI + faceNormal);
otherMaxI = otherMaxI + faceNormal - minI;
if (otherMinI.X < 0) continue;
if (otherMinI.Y < 0) continue;
if (otherMinI.Z < 0) continue;
if (otherMaxI.X < 0) continue;
if (otherMaxI.Y < 0) continue;
if (otherMaxI.Z < 0) continue;
return mergeBlock;
}
}
return null;
}
/// <param name="minVoxelChanged">Inclusive min.</param>
/// <param name="maxVoxelChanged">Inclusive max.</param>
private void storage_RangeChanged(Vector3I minChanged, Vector3I maxChanged, MyStorageDataTypeFlags changedData)
{
MyPrecalcComponent.AssertUpdateThread();
ProfilerShort.Begin("MyVoxelGeometry.storage_RangeChanged");
minChanged -= MyPrecalcComponent.InvalidatedRangeInflate;
maxChanged += MyPrecalcComponent.InvalidatedRangeInflate;
m_storage.ClampVoxelCoord(ref minChanged);
m_storage.ClampVoxelCoord(ref maxChanged);
var minCellChanged = minChanged >> MyVoxelConstants.GEOMETRY_CELL_SIZE_IN_VOXELS_BITS;
var maxCellChanged = maxChanged >> MyVoxelConstants.GEOMETRY_CELL_SIZE_IN_VOXELS_BITS;
using (m_lock.AcquireExclusiveUsing())
{
if (minCellChanged == Vector3I.Zero && maxCellChanged == m_cellsCount - 1)
{
m_cellsByCoordinate.Clear();
m_coordinateToMesh.Clear();
m_isEmptyCache.Reset();
}
else
{
MyCellCoord cell = new MyCellCoord();
cell.CoordInLod = minCellChanged;
for (var it = new Vector3I.RangeIterator(ref minCellChanged, ref maxCellChanged); it.IsValid(); it.GetNext(out cell.CoordInLod))
{
var key = cell.PackId64();
m_cellsByCoordinate.Remove(key);
m_coordinateToMesh.Remove(key);
SetEmpty(ref cell, false);
}
}
}
ProfilerShort.End();
}
public void MarkBoxForAddition(BoundingBoxD box)
{
ProfilerShort.Begin("VoxelNavMesh.MarkBoxForAddition");
Vector3I pos, end;
MyVoxelCoordSystems.WorldPositionToVoxelCoord(m_voxelMap.PositionLeftBottomCorner, ref box.Min, out pos);
MyVoxelCoordSystems.WorldPositionToVoxelCoord(m_voxelMap.PositionLeftBottomCorner, ref box.Max, out end);
m_voxelMap.Storage.ClampVoxelCoord(ref pos);
m_voxelMap.Storage.ClampVoxelCoord(ref end);
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref pos, out pos);
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref end, out end);
Vector3 center = pos + end;
center = center * 0.5f;
pos /= 1 << NAVMESH_LOD;
end /= 1 << NAVMESH_LOD;
for (var it = new Vector3I.RangeIterator(ref pos, ref end); it.IsValid(); it.GetNext(out pos))
{
if (!m_processedCells.Contains(ref pos) && !m_markedForAddition.Contains(ref pos))
{
float weight = 1.0f / (0.01f + Vector3.RectangularDistance(pos, center));
if (!m_toAdd.Full)
{
m_toAdd.Insert(pos, weight);
m_markedForAddition.Add(ref pos);
}
else
{
float min = m_toAdd.MinKey();
if (weight > min)
{
Vector3I posRemoved = m_toAdd.RemoveMin();
m_markedForAddition.Remove(ref posRemoved);
m_toAdd.Insert(pos, weight);
m_markedForAddition.Add(ref pos);
}
}
}
}
ProfilerShort.End();
}
public void ProcessChangedCellComponents()
{
ProfilerShort.Begin("ProcessChangedCellComponents");
m_currentHelper = this;
Vector3I min, max, pos;
List<int> triangles = null;
foreach (var cell in m_changedCells)
{
MyCellCoord cellCoord = new MyCellCoord(0, cell);
ulong packedCell = cellCoord.PackId64();
m_components.OpenCell(packedCell);
min = CellToLowestCube(cell);
max = min + m_cellSize - Vector3I.One;
// Save a hashset of all the triangles in the current cell
pos = min;
for (var it = new Vector3I.RangeIterator(ref min, ref max); it.IsValid(); it.GetNext(out pos))
{
if (!m_triangleRegistry.TryGetValue(pos, out triangles)) continue;
foreach (var triIndex in triangles)
{
m_tmpCellTriangles.Add(triIndex);
}
}
long timeBegin = m_mesh.GetCurrentTimestamp() + 1;
long timeEnd = timeBegin;
m_currentComponentRel = 0;
foreach (var triIndex in m_tmpCellTriangles)
{
// Skip already visited triangles
var triangle = m_mesh.GetTriangle(triIndex);
if (m_currentComponentRel != 0 && m_mesh.VisitedBetween(triangle, timeBegin, timeEnd)) continue;
m_components.OpenComponent();
// Make sure we have place in m_currentCellConnections
if (m_currentComponentRel >= m_currentCellConnections.Count)
{
m_currentCellConnections.Add(new List<int>());
}
// Find connected component from an unvisited triangle and mark its connections
m_components.AddComponentTriangle(triangle, triangle.Center);
triangle.ComponentIndex = m_components.OpenComponentIndex;
m_mesh.PrepareTraversal(triangle, null, m_processTrianglePredicate);
var primitiveEnum = m_mesh.GetEnumerator();
while (primitiveEnum.MoveNext());
primitiveEnum.Dispose();
m_components.CloseComponent();
timeEnd = m_mesh.GetCurrentTimestamp();
if (m_currentComponentRel == 0)
{
timeBegin = timeEnd;
}
m_currentComponentRel++;
}
m_tmpCellTriangles.Clear();
MyNavmeshComponents.ClosedCellInfo cellInfo = new MyNavmeshComponents.ClosedCellInfo();
m_components.CloseAndCacheCell(ref cellInfo);
// Add new component primitives
if (cellInfo.NewCell)
{
for (int i = 0; i < cellInfo.ComponentNum; ++i)
{
m_mesh.HighLevelGroup.AddPrimitive(cellInfo.StartingIndex + i, m_components.GetComponentCenter(i));
}
}
// Connect new components with the others in the neighboring cells
for (int i = 0; i < cellInfo.ComponentNum; ++i)
{
foreach (var otherComponent in m_currentCellConnections[i])
{
m_mesh.HighLevelGroup.ConnectPrimitives(cellInfo.StartingIndex + i, otherComponent);
}
m_currentCellConnections[i].Clear();
}
// Set all the components as expanded
for (int i = 0; i < cellInfo.ComponentNum; ++i)
{
int componentIndex = cellInfo.StartingIndex + i;
var component = m_mesh.HighLevelGroup.GetPrimitive(componentIndex);
if (component != null)
{
component.IsExpanded = true;
}
}
}
m_changedCells.Clear();
m_currentHelper = null;
ProfilerShort.End();
}
private MyProceduralCell GenerateObjectSeedsCell(ref Vector3I cellId)
{
MyProceduralCell cell = new MyProceduralCell(cellId);
ProfilerShort.Begin("GenerateObjectSeedsCell");
IMyModule cellDensityFunction = CalculateCellDensityFunction(ref cellId);
if (cellDensityFunction == null)
{
ProfilerShort.End();
return null;
}
int cellSeed = GetCellSeed(ref cellId);
using (MyRandom.Instance.PushSeed(cellSeed))
{
var random = MyRandom.Instance;
int index = 0;
Vector3I subCellId = Vector3I.Zero;
Vector3I max = new Vector3I(SUBCELLS - 1);
for (var iter = new Vector3I.RangeIterator(ref Vector3I.Zero, ref max); iter.IsValid(); iter.GetNext(out subCellId))
{
Vector3D position = new Vector3D(random.NextDouble(), random.NextDouble(), random.NextDouble());
position += (Vector3D)subCellId / SUBCELL_SIZE;
position += cellId;
position *= CELL_SIZE;
if (!MyEntities.IsInsideWorld(position))
{
continue;
}
ProfilerShort.Begin("GetValue");
var value = cellDensityFunction.GetValue(position.X, position.Y, position.Z);
ProfilerShort.End();
if (value < m_objectDensity) // -1..+1
{
var objectSeed = new MyObjectSeed(cell, position, GetObjectSize(random.NextDouble()));
objectSeed.Type = GetSeedType(random.NextDouble());
objectSeed.Seed = random.Next();
objectSeed.Index = index++;
GenerateObject(cell, objectSeed, ref index, random, cellDensityFunction);
}
}
}
ProfilerShort.End();
return cell;
}
/// <param name="minVoxelChanged">Inclusive min.</param>
/// <param name="maxVoxelChanged">Inclusive max.</param>
internal void InvalidateRange(Vector3I minChanged, Vector3I maxChanged)
{
minChanged -= MyVoxelPrecalc.InvalidatedRangeInflate;
maxChanged += MyVoxelPrecalc.InvalidatedRangeInflate;
m_voxelMap.FixVoxelCoord(ref minChanged);
m_voxelMap.FixVoxelCoord(ref maxChanged);
var minCellChanged = minChanged >> MyVoxelConstants.GEOMETRY_CELL_SIZE_IN_VOXELS_BITS;
var maxCellChanged = maxChanged >> MyVoxelConstants.GEOMETRY_CELL_SIZE_IN_VOXELS_BITS;
Vector3I cellCoord = minCellChanged;
for (var it = new Vector3I.RangeIterator(ref minCellChanged, ref maxCellChanged); it.IsValid(); it.GetNext(out cellCoord))
{
RemoveCell(ref cellCoord);
}
}
internal void GenerateAllShapes()
{
if (!m_bodiesInitialized) CreateRigidBodies();
var min = Vector3I.Zero;
Vector3I storageSize = m_voxelMap.Size;
Vector3I max = new Vector3I(0, 0, 0);
max.X = storageSize.X >> MyVoxelConstants.GEOMETRY_CELL_SIZE_IN_VOXELS_BITS;
max.Y = storageSize.Y >> MyVoxelConstants.GEOMETRY_CELL_SIZE_IN_VOXELS_BITS;
max.Z = storageSize.Z >> MyVoxelConstants.GEOMETRY_CELL_SIZE_IN_VOXELS_BITS;
max += min;
var args = new MyPrecalcJobPhysicsPrefetch.Args
{
GeometryCell = new MyCellCoord(1, min),
Storage = m_voxelMap.Storage,
TargetPhysics = this,
Tracker = m_workTracker
};
for (var it = new Vector3I.RangeIterator(ref min, ref max);
it.IsValid();
it.GetNext(out args.GeometryCell.CoordInLod))
{
MyPrecalcJobPhysicsPrefetch.Start(args);
}
}
private MyProceduralCell GenerateObjectSeedsCell(ref Vector3I cellId)
{
MyProceduralCell cell = new MyProceduralCell(cellId);
ProfilerShort.Begin("GenerateObjectSeedsCell");
IMyModule cellDensityFunction = CalculateCellDensityFunction(ref cellId);
if (cellDensityFunction == null)
{
ProfilerShort.End();
return(null);
}
int cellSeed = GetCellSeed(ref cellId);
using (MyRandom.Instance.PushSeed(cellSeed))
{
var random = MyRandom.Instance;
int index = 0;
Vector3I subCellId = Vector3I.Zero;
Vector3I max = new Vector3I(SUBCELLS - 1);
for (var iter = new Vector3I.RangeIterator(ref Vector3I.Zero, ref max); iter.IsValid(); iter.GetNext(out subCellId))
{
Vector3D position = new Vector3D(random.NextDouble(), random.NextDouble(), random.NextDouble());
position += (Vector3D)subCellId / SUBCELL_SIZE;
position += cellId;
position *= CELL_SIZE;
if (!MyEntities.IsInsideWorld(position))
{
continue;
}
ProfilerShort.Begin("GetValue");
var value = cellDensityFunction.GetValue(position.X, position.Y, position.Z);
ProfilerShort.End();
if (value < m_objectDensity) // -1..+1
{
var objectSeed = new MyObjectSeed(cell, position, GetObjectSize(random.NextDouble()));
objectSeed.Type = GetSeedType(random.NextDouble());
objectSeed.Seed = random.Next();
objectSeed.Index = index++;
GenerateObject(cell, objectSeed, ref index, random, cellDensityFunction);
}
}
}
ProfilerShort.End();
return(cell);
}