private void GetSurroundingBlocksFromStaticGrids(MySlimBlock block, MyCubeSize cubeSizeEnum, HashSet <MySlimBlock> outBlocks)
{
outBlocks.Clear();
BoundingBoxD aabbForNeighbors = new BoundingBoxD((Vector3D)(block.Min * block.CubeGrid.GridSize), (Vector3D)(block.Max * block.CubeGrid.GridSize));
BoundingBoxD box = new BoundingBoxD((Vector3D)((block.Min * block.CubeGrid.GridSize) - (block.CubeGrid.GridSize / 2f)), (block.Max * block.CubeGrid.GridSize) + (block.CubeGrid.GridSize / 2f));
if (block.FatBlock != null)
{
Matrix matrix;
box = block.FatBlock.Model.BoundingBox;
block.FatBlock.Orientation.GetMatrix(out matrix);
box = box.TransformFast(matrix);
box.Translate(box.Center);
}
box.Inflate((double)0.125);
BoundingBoxD boundingBox = box.TransformFast(block.CubeGrid.WorldMatrix);
List <VRage.Game.Entity.MyEntity> foundElements = new List <VRage.Game.Entity.MyEntity>();
Sandbox.Game.Entities.MyEntities.GetElementsInBox(ref boundingBox, foundElements);
for (int i = 0; i < foundElements.Count; i++)
{
MyCubeGrid objA = foundElements[i] as MyCubeGrid;
if (((objA != null) && (objA.IsStatic && (!ReferenceEquals(objA, block.CubeGrid) && (objA.EnableSmallToLargeConnections && objA.SmallToLargeConnectionsInitialized)))) && (objA.GridSizeEnum == cubeSizeEnum))
{
m_tmpSlimBlocksList.Clear();
objA.GetBlocksIntersectingOBB(box, block.CubeGrid.WorldMatrix, m_tmpSlimBlocksList);
CheckNeighborBlocks(block, aabbForNeighbors, objA, m_tmpSlimBlocksList);
foreach (MySlimBlock block2 in m_tmpSlimBlocksList)
{
if (block2.FatBlock == null)
{
outBlocks.Add(block2);
continue;
}
if (!(block2.FatBlock is MyFracturedBlock) && !block2.FatBlock.Components.Has <MyFractureComponentBase>())
{
if (block2.FatBlock is MyCompoundCubeBlock)
{
foreach (MySlimBlock block3 in (block2.FatBlock as MyCompoundCubeBlock).GetBlocks())
{
if (!block3.FatBlock.Components.Has <MyFractureComponentBase>())
{
outBlocks.Add(block3);
}
}
continue;
}
outBlocks.Add(block2);
}
}
m_tmpSlimBlocksList.Clear();
}
}
foundElements.Clear();
}
private void GetSurroundingBlocksFromStaticGrids(MySlimBlock block, MyCubeSize cubeSizeEnum, HashSet <MyCubeBlock> outBlocks)
{
outBlocks.Clear();
BoundingBoxD boundingBox = new BoundingBoxD((Vector3D)((block.Min * block.CubeGrid.GridSize) - (block.CubeGrid.GridSize / 2f)), (block.Max * block.CubeGrid.GridSize) + (block.CubeGrid.GridSize / 2f));
if (block.FatBlock != null)
{
Matrix matrix;
boundingBox = block.FatBlock.Model.BoundingBox;
block.FatBlock.Orientation.GetMatrix(out matrix);
boundingBox = boundingBox.TransformFast(matrix);
boundingBox.Translate(boundingBox.Center);
}
boundingBox = boundingBox.TransformFast(block.CubeGrid.WorldMatrix);
boundingBox.Inflate((double)0.125);
List <VRage.Game.Entity.MyEntity> foundElements = new List <VRage.Game.Entity.MyEntity>();
Sandbox.Game.Entities.MyEntities.GetElementsInBox(ref boundingBox, foundElements);
int num = 0;
while (true)
{
while (true)
{
if (num >= foundElements.Count)
{
foundElements.Clear();
return;
}
MyCubeBlock item = foundElements[num] as MyCubeBlock;
if (((item != null) && (!ReferenceEquals(item.SlimBlock, block) && (item.CubeGrid.IsStatic && (item.CubeGrid.EnableSmallToLargeConnections && (item.CubeGrid.SmallToLargeConnectionsInitialized && (!ReferenceEquals(item.CubeGrid, block.CubeGrid) && ((item.CubeGrid.GridSizeEnum == cubeSizeEnum) && !(item is MyFracturedBlock)))))))) && !item.Components.Has <MyFractureComponentBase>())
{
MyCompoundCubeBlock block3 = item as MyCompoundCubeBlock;
if (block3 != null)
{
foreach (MySlimBlock block4 in block3.GetBlocks())
{
if (ReferenceEquals(block4, block))
{
continue;
}
if (!block4.FatBlock.Components.Has <MyFractureComponentBase>())
{
outBlocks.Add(block4.FatBlock);
}
}
break;
}
outBlocks.Add(item);
}
break;
}
num++;
}
}
/// <summary>
/// Writes all surrounding blocks around the given one with the given size.
/// </summary>
private void GetSurroundingBlocksFromStaticGrids(MySlimBlock block, MyCubeSize cubeSizeEnum, HashSet <MyCubeBlock> outBlocks)
{
outBlocks.Clear();
BoundingBoxD aabb = new BoundingBoxD(block.Min * block.CubeGrid.GridSize - block.CubeGrid.GridSize / 2, block.Max * block.CubeGrid.GridSize + block.CubeGrid.GridSize / 2);
if (block.FatBlock != null)
{
var aabbCenter = aabb.Center;
aabb = (BoundingBoxD)block.FatBlock.Model.BoundingBox;
Matrix m;
block.FatBlock.Orientation.GetMatrix(out m);
aabb = aabb.TransformFast(m);
aabb.Translate(aabbCenter);
}
aabb = aabb.TransformFast(block.CubeGrid.WorldMatrix);
aabb.Inflate(0.125);
List <MyEntity> boxOverlapList = new List <MyEntity>();
MyEntities.GetElementsInBox(ref aabb, boxOverlapList);
for (int i = 0; i < boxOverlapList.Count; i++)
{
var otherBlock = boxOverlapList[i] as MyCubeBlock;
if (otherBlock != null && otherBlock.SlimBlock != block &&
otherBlock.CubeGrid.IsStatic && otherBlock.CubeGrid.EnableSmallToLargeConnections && otherBlock.CubeGrid.SmallToLargeConnectionsInitialized &&
otherBlock.CubeGrid != block.CubeGrid && otherBlock.CubeGrid.GridSizeEnum == cubeSizeEnum && !(otherBlock is MyFracturedBlock) &&
!(otherBlock.Components.Has <MyFractureComponentBase>()))
{
var compound = otherBlock as MyCompoundCubeBlock;
if (compound != null)
{
foreach (var blockInCompound in compound.GetBlocks())
{
if (blockInCompound != block && !(blockInCompound.FatBlock.Components.Has <MyFractureComponentBase>()))
{
outBlocks.Add(blockInCompound.FatBlock);
}
}
}
else
{
outBlocks.Add(otherBlock);
}
}
}
boxOverlapList.Clear();
}
public override BoundingBoxD GetWorldBoundaries()
{
//return new BoundingBoxD(Center - Radius, Center + Radius);
var bbox = new BoundingBoxD(Center - Radius, Center + Radius);
return(bbox.TransformFast(Transformation));
}
public override BoundingBoxD PeekWorldBoundaries(ref Vector3D targetPosition)
{
MatrixD newTransformation = Transformation;
newTransformation.Translation = targetPosition;
var bbox = new BoundingBoxD(A - Radius, B + Radius);
return(bbox.TransformFast(newTransformation));
}
public override BoundingBoxD PeekWorldBoundaries(ref Vector3D targetPosition)
{
MatrixD transformation = base.Transformation;
transformation.Translation = targetPosition;
BoundingBoxD xd2 = new BoundingBoxD(this.A - this.Radius, this.B + this.Radius);
return(xd2.TransformFast(transformation));
}
public void Init(IMy2DClipmapManager parent, int x, int y, int lod, ref BoundingBox2D bounds)
{
m_manager = (MyPlanetEnvironmentComponent)parent;
var bounds3D = new BoundingBoxD(new Vector3D(bounds.Min, 0), new Vector3D(bounds.Max, 0));
Lod = lod;
Face = m_manager.ActiveFace;
var matrix = m_manager.ActiveClipmap.WorldMatrix;
bounds3D = bounds3D.TransformFast(matrix);
Coords = new Vector2I(x, y);
Id = MyPlanetSectorId.MakeSectorId(x, y, m_manager.ActiveFace, lod);
m_manager.RegisterProxy(this);
MyEnvironmentSectorParameters sectorParams;
matrix.Translation = Vector3D.Zero;
sectorParams.SurfaceBasisX = Vector3.Transform(new Vector3(bounds.Width / 2, 0, 0), matrix);
sectorParams.SurfaceBasisY = Vector3.Transform(new Vector3(0, bounds.Height / 2, 0), matrix);
sectorParams.Center = bounds3D.Center;
if (lod > m_manager.MaxLod) return;
if (!m_manager.TryGetSector(Id, out EnvironmentSector))
{
sectorParams.SectorId = Id;
sectorParams.EntityId = MyPlanetSectorId.MakeSectorId(x, y, m_manager.ActiveFace, lod);
sectorParams.Bounds = m_manager.GetBoundingShape(ref sectorParams.Center, ref sectorParams.SurfaceBasisX, ref sectorParams.SurfaceBasisY); ;
sectorParams.Environment = m_manager.EnvironmentDefinition;
sectorParams.DataRange = new BoundingBox2I(Coords << lod, ((Coords + 1) << lod) - 1);
sectorParams.Provider = m_manager.Providers[m_manager.ActiveFace];
EnvironmentSector = m_manager.EnvironmentDefinition.CreateSector();
EnvironmentSector.Init(m_manager, ref sectorParams);
m_manager.Planet.AddChildEntity((MyEntity)EnvironmentSector);
}
m_manager.EnqueueOperation(this, lod);
LodSet = lod;
EnvironmentSector.OnLodCommit += sector_OnMyLodCommit;
}
private bool QueryEmptyOrFull(int minX, int minY, int minZ, int maxX, int maxY, int maxZ)
{
BoundingBoxI box = new BoundingBoxI(new Vector3I(minX, minY, minZ), new Vector3I(maxX, maxY, maxZ));
if (box.Volume() < 100f)
{
return(false);
}
bool flag = this.m_voxelMap.Storage.Intersect(ref box, 0, true) != ContainmentType.Intersects;
BoundingBoxD xd = new BoundingBoxD(new Vector3((float)minX, (float)minY, (float)minZ) * 8f, new Vector3((float)maxX, (float)maxY, (float)maxZ) * 8f);
xd.TransformFast(base.Entity.WorldMatrix);
MyOrientedBoundingBoxD xd1 = new MyOrientedBoundingBoxD(xd, base.Entity.WorldMatrix);
MyRenderProxy.DebugDrawAABB(xd, flag ? Color.Green : Color.Red, 1f, 1f, false, false, false);
return(flag);
}
public static bool AnyBlocksInAABB(this MyGridDataComponent g, BoundingBoxD box)
{
var e = g.Entity;
if (e.PositionComp == null)
{
return(false);
}
if (box.Contains(e.PositionComp.WorldAABB) == ContainmentType.Contains)
{
return(g.BlockCount > 0);
}
var orientedBoundingBoxD = OrientedBoundingBoxD.Create(box, e.PositionComp.WorldMatrixNormalizedInv);
var sizeR = 1f / g.Size;
orientedBoundingBoxD.Center *= sizeR;
orientedBoundingBoxD.HalfExtent *= sizeR;
box = box.TransformFast(e.PositionComp.WorldMatrixNormalizedInv);
var min = box.Min;
var max = box.Max;
var obbPt1 = new Vector3I((int)Math.Round(min.X * sizeR), (int)Math.Round(min.Y * sizeR), (int)Math.Round(min.Z * sizeR));
var obbPt2 = new Vector3I((int)Math.Round(max.X * sizeR), (int)Math.Round(max.Y * sizeR), (int)Math.Round(max.Z * sizeR));
var obbMin = Vector3I.Min(obbPt1, obbPt2);
var obbMax = Vector3I.Max(obbPt1, obbPt2);
var start = Vector3I.Max(obbMin, g.Min);
var end = Vector3I.Min(obbMax, g.Max);
if (start.X > end.X || start.Y > end.Y || start.Z > end.Z)
{
return(false);
}
var vector3IRangeIterator = new Vector3I_RangeIterator(ref start, ref end);
var next = vector3IRangeIterator.Current;
while (vector3IRangeIterator.IsValid())
{
if (g.GetAnyBlock(next) != null)
{
return(true);
}
vector3IRangeIterator.GetNext(out next);
}
return(false);
}
/// <summary>
/// Checks if blocks are neigbors to block(s) in aabbForNeighbors.
/// </summary>
private static void CheckNeighborBlocks(MySlimBlock block, BoundingBoxD aabbForNeighbors, MyCubeGrid cubeGrid, List <MySlimBlock> blocks)
{
var compositeTransformToGrid = block.CubeGrid.WorldMatrix * cubeGrid.PositionComp.WorldMatrixNormalizedInv;
var aabbForNeighborsInGrid = aabbForNeighbors.TransformFast(ref compositeTransformToGrid);
Vector3I start = Vector3I.Round(cubeGrid.GridSizeR * aabbForNeighborsInGrid.Min);
Vector3I end = Vector3I.Round(cubeGrid.GridSizeR * aabbForNeighborsInGrid.Max);
Vector3I startIt = Vector3I.Min(start, end);
Vector3I endIt = Vector3I.Max(start, end);
for (int slimBlockIndex = blocks.Count - 1; slimBlockIndex >= 0; --slimBlockIndex)
{
var slimBlock = blocks[slimBlockIndex];
bool found = false;
Vector3I_RangeIterator itBlockInGridPos = new Vector3I_RangeIterator(ref slimBlock.Min, ref slimBlock.Max);
var posInGrid = itBlockInGridPos.Current;
for (; itBlockInGridPos.IsValid(); itBlockInGridPos.GetNext(out posInGrid))
{
Vector3I_RangeIterator itBlockPos = new Vector3I_RangeIterator(ref startIt, ref endIt);
var pos = itBlockPos.Current;
for (; itBlockPos.IsValid(); itBlockPos.GetNext(out pos))
{
Vector3I diff = Vector3I.Abs(posInGrid - pos);
if (pos == posInGrid || diff.X + diff.Y + diff.Z == 1)
{
found = true;
break;
}
}
if (found)
{
break;
}
}
if (!found)
{
blocks.RemoveAt(slimBlockIndex);
}
}
}
private bool QueryEmptyOrFull(int minX, int minY, int minZ, int maxX, int maxY, int maxZ)
{
////return false;
var bb = new BoundingBox(new Vector3(minX, minY, minZ), new Vector3(maxX, maxY, maxZ));
if (bb.Volume() < 100)
{
return(false);
}
//bb.Translate(m_voxelMap.StorageMin);
var result = m_voxelMap.Storage.Intersect(ref bb, false) != ContainmentType.Intersects;
{
var bbd = new BoundingBoxD(new Vector3(minX, minY, minZ) * 8, new Vector3(maxX, maxY, maxZ) * 8);
bbd.TransformFast(Entity.WorldMatrix);
var obb = new MyOrientedBoundingBoxD(bbd, Entity.WorldMatrix);
MyRenderProxy.DebugDrawAABB(bbd, result ? Color.Green : Color.Red, 1, 1, false);
}
return(result);
}
private unsafe void AddGridVerticesInsideOBB(MyCubeGrid grid, MyOrientedBoundingBoxD obb)
{
BoundingBoxD aABB = obb.GetAABB();
using (HashSet <MyGroups <MyCubeGrid, MyGridLogicalGroupData> .Node> .Enumerator enumerator = MyCubeGridGroups.Static.Logical.GetGroup(grid).Nodes.GetEnumerator())
{
while (enumerator.MoveNext())
{
MyCubeGrid nodeData = enumerator.Current.NodeData;
this.m_rdPathfinding.AddToTrackedGrids(nodeData);
MatrixD worldMatrix = nodeData.WorldMatrix;
MatrixD *xdPtr1 = (MatrixD *)ref worldMatrix;
xdPtr1.Translation -= this.m_center;
MatrixD xd3 = MatrixD.Transform(worldMatrix, this.rdWorldQuaternion);
if (MyPerGameSettings.Game == GameEnum.SE_GAME)
{
BoundingBoxD xd4 = aABB.TransformFast(nodeData.PositionComp.WorldMatrixNormalizedInv);
Vector3I vectori = new Vector3I((int)Math.Round(xd4.Min.X), (int)Math.Round(xd4.Min.Y), (int)Math.Round(xd4.Min.Z));
Vector3I vectori2 = new Vector3I((int)Math.Round(xd4.Max.X), (int)Math.Round(xd4.Max.Y), (int)Math.Round(xd4.Max.Z));
vectori = Vector3I.Min(vectori, vectori2);
vectori2 = Vector3I.Max(vectori, vectori2);
if (nodeData.Physics != null)
{
using (MyUtils.ReuseCollection <HkShape>(ref m_tmpShapes))
{
MyGridShape shape = nodeData.Physics.Shape;
using (MyGridShape.NativeShapeLock.AcquireSharedUsing())
{
shape.GetShapesInInterval(vectori, vectori2, m_tmpShapes);
foreach (HkShape shape2 in m_tmpShapes)
{
this.AddPhysicalShape(shape2, (Matrix)xd3);
}
}
}
}
}
}
}
}
public void Init(IMy2DClipmapManager parent, int x, int y, int lod, ref BoundingBox2D bounds)
{
m_parent = (SectorTreeComponent)parent;
Bounds = new BoundingBoxD(new Vector3D(bounds.Min, 0), new Vector3D(bounds.Max, 50));
Lod = lod;
var matrix = m_parent.m_tree[m_parent.m_activeClipmap].WorldMatrix;
Bounds = Bounds.TransformFast(matrix);
Coords = new Vector2I(x, y);
m_parent.m_handlers.Add(this);
var center = Bounds.Center;
// Sector Frustum
Vector3D[] v = new Vector3D[8];
v[0] = Vector3D.Transform(new Vector3D(bounds.Min.X, bounds.Min.Y, 0), matrix);
v[1] = Vector3D.Transform(new Vector3D(bounds.Max.X, bounds.Min.Y, 0), matrix);
v[2] = Vector3D.Transform(new Vector3D(bounds.Min.X, bounds.Max.Y, 0), matrix);
v[3] = Vector3D.Transform(new Vector3D(bounds.Max.X, bounds.Max.Y, 0), matrix);
for (int i = 0; i < 4; ++i)
{
//v[i] -= WorldMatrix.Translation;
v[i].Normalize();
v[i + 4] = v[i] * m_parent.Radius;
v[i] *= m_parent.Radius + 50;
//v[i] += WorldMatrix.Translation;
//v[i + 4] += WorldMatrix.Translation;
}
FrustumBounds = v;
}
//public static bool TestPlacementAreaWithEntities(MyCubeGrid targetGrid, bool targetGridIsStatic, ref MyGridPlacementSettings settings, BoundingBoxD localAabb, bool dynamicBuildMode, MyEntity ignoredEntity = null)
//{
// ProfilerShort.Begin("Test start with entities");
// var worldMatrix = targetGrid.WorldMatrix;
// Vector3 halfExtents = localAabb.HalfExtents;
// halfExtents += settings.SearchHalfExtentsDeltaAbsolute; //this works for SE
// if (MyFakes.ENABLE_BLOCK_PLACING_IN_OCCUPIED_AREA)
// halfExtents -= new Vector3D(GRID_PLACING_AREA_FIX_VALUE);
// Vector3D translation = localAabb.Transform(ref worldMatrix).Center;
// Quaternion quaternion = Quaternion.CreateFromRotationMatrix(worldMatrix);
// quaternion.Normalize();
// ProfilerShort.End();
// ProfilerShort.Begin("get top most entities");
// m_tmpResultList.Clear();
// BoundingBoxD box = targetGrid.PositionComp.WorldAABB;
// MyGamePruningStructure.GetTopMostEntitiesInBox(ref box, m_tmpResultList);
// ProfilerShort.End();
// return TestPlacementAreaInternalWithEntities(targetGrid, targetGridIsStatic, ref settings, ref localAabb, ignoredEntity, ref worldMatrix, dynamicBuildMode: dynamicBuildMode);
//}
public static bool TestPlacementArea(MyCubeGrid targetGrid, bool targetGridIsStatic, ref MyGridPlacementSettings settings, BoundingBoxD localAabb, bool dynamicBuildMode, MyEntity ignoredEntity = null, bool testVoxel = true)
{
ProfilerShort.Begin("TestStart");
var worldMatrix = targetGrid.WorldMatrix;
Vector3 halfExtents = localAabb.HalfExtents;
halfExtents += settings.SearchHalfExtentsDeltaAbsolute; //this works for SE
if (MyFakes.ENABLE_BLOCK_PLACING_IN_OCCUPIED_AREA)
halfExtents -= new Vector3D(GRID_PLACING_AREA_FIX_VALUE);
Vector3D translation = localAabb.TransformFast(ref worldMatrix).Center;
Quaternion quaternion = Quaternion.CreateFromRotationMatrix(worldMatrix);
quaternion.Normalize();
ProfilerShort.End();
ProfilerShort.Begin("VoxelOverlap");
if (testVoxel && settings.VoxelPlacement.Value.PlacementMode != VoxelPlacementMode.Both)
{
bool result = IsAabbInsideVoxel(worldMatrix, localAabb, settings);
if (settings.VoxelPlacement.Value.PlacementMode == VoxelPlacementMode.InVoxel)
result = !result;
if (result)
{
ProfilerShort.End();
return false;
}
}
ProfilerShort.End();
ProfilerShort.Begin("Havok.GetPenetrationsBox");
Debug.Assert(m_physicsBoxQueryList.Count == 0, "List not cleared");
MyPhysics.GetPenetrationsBox(ref halfExtents, ref translation, ref quaternion, m_physicsBoxQueryList, MyPhysics.CollisionLayers.NoVoxelCollisionLayer);
m_lastQueryBox.HalfExtents = halfExtents;
m_lastQueryTransform = MatrixD.CreateFromQuaternion(quaternion);
m_lastQueryTransform.Translation = translation;
ProfilerShort.End();
MyCubeGrid touchingGrid;
return TestPlacementAreaInternal(targetGrid, targetGridIsStatic, ref settings, null, null, ref localAabb, ignoredEntity, ref worldMatrix, out touchingGrid, dynamicBuildMode);
}
/// <summary>
/// Calculates amount of volume of a bounding box in voxels.
/// </summary>
/// <param name="localAabb">Local bounding box to query for.</param>
/// <param name="worldMatrix">World matrix of the bounding box.</param>
/// <returns>Pair of floats where 1st value is Volume amount and 2nd value is ratio of Volume amount to Whole volume.</returns>
public MyTuple <float, float> GetVoxelContentInBoundingBox_Fast(BoundingBoxD localAabb, MatrixD worldMatrix)
{
MatrixD toVoxel = worldMatrix * PositionComp.WorldMatrixNormalizedInv;
MatrixD toGrid; MatrixD.Invert(ref toVoxel, out toGrid);
BoundingBoxD transAABB = localAabb.TransformFast(toVoxel);
transAABB.Translate(SizeInMetresHalf + StorageMin);
Vector3I minI = Vector3I.Floor(transAABB.Min);
Vector3I maxI = Vector3I.Ceiling(transAABB.Max);
double vol = localAabb.Volume / MyVoxelConstants.VOXEL_VOLUME_IN_METERS;
int K = Math.Max((MathHelper.Log2Ceiling((int)vol) - MathHelper.Log2Ceiling(100)) / 3, 0);
float voxelSizeAtLod = MyVoxelConstants.VOXEL_SIZE_IN_METRES * (1 << K);
float voxelVolumeAtLod = voxelSizeAtLod * voxelSizeAtLod * voxelSizeAtLod;
minI >>= K;
maxI >>= K;
// localAabb.Inflate(1 * voxelSizeAtLod);
var offset = ((Size >> 1) + StorageMin) >> K;
m_tempStorage.Resize(maxI - minI + 1);
Storage.ReadRange(m_tempStorage, MyStorageDataTypeFlags.Content, K, minI, maxI);
float resultVolume = 0;
float resultPercent = 0;
int hitVolumeBoxes = 0;
MyOrientedBoundingBoxD worldbbox = new MyOrientedBoundingBoxD(localAabb, worldMatrix);
Vector3I coord, cache;
for (coord.Z = minI.Z, cache.Z = 0; coord.Z <= maxI.Z; coord.Z++, cache.Z++)
{
for (coord.Y = minI.Y, cache.Y = 0; coord.Y <= maxI.Y; coord.Y++, cache.Y++)
{
for (coord.X = minI.X, cache.X = 0; coord.X <= maxI.X; coord.X++, cache.X++)
{
Vector3D voxelPos = (coord - offset) * voxelSizeAtLod;
Vector3D gridPoint;
Vector3D.Transform(ref voxelPos, ref toGrid, out gridPoint);
ContainmentType cont;
//localAabb.Contains(ref gridPoint, out cont);
var voxelToWorld = WorldMatrix;
voxelToWorld.Translation -= (Vector3D)StorageMin + SizeInMetresHalf;
BoundingBoxD voxelBox = new BoundingBoxD();
voxelBox.Min = ((Vector3D)(coord) - .5) * voxelSizeAtLod;
voxelBox.Max = ((Vector3D)(coord) + .5) * voxelSizeAtLod;
MyOrientedBoundingBoxD voxelBbox = new MyOrientedBoundingBoxD(voxelBox, voxelToWorld);
cont = worldbbox.Contains(ref voxelBbox);
if (cont == ContainmentType.Disjoint)
{
//VRageRender.MyRenderProxy.DebugDrawOBB(
//new MyOrientedBoundingBoxD(voxelBox, voxelToWorld), Color.Red, 0.1f,
//true, false);
continue;
}
float content = m_tempStorage.Content(ref cache) / MyVoxelConstants.VOXEL_CONTENT_FULL_FLOAT;
//VRageRender.MyRenderProxy.DebugDrawOBB(voxelBbox, Color.Aqua, content,
// true, false);
resultVolume += content * voxelVolumeAtLod;
resultPercent += content;
hitVolumeBoxes++;
}
}
}
resultPercent /= hitVolumeBoxes;
//float localAABBVol = (float)localAabb.Volume;
//if (localAABBVol < resultVolume)
// resultPercent *= (float)localAabb.Volume / resultVolume;
//VRageRender.MyRenderProxy.DebugDrawOBB(worldbbox, Color.Yellow, 0,
// true, false);
//VRageRender.MyRenderProxy.DebugWaitForFrameFinish();
return(new MyTuple <float, float>(resultVolume, resultPercent));
}
/// <summary>
/// Calculates amount of volume of a bounding box in voxels.
/// </summary>
/// <param name="localAabb">Local bounding box to query for.</param>
/// <param name="worldMatrix">World matrix of the bounding box.</param>
/// <returns>Pair of floats where 1st value is Volume amount and 2nd value is ratio of Volume amount to Whole volume.</returns>
public MyTuple<float,float> GetVoxelContentInBoundingBox_Fast(BoundingBoxD localAabb, MatrixD worldMatrix)
{
MatrixD toVoxel = worldMatrix * PositionComp.WorldMatrixNormalizedInv;
MatrixD toGrid; MatrixD.Invert(ref toVoxel, out toGrid);
BoundingBoxD transAABB = localAabb.TransformFast(toVoxel);
transAABB.Translate(SizeInMetresHalf + StorageMin);
Vector3I minI = Vector3I.Floor(transAABB.Min);
Vector3I maxI = Vector3I.Ceiling(transAABB.Max);
double vol = localAabb.Volume / MyVoxelConstants.VOXEL_VOLUME_IN_METERS;
int K = Math.Max((MathHelper.Log2Ceiling((int)vol) - MathHelper.Log2Ceiling(100)) / 3, 0);
float voxelSizeAtLod = MyVoxelConstants.VOXEL_SIZE_IN_METRES * (1 << K);
float voxelVolumeAtLod = voxelSizeAtLod * voxelSizeAtLod * voxelSizeAtLod;
minI >>= K;
maxI >>= K;
// localAabb.Inflate(1 * voxelSizeAtLod);
var offset = ((Size >> 1) + StorageMin) >> K;
m_tempStorage.Resize(maxI - minI + 1);
Storage.ReadRange(m_tempStorage, MyStorageDataTypeFlags.Content, K, minI, maxI);
float resultVolume = 0;
float resultPercent = 0;
int hitVolumeBoxes = 0;
MyOrientedBoundingBoxD worldbbox = new MyOrientedBoundingBoxD(localAabb, worldMatrix);
Vector3I coord, cache;
for (coord.Z = minI.Z, cache.Z = 0; coord.Z <= maxI.Z; coord.Z++, cache.Z++)
{
for (coord.Y = minI.Y, cache.Y = 0; coord.Y <= maxI.Y; coord.Y++, cache.Y++)
{
for (coord.X = minI.X, cache.X = 0; coord.X <= maxI.X; coord.X++, cache.X++)
{
Vector3D voxelPos = (coord - offset) * voxelSizeAtLod;
Vector3D gridPoint;
Vector3D.Transform(ref voxelPos, ref toGrid, out gridPoint);
ContainmentType cont;
//localAabb.Contains(ref gridPoint, out cont);
var voxelToWorld = WorldMatrix;
voxelToWorld.Translation -= (Vector3D)StorageMin + SizeInMetresHalf;
BoundingBoxD voxelBox = new BoundingBoxD();
voxelBox.Min = ((Vector3D)(coord) - .5) * voxelSizeAtLod;
voxelBox.Max = ((Vector3D)(coord) + .5) * voxelSizeAtLod;
MyOrientedBoundingBoxD voxelBbox = new MyOrientedBoundingBoxD(voxelBox, voxelToWorld);
cont = worldbbox.Contains(ref voxelBbox);
if (cont == ContainmentType.Disjoint)
{
//VRageRender.MyRenderProxy.DebugDrawOBB(
//new MyOrientedBoundingBoxD(voxelBox, voxelToWorld), Color.Red, 0.1f,
//true, false);
continue;
}
float content = m_tempStorage.Content(ref cache) / MyVoxelConstants.VOXEL_CONTENT_FULL_FLOAT;
//VRageRender.MyRenderProxy.DebugDrawOBB(voxelBbox, Color.Aqua, content,
// true, false);
resultVolume += content * voxelVolumeAtLod;
resultPercent += content;
hitVolumeBoxes++;
}
}
}
resultPercent /= hitVolumeBoxes;
//float localAABBVol = (float)localAabb.Volume;
//if (localAABBVol < resultVolume)
// resultPercent *= (float)localAabb.Volume / resultVolume;
//VRageRender.MyRenderProxy.DebugDrawOBB(worldbbox, Color.Yellow, 0,
// true, false);
//VRageRender.MyRenderProxy.DebugWaitForFrameFinish();
return new MyTuple<float, float>(resultVolume, resultPercent);
}
public void UpdateWorldAABB(out BoundingBoxD worldAabb)
{
worldAabb = m_localAABB.TransformFast(ref m_worldMatrix);
m_worldAABB = worldAabb;
}
public static bool TestPlacementVoxelMapOverlap(
MyVoxelBase voxelMap,
ref MyGridPlacementSettings settings,
ref BoundingBoxD localAabb,
ref MatrixD worldMatrix,
bool touchingStaticGrid = false)
{
ProfilerShort.Begin("TestPlacementVoxelMapOverlap");
var worldAabb = localAabb.TransformFast(ref worldMatrix);
const int IntersectsOrInside = 1;
const int Outside = 2;
int overlapState = Outside;
if (voxelMap == null)
voxelMap = MySession.Static.VoxelMaps.GetVoxelMapWhoseBoundingBoxIntersectsBox(ref worldAabb, null);
if (voxelMap != null && voxelMap.IsAnyAabbCornerInside(ref worldMatrix, localAabb))
{
overlapState = IntersectsOrInside;
}
bool testPassed = true;
switch (overlapState)
{
case IntersectsOrInside:
testPassed = settings.VoxelPlacement.Value.PlacementMode == VoxelPlacementMode.Both;
break;
case Outside:
testPassed = settings.VoxelPlacement.Value.PlacementMode == VoxelPlacementMode.OutsideVoxel || (settings.CanAnchorToStaticGrid && touchingStaticGrid);
break;
default:
Debug.Fail("Invalid branch.");
break;
}
ProfilerShort.End();
return testPassed;
}
private static bool TestPlacementAreaInternalWithEntities(MyCubeGrid targetGrid,
bool targetGridIsStatic,
ref MyGridPlacementSettings settings,
ref BoundingBoxD localAabb,
MyEntity ignoredEntity,
ref MatrixD worldMatrix,
bool dynamicBuildMode = false)
{
ProfilerShort.Begin("TestPlacementAreaInternalWithEntities");
MyCubeGrid touchingGrid = null;
float gridSize = targetGrid.GridSize;
bool isStatic = targetGridIsStatic;
var worldAabb = localAabb.TransformFast(ref worldMatrix);
bool entityOverlap = false;
MyVoxelBase overlappedVoxelMap = null;
bool touchingStaticGrid = false;
foreach (var entity in m_tmpResultList)
{
if (ignoredEntity != null && (entity == ignoredEntity || entity.GetTopMostParent() == ignoredEntity))
continue;
var body = entity.Physics;
if (body == null)
continue;
var grid = entity as MyCubeGrid;
if (grid != null)
{
// Small on large (or large on small) always possible
if (isStatic == grid.IsStatic && gridSize != grid.GridSize)
continue;
TestGridPlacement(ref settings, ref worldMatrix, ref touchingGrid, gridSize, isStatic, ref localAabb, null, null, ref entityOverlap, ref touchingStaticGrid, grid);
if (entityOverlap)
{
break;
}
}
else
{
var character = entity as MyCharacter;
if (character != null && character.PositionComp.WorldAABB.Intersects(targetGrid.PositionComp.WorldAABB))
{
entityOverlap = true;
break;
}
}
}
m_tmpResultList.Clear();
ProfilerShort.End();
if (entityOverlap)
return false;
if (targetGrid.IsStatic)
{
return true;
}
return true;
}
/// <summary>
/// Returns world AABB of the block (geometry AABB). If useAABBFromBlockCubes = true then AABB from block cubes is returned.
/// </summary>
public void GetWorldBoundingBox(out BoundingBoxD aabb, bool useAABBFromBlockCubes = false)
{
if (FatBlock != null && !useAABBFromBlockCubes)
{
aabb = FatBlock.PositionComp.WorldAABB;
}
else
{
float gridSize = CubeGrid.GridSize;
aabb = new BoundingBoxD(Min * gridSize - gridSize / 2, Max * gridSize + gridSize / 2);
aabb = aabb.TransformFast(CubeGrid.WorldMatrix);
}
}
public override BoundingBoxD GetWorldBoundaries()
{
var bbox = new BoundingBoxD(A - Radius, B + Radius);
return bbox.TransformFast(Transformation);
}
public override BoundingBoxD GetWorldBoundaries()
{
return(Boundaries.TransformFast(Transformation));
}
/// <summary>
/// Writes all surrounding blocks around the given one with the given size.
/// </summary>
private void GetSurroundingBlocksFromStaticGrids(MySlimBlock block, MyCubeSize cubeSizeEnum, HashSet <MySlimBlock> outBlocks)
{
outBlocks.Clear();
BoundingBoxD aabbForNeighbors = new BoundingBoxD(block.Min * block.CubeGrid.GridSize, block.Max * block.CubeGrid.GridSize);
BoundingBoxD aabb = new BoundingBoxD(block.Min * block.CubeGrid.GridSize - block.CubeGrid.GridSize / 2, block.Max * block.CubeGrid.GridSize + block.CubeGrid.GridSize / 2);
if (block.FatBlock != null)
{
var aabbCenter = aabb.Center;
aabb = (BoundingBoxD)block.FatBlock.Model.BoundingBox;
Matrix m;
block.FatBlock.Orientation.GetMatrix(out m);
aabb = aabb.TransformFast(m);
aabb.Translate(aabbCenter);
}
aabb.Inflate(0.125);
var aabbWorld = aabb.TransformFast(block.CubeGrid.WorldMatrix);
List <MyEntity> boxOverlapList = new List <MyEntity>();
MyEntities.GetElementsInBox(ref aabbWorld, boxOverlapList);
for (int i = 0; i < boxOverlapList.Count; i++)
{
var cubeGrid = boxOverlapList[i] as MyCubeGrid;
if (cubeGrid != null)
{
if (cubeGrid.IsStatic && cubeGrid != block.CubeGrid && cubeGrid.EnableSmallToLargeConnections && cubeGrid.SmallToLargeConnectionsInitialized &&
cubeGrid.GridSizeEnum == cubeSizeEnum)
{
Debug.Assert(m_tmpSlimBlocksList.Count == 0);
m_tmpSlimBlocksList.Clear();
cubeGrid.GetBlocksIntersectingOBB(aabb, block.CubeGrid.WorldMatrix, m_tmpSlimBlocksList);
CheckNeighborBlocks(block, aabbForNeighbors, cubeGrid, m_tmpSlimBlocksList);
foreach (var slimBlock in m_tmpSlimBlocksList)
{
if (slimBlock.FatBlock != null)
{
if (slimBlock.FatBlock is MyFracturedBlock)
{
continue;
}
if (slimBlock.FatBlock.Components.Has <MyFractureComponentBase>())
{
continue;
}
if (slimBlock.FatBlock is MyCompoundCubeBlock)
{
foreach (var blockInCompound in (slimBlock.FatBlock as MyCompoundCubeBlock).GetBlocks())
{
if (!(blockInCompound.FatBlock.Components.Has <MyFractureComponentBase>()))
{
outBlocks.Add(blockInCompound);
}
}
}
else
{
outBlocks.Add(slimBlock);
}
}
else
{
outBlocks.Add(slimBlock);
}
}
m_tmpSlimBlocksList.Clear();
}
}
}
boxOverlapList.Clear();
}
public override BoundingBoxD GetWorldBoundaries()
{
var bbox = new BoundingBoxD(A - Radius, B + Radius);
return(bbox.TransformFast(Transformation));
}
private bool QueryEmptyOrFull(int minX, int minY, int minZ, int maxX, int maxY, int maxZ)
{
////return false;
var bb = new BoundingBox(new Vector3(minX, minY, minZ), new Vector3(maxX, maxY, maxZ));
if (bb.Volume() < 100)
return false;
//bb.Translate(m_voxelMap.StorageMin);
var result = m_voxelMap.Storage.Intersect(ref bb, false) != ContainmentType.Intersects;
{
var bbd = new BoundingBoxD(new Vector3(minX, minY, minZ) * 8, new Vector3(maxX, maxY, maxZ) * 8);
bbd.TransformFast(Entity.WorldMatrix);
var obb = new MyOrientedBoundingBoxD(bbd, Entity.WorldMatrix);
MyRenderProxy.DebugDrawAABB(bbd, result ? Color.Green : Color.Red, 1, 1, false);
}
return result;
}
/// <summary>
/// Checks if aabb is in voxel. If settings provided it will return false if penetration settings allow for it.
/// </summary>
/// <param name="worldMatrix">World matrix of the aabb.</param>
/// <param name="localAabb">Local aabb</param>
/// <param name="settings">Game settings</param>
/// <returns></returns>
public static bool IsAabbInsideVoxel(MatrixD worldMatrix, BoundingBoxD localAabb, MyGridPlacementSettings settings)
{
var worldAabb = localAabb.TransformFast(ref worldMatrix);
List<MyVoxelBase> voxels = new List<MyVoxelBase>();
MyGamePruningStructure.GetAllVoxelMapsInBox(ref worldAabb, voxels);
foreach (MyVoxelBase voxel in voxels)
{
if (settings.VoxelPlacement.Value.PlacementMode != VoxelPlacementMode.Volumetric && voxel.IsAnyAabbCornerInside(ref worldMatrix, localAabb))
return true;
if (settings.VoxelPlacement.Value.PlacementMode == VoxelPlacementMode.Volumetric && !TestPlacementVoxelMapPenetration(voxel, settings, ref localAabb, ref worldMatrix))
return true;
}
return false;
}
public static bool TestBlockPlacementArea(MyCubeBlockDefinition blockDefinition, MyBlockOrientation? blockOrientation, MatrixD worldMatrix, ref MyGridPlacementSettings settings, BoundingBoxD localAabb, bool dynamicBuildMode,
MyEntity ignoredEntity = null, bool testVoxel = true)
{
ProfilerShort.Begin("TestStart");
Vector3 halfExtents = localAabb.HalfExtents;
halfExtents += settings.SearchHalfExtentsDeltaAbsolute; //this works for SE
if (MyFakes.ENABLE_BLOCK_PLACING_IN_OCCUPIED_AREA)
halfExtents -= new Vector3D(GRID_PLACING_AREA_FIX_VALUE);
Vector3D translation = localAabb.TransformFast(ref worldMatrix).Center;
Quaternion quaternion = Quaternion.CreateFromRotationMatrix(worldMatrix);
quaternion.Normalize();
ProfilerShort.End();
ProfilerShort.Begin("VoxelOverlap");
// copy settings so we wont override original one.
MyGridPlacementSettings settingsCopy = settings;
if (testVoxel && !TestVoxelPlacement(blockDefinition, settingsCopy, dynamicBuildMode, worldMatrix, localAabb))
return false;
ProfilerShort.End();
ProfilerShort.Begin("Havok.GetPenetrationsBox");
Debug.Assert(m_physicsBoxQueryList.Count == 0, "List not cleared");
MyPhysics.GetPenetrationsBox(ref halfExtents, ref translation, ref quaternion, m_physicsBoxQueryList, MyPhysics.CollisionLayers.NoVoxelCollisionLayer);
m_lastQueryBox.HalfExtents = halfExtents;
m_lastQueryTransform = MatrixD.CreateFromQuaternion(quaternion);
m_lastQueryTransform.Translation = translation;
ProfilerShort.End();
MyCubeGrid touchingGrid;
return TestPlacementAreaInternal(null, ref settingsCopy, blockDefinition, blockOrientation, ref localAabb, ignoredEntity, ref worldMatrix, out touchingGrid, dynamicBuildMode: dynamicBuildMode);
}
internal override void DebugDraw(ref MatrixD worldTranslation, Color color)
{
BoundingBoxD xd = new BoundingBoxD(this.m_translation - this.m_halfExtents, this.m_translation + this.m_halfExtents);
MyRenderProxy.DebugDrawAABB(xd.TransformFast((MatrixD)worldTranslation), color, 0.5f, 1f, false, false, false);
}
private static void TestGridPlacement(ref MyGridPlacementSettings settings, ref MatrixD worldMatrix, ref MyCubeGrid touchingGrid, float gridSize, bool isStatic, ref BoundingBoxD localAABB, MyCubeBlockDefinition blockDefinition,
MyBlockOrientation? blockOrientation, ref bool entityOverlap, ref bool touchingStaticGrid, MyCubeGrid grid)
{
var worldAabb = localAABB.TransformFast(ref worldMatrix);
var invWorldMatrix = grid.PositionComp.WorldMatrixNormalizedInv;
var otherLocalAabb = worldAabb.TransformFast(ref invWorldMatrix);
Vector3D minToWorld = Vector3D.Transform(localAABB.Min, worldMatrix);
Vector3D maxToWorld = Vector3D.Transform(localAABB.Max, worldMatrix);
Vector3D tempMinLocal = Vector3D.Transform(minToWorld, invWorldMatrix);
Vector3D tempMaxLocal = Vector3D.Transform(maxToWorld, invWorldMatrix);
Vector3D otherMinLocal = Vector3D.Min(tempMinLocal, tempMaxLocal);
Vector3D otherMaxLocal = Vector3D.Max(tempMinLocal, tempMaxLocal);
var scaledMin = (otherMinLocal + gridSize / 2) / grid.GridSize;
var scaledMax = (otherMaxLocal - gridSize / 2) / grid.GridSize;
var tempMin = Vector3I.Round(scaledMin);
var tempMax = Vector3I.Round(scaledMax);
var min = Vector3I.Min(tempMin, tempMax);
var max = Vector3I.Max(tempMin, tempMax);
MyBlockOrientation? gridBlockOrientation = null;
if (MyFakes.ENABLE_COMPOUND_BLOCKS && isStatic && grid.IsStatic && blockOrientation != null)
{
Matrix blockRotation;
blockOrientation.Value.GetMatrix(out blockRotation);
Matrix rotationInGrid = blockRotation * worldMatrix;
rotationInGrid = rotationInGrid * invWorldMatrix;
rotationInGrid.Translation = Vector3.Zero;
Base6Directions.Direction forwardDir = Base6Directions.GetForward(ref rotationInGrid);
Base6Directions.Direction upDir = Base6Directions.GetUp(ref rotationInGrid);
if (Base6Directions.IsValidBlockOrientation(forwardDir, upDir))
gridBlockOrientation = new MyBlockOrientation(forwardDir, upDir);
}
if (!grid.CanAddCubes(min, max, gridBlockOrientation, blockDefinition))
{
entityOverlap = true;
return;
}
if (settings.CanAnchorToStaticGrid && grid.IsTouchingAnyNeighbor(min, max))
{
touchingStaticGrid = true;
if (touchingGrid == null)
touchingGrid = grid;
}
}
private static void CheckNeighborBlocks(MySlimBlock block, BoundingBoxD aabbForNeighbors, MyCubeGrid cubeGrid, List <MySlimBlock> blocks)
{
MatrixD m = block.CubeGrid.WorldMatrix * cubeGrid.PositionComp.WorldMatrixNormalizedInv;
BoundingBoxD xd2 = aabbForNeighbors.TransformFast(ref m);
Vector3I vectori = Vector3I.Round((Vector3D)(cubeGrid.GridSizeR * xd2.Max));
Vector3I vectori1 = Vector3I.Round((Vector3D)(cubeGrid.GridSizeR * xd2.Min));
Vector3I start = Vector3I.Min(vectori1, vectori);
Vector3I end = Vector3I.Max(vectori1, vectori);
int index = blocks.Count - 1;
while (true)
{
bool flag;
while (true)
{
if (index < 0)
{
return;
}
MySlimBlock block2 = blocks[index];
flag = false;
Vector3I_RangeIterator iterator = new Vector3I_RangeIterator(ref block2.Min, ref block2.Max);
Vector3I current = iterator.Current;
while (true)
{
if (!iterator.IsValid())
{
break;
}
Vector3I_RangeIterator iterator2 = new Vector3I_RangeIterator(ref start, ref end);
Vector3I next = iterator2.Current;
while (true)
{
if (iterator2.IsValid())
{
Vector3I vectori6 = Vector3I.Abs(current - next);
if ((next != current) && (((vectori6.X + vectori6.Y) + vectori6.Z) != 1))
{
iterator2.GetNext(out next);
continue;
}
flag = true;
}
if (flag)
{
break;
}
else
{
iterator.GetNext(out current);
}
break;
}
}
break;
}
if (!flag)
{
blocks.RemoveAt(index);
}
index--;
}
}
private void AddVoxelMesh(MyVoxelBase voxelBase, IMyStorage storage, Dictionary <Vector3I, MyIsoMesh> cache, float border, Vector3D originPosition, MyOrientedBoundingBoxD obb, List <BoundingBoxD> bbList)
{
bool useCache = cache != null;
if (useCache)
{
CheckCacheValidity();
}
obb.HalfExtent += new Vector3D(border, 0, border);
BoundingBoxD bb = obb.GetAABB();
int aabbSideSide = (int)Math.Round(bb.HalfExtents.Max() * 2);
bb = new BoundingBoxD(bb.Min, bb.Min + aabbSideSide);
bb.Translate(obb.Center - bb.Center);
// For debug
bbList.Add(new BoundingBoxD(bb.Min, bb.Max));
bb = (BoundingBoxD)bb.TransformFast(voxelBase.PositionComp.WorldMatrixInvScaled);
bb.Translate(voxelBase.SizeInMetresHalf);
Vector3I min = Vector3I.Round(bb.Min);
Vector3I max = min + aabbSideSide;
Vector3I geomMin, geomMax;
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref min, out geomMin);
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref max, out geomMax);
var cullBox = obb;
cullBox.Transform(voxelBase.PositionComp.WorldMatrixInvScaled);
cullBox.Center += voxelBase.SizeInMetresHalf;
ProfilerShort.Begin("WOOOORK");
Vector3I_RangeIterator it = new Vector3I_RangeIterator(ref geomMin, ref geomMax);
MyCellCoord coord = new MyCellCoord();
BoundingBox localAabb;
coord.Lod = NAVMESH_LOD;
int hits = 0;
MyIsoMesh gMesh;
Vector3 offset = originPosition - voxelBase.PositionLeftBottomCorner;
// Calculate rotation
Vector3 gravityVector = -Vector3.Normalize(GameSystems.MyGravityProviderSystem.CalculateTotalGravityInPoint(originPosition));
Vector3 forwardVector = Vector3.CalculatePerpendicularVector(gravityVector);
Quaternion quaternion = Quaternion.CreateFromForwardUp(forwardVector, gravityVector);
Matrix rotation = Matrix.CreateFromQuaternion(Quaternion.Inverse(quaternion));
Matrix ownRotation = voxelBase.PositionComp.WorldMatrix.GetOrientation();
while (it.IsValid())
{
ProfilerShort.Begin("ITERATOR");
if (useCache && cache.TryGetValue(it.Current, out gMesh))
{
if (gMesh != null)
{
AddMeshTriangles(gMesh, offset, rotation, ownRotation);
}
it.MoveNext();
ProfilerShort.End();
continue;
}
coord.CoordInLod = it.Current;
MyVoxelCoordSystems.GeometryCellCoordToLocalAABB(ref coord.CoordInLod, out localAabb);
if (!cullBox.Intersects(ref localAabb))
{
hits++;
it.MoveNext();
ProfilerShort.End();
continue;
}
ProfilerShort.End();
var debugBB = new BoundingBoxD(localAabb.Min, localAabb.Max).Translate(-voxelBase.SizeInMetresHalf);
bbList.Add(debugBB);
ProfilerShort.Begin("Mesh Calc");
var voxelStart = coord.CoordInLod * MyVoxelConstants.GEOMETRY_CELL_SIZE_IN_VOXELS - 1;
var voxelEnd = voxelStart + MyVoxelConstants.GEOMETRY_CELL_SIZE_IN_VOXELS //- 1
+ 1 // overlap to neighbor so geometry is stitched together within same LOD
+ 1; // for eg. 9 vertices in row we need 9 + 1 samples (voxels)
var generatedMesh = MyPrecalcComponent.IsoMesher.Precalc(storage, NAVMESH_LOD, voxelStart, voxelEnd, false, false, true);
ProfilerShort.End();
if (useCache)
{
cache[it.Current] = generatedMesh;
}
if (generatedMesh != null)
{
ProfilerShort.Begin("Mesh NOT NULL");
AddMeshTriangles(generatedMesh, offset, rotation, ownRotation);
ProfilerShort.End();
}
it.MoveNext();
}
ProfilerShort.End();
}
public static BoundingBoxD GetWorldBoundariesForSphere(BoundingSphereD Sphere)
{
BoundingBoxD boundingBoxD = new BoundingBoxD(Sphere.Center - Sphere.Radius, Sphere.Center + Sphere.Radius);
return(boundingBoxD.TransformFast(MatrixD.Identity));
}
public override BoundingBoxD GetWorldBoundaries()
{
//return new BoundingBoxD(Center - Radius, Center + Radius);
var bbox = new BoundingBoxD(Center - Radius, Center + Radius);
return bbox.TransformFast(Transformation);
}
private unsafe void AddVoxelMesh(MyVoxelBase voxelBase, IMyStorage storage, Dictionary <Vector3I, MyIsoMesh> cache, float border, Vector3D originPosition, MyOrientedBoundingBoxD obb, List <BoundingBoxD> bbList)
{
Vector3I vectori3;
Vector3I vectori4;
bool flag = cache != null;
if (flag)
{
this.CheckCacheValidity();
}
Vector3D *vectordPtr1 = (Vector3D *)ref obb.HalfExtent;
vectordPtr1[0] += new Vector3D((double)border, 0.0, (double)border);
BoundingBoxD aABB = obb.GetAABB();
int num = (int)Math.Round((double)(aABB.HalfExtents.Max() * 2.0));
BoundingBoxD *xdPtr1 = (BoundingBoxD *)ref aABB;
xdPtr1 = (BoundingBoxD *)new BoundingBoxD(aABB.Min, aABB.Min + num);
((BoundingBoxD *)ref aABB).Translate(obb.Center - aABB.Center);
bbList.Add(new BoundingBoxD(aABB.Min, aABB.Max));
aABB = aABB.TransformFast(voxelBase.PositionComp.WorldMatrixInvScaled);
aABB.Translate(voxelBase.SizeInMetresHalf);
Vector3I voxelCoord = Vector3I.Round(aABB.Min);
Vector3I vectori2 = (Vector3I)(voxelCoord + num);
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref voxelCoord, out vectori3);
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref vectori2, out vectori4);
MyOrientedBoundingBoxD xd2 = obb;
xd2.Transform(voxelBase.PositionComp.WorldMatrixInvScaled);
Vector3D *vectordPtr2 = (Vector3D *)ref xd2.Center;
vectordPtr2[0] += voxelBase.SizeInMetresHalf;
Vector3I_RangeIterator iterator = new Vector3I_RangeIterator(ref vectori3, ref vectori4);
MyCellCoord coord = new MyCellCoord {
Lod = 0
};
int num2 = 0;
Vector3 offset = (Vector3)(originPosition - voxelBase.PositionLeftBottomCorner);
Vector3 up = -Vector3.Normalize(MyGravityProviderSystem.CalculateTotalGravityInPoint(originPosition));
Matrix rotation = Matrix.CreateFromQuaternion(Quaternion.Inverse(Quaternion.CreateFromForwardUp(Vector3.CalculatePerpendicularVector(up), up)));
Matrix orientation = (Matrix)voxelBase.PositionComp.WorldMatrix.GetOrientation();
while (iterator.IsValid())
{
BoundingBox box;
MyIsoMesh mesh;
if (flag && cache.TryGetValue(iterator.Current, out mesh))
{
if (mesh != null)
{
this.AddMeshTriangles(mesh, offset, rotation, orientation);
}
iterator.MoveNext();
continue;
}
coord.CoordInLod = iterator.Current;
MyVoxelCoordSystems.GeometryCellCoordToLocalAABB(ref coord.CoordInLod, out box);
if (!xd2.Intersects(ref box))
{
num2++;
iterator.MoveNext();
}
else
{
BoundingBoxD item = new BoundingBoxD(box.Min, box.Max).Translate(-voxelBase.SizeInMetresHalf);
bbList.Add(item);
Vector3I lodVoxelMin = (coord.CoordInLod * 8) - 1;
MyIsoMesh mesh2 = MyPrecalcComponent.IsoMesher.Precalc(storage, 0, lodVoxelMin, (Vector3I)(((lodVoxelMin + 8) + 1) + 1), MyStorageDataTypeFlags.Content, 0);
if (flag)
{
cache[iterator.Current] = mesh2;
}
if (mesh2 != null)
{
this.AddMeshTriangles(mesh2, offset, rotation, orientation);
}
iterator.MoveNext();
}
}
}
public override BoundingBoxD PeekWorldBoundaries(ref Vector3D targetPosition)
{
MatrixD newTransformation = Transformation;
newTransformation.Translation = targetPosition;
var bbox = new BoundingBoxD(A - Radius, B + Radius);
return bbox.TransformFast(newTransformation);
}
private void UpdateGizmo_VoxelMap(MyCubeBuilderGizmo.MyGizmoSpaceProperties gizmoSpace, bool add, bool remove, bool draw)
{
if (!m_animationLock)
{
gizmoSpace.m_animationLastMatrix = gizmoSpace.m_localMatrixAdd;
}
MatrixD animationMatrix = gizmoSpace.m_localMatrixAdd;
if (MySandboxGame.Config.AnimatedRotation && gizmoSpace.m_animationProgress < 1)
{
animationMatrix = MatrixD.Slerp(gizmoSpace.m_animationLastMatrix, gizmoSpace.m_localMatrixAdd, gizmoSpace.m_animationProgress);
}
else if (MySandboxGame.Config.AnimatedRotation && gizmoSpace.m_animationProgress >= 1)
{
m_animationLock = false;
gizmoSpace.m_animationLastMatrix = gizmoSpace.m_localMatrixAdd;
}
Color green = new Color(Color.Green * 0.6f, 1f);
float gridSize = MyDefinitionManager.Static.GetCubeSize(CurrentBlockDefinition.CubeSize);
Vector3 temp;
Vector3D worldCenter = Vector3D.Zero;
MatrixD drawMatrix = gizmoSpace.m_worldMatrixAdd;
MatrixD localOrientation = animationMatrix.GetOrientation();
Color color = green;
gizmoSpace.m_showGizmoCube = !IntersectsCharacterOrCamera(gizmoSpace, gridSize, ref MatrixD.Identity);
int posIndex = 0;
for (temp.X = 0; temp.X < CurrentBlockDefinition.Size.X; temp.X++)
for (temp.Y = 0; temp.Y < CurrentBlockDefinition.Size.Y; temp.Y++)
for (temp.Z = 0; temp.Z < CurrentBlockDefinition.Size.Z; temp.Z++)
{
Vector3I gridPosition = gizmoSpace.m_positions[posIndex++];
Vector3D gridRelative = gridPosition * gridSize;
if (!CubeBuilderDefinition.BuildingSettings.StaticGridAlignToCenter)
gridRelative += new Vector3D(0.5 * gridSize, 0.5 * gridSize, -0.5 * gridSize);
Vector3D tempWorldPos = Vector3D.Transform(gridRelative, gizmoSpace.m_worldMatrixAdd);
worldCenter += gridRelative;
MyCubeGrid.GetCubePartsWithoutTopologyCheck(
CurrentBlockDefinition,
gridPosition,
localOrientation,
gridSize,
gizmoSpace.m_cubeModelsTemp,
gizmoSpace.m_cubeMatricesTemp,
gizmoSpace.m_cubeNormals,
gizmoSpace.m_patternOffsets
);
if (gizmoSpace.m_showGizmoCube)
{
for (int i = 0; i < gizmoSpace.m_cubeMatricesTemp.Count; i++)
{
MatrixD modelMatrix = gizmoSpace.m_cubeMatricesTemp[i] * gizmoSpace.m_worldMatrixAdd;
modelMatrix.Translation = tempWorldPos;
gizmoSpace.m_cubeMatricesTemp[i] = modelMatrix;
}
drawMatrix.Translation = tempWorldPos;
MatrixD invDrawMatrix = MatrixD.Invert(localOrientation * drawMatrix);
m_gizmo.AddFastBuildParts(gizmoSpace, CurrentBlockDefinition, null);
m_gizmo.UpdateGizmoCubeParts(gizmoSpace, m_renderData, ref invDrawMatrix, CurrentBlockDefinition);
}
}
//calculate world center for block model
worldCenter /= CurrentBlockDefinition.Size.Size;
if (!m_animationLock)
{
gizmoSpace.m_animationProgress = 0;
gizmoSpace.m_animationLastPosition = worldCenter;
}
else if (MySandboxGame.Config.AnimatedRotation && gizmoSpace.m_animationProgress < 1)
{
worldCenter = Vector3D.Lerp(gizmoSpace.m_animationLastPosition, worldCenter, gizmoSpace.m_animationProgress);
}
worldCenter = Vector3D.Transform(worldCenter, gizmoSpace.m_worldMatrixAdd);
drawMatrix.Translation = worldCenter;
drawMatrix = localOrientation * drawMatrix;
BoundingBoxD localAABB = new BoundingBoxD(-CurrentBlockDefinition.Size * gridSize * 0.5f, CurrentBlockDefinition.Size * gridSize * 0.5f);
var settings = CurrentBlockDefinition.CubeSize == MyCubeSize.Large ? CubeBuilderDefinition.BuildingSettings.LargeStaticGrid : CubeBuilderDefinition.BuildingSettings.SmallStaticGrid;
MyBlockOrientation blockOrientation = new MyBlockOrientation(ref Quaternion.Identity);
bool placementTest = CheckValidBlockRotation(gizmoSpace.m_localMatrixAdd, CurrentBlockDefinition.Direction, CurrentBlockDefinition.Rotation)
&& MyCubeGrid.TestBlockPlacementArea(CurrentBlockDefinition, blockOrientation, drawMatrix, ref settings, localAABB, false);
gizmoSpace.m_buildAllowed &= placementTest;
gizmoSpace.m_buildAllowed &= gizmoSpace.m_showGizmoCube;
gizmoSpace.m_worldMatrixAdd = drawMatrix;
BuildComponent.GetGridSpawnMaterials(CurrentBlockDefinition, drawMatrix, true);
if (MySession.Static.IsAdminModeEnabled(Sync.MyId) == false)
{
gizmoSpace.m_buildAllowed &= BuildComponent.HasBuildingMaterials(MySession.Static.LocalCharacter);
}
if (MySession.Static.SurvivalMode && !SpectatorIsBuilding && MySession.Static.IsAdminModeEnabled(Sync.MyId) == false)
{
BoundingBoxD gizmoBox = localAABB.TransformFast(ref drawMatrix);
if (!MyCubeBuilderGizmo.DefaultGizmoCloseEnough(ref MatrixD.Identity, gizmoBox, gridSize, IntersectionDistance) || CameraControllerSpectator)
{
gizmoSpace.m_buildAllowed = false;
gizmoSpace.m_showGizmoCube = false;
gizmoSpace.m_removeBlock = null;
return;
}
}
color = Color.White;
string lineMaterial = gizmoSpace.m_buildAllowed ? "GizmoDrawLine" : "GizmoDrawLineRed";
if (gizmoSpace.SymmetryPlane == MySymmetrySettingModeEnum.Disabled)
{
MySimpleObjectDraw.DrawTransparentBox(ref drawMatrix,
ref localAABB, ref color, MySimpleObjectRasterizer.Wireframe, 1, 0.04f, lineMaterial: lineMaterial);
m_rotationHints.CalculateRotationHints(drawMatrix, localAABB, !MyHud.MinimalHud && MySandboxGame.Config.RotationHints && draw && MyFakes.ENABLE_ROTATION_HINTS);
}
gizmoSpace.m_cubeMatricesTemp.Clear();
gizmoSpace.m_cubeModelsTemp.Clear();
if (gizmoSpace.m_showGizmoCube)
{
// Draw mount points of added cube block as yellow squares in neighboring cells.
if (MyDebugDrawSettings.ENABLE_DEBUG_DRAW && MyDebugDrawSettings.DEBUG_DRAW_MOUNT_POINTS)
{
DrawMountPoints(gridSize, CurrentBlockDefinition, ref drawMatrix);
}
AddFastBuildModels(gizmoSpace, MatrixD.Identity, gizmoSpace.m_cubeMatricesTemp, gizmoSpace.m_cubeModelsTemp, gizmoSpace.m_blockDefinition);
Debug.Assert(gizmoSpace.m_cubeMatricesTemp.Count == gizmoSpace.m_cubeModelsTemp.Count);
for (int i = 0; i < gizmoSpace.m_cubeMatricesTemp.Count; ++i)
{
string model = gizmoSpace.m_cubeModelsTemp[i];
if (!string.IsNullOrEmpty(model))
m_renderData.AddInstance(MyModel.GetId(model), gizmoSpace.m_cubeMatricesTemp[i], ref MatrixD.Identity);
}
}
gizmoSpace.m_animationProgress += m_animationSpeed;
}
private void AddVoxelMesh(MyVoxelBase voxelBase, IMyStorage storage, Dictionary<Vector3I, MyIsoMesh> cache, float border, Vector3D originPosition, MyOrientedBoundingBoxD obb, List<BoundingBoxD> bbList)
{
bool useCache = cache != null;
if (useCache)
CheckCacheValidity();
obb.HalfExtent += new Vector3D(border, 0, border);
BoundingBoxD bb = obb.GetAABB();
int aabbSideSide = (int)Math.Round(bb.HalfExtents.Max() * 2);
bb = new BoundingBoxD(bb.Min, bb.Min + aabbSideSide);
bb.Translate(obb.Center - bb.Center);
// For debug
bbList.Add(new BoundingBoxD(bb.Min, bb.Max));
bb = (BoundingBoxD)bb.TransformFast(voxelBase.PositionComp.WorldMatrixInvScaled);
bb.Translate(voxelBase.SizeInMetresHalf);
Vector3I min = Vector3I.Round(bb.Min);
Vector3I max = min + aabbSideSide;
Vector3I geomMin, geomMax;
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref min, out geomMin);
MyVoxelCoordSystems.VoxelCoordToGeometryCellCoord(ref max, out geomMax);
var cullBox = obb;
cullBox.Transform(voxelBase.PositionComp.WorldMatrixInvScaled);
cullBox.Center += voxelBase.SizeInMetresHalf;
ProfilerShort.Begin("WOOOORK");
Vector3I_RangeIterator it = new Vector3I_RangeIterator(ref geomMin, ref geomMax);
MyCellCoord coord = new MyCellCoord();
BoundingBox localAabb;
coord.Lod = NAVMESH_LOD;
int hits = 0;
MyIsoMesh gMesh;
Vector3 offset = originPosition - voxelBase.PositionLeftBottomCorner;
// Calculate rotation
Vector3 gravityVector = -Vector3.Normalize(GameSystems.MyGravityProviderSystem.CalculateTotalGravityInPoint(originPosition));
Vector3 forwardVector = Vector3.CalculatePerpendicularVector(gravityVector);
Quaternion quaternion = Quaternion.CreateFromForwardUp(forwardVector, gravityVector);
Matrix rotation = Matrix.CreateFromQuaternion(Quaternion.Inverse(quaternion));
Matrix ownRotation = voxelBase.PositionComp.WorldMatrix.GetOrientation();
while (it.IsValid())
{
ProfilerShort.Begin("ITERATOR");
if (useCache && cache.TryGetValue(it.Current, out gMesh))
{
if (gMesh != null)
{
AddMeshTriangles(gMesh, offset, rotation, ownRotation);
}
it.MoveNext();
ProfilerShort.End();
continue;
}
coord.CoordInLod = it.Current;
MyVoxelCoordSystems.GeometryCellCoordToLocalAABB(ref coord.CoordInLod, out localAabb);
if (!cullBox.Intersects(ref localAabb))
{
hits++;
it.MoveNext();
ProfilerShort.End();
continue;
}
ProfilerShort.End();
var debugBB = new BoundingBoxD(localAabb.Min, localAabb.Max).Translate(-voxelBase.SizeInMetresHalf);
bbList.Add(debugBB);
ProfilerShort.Begin("Mesh Calc");
var voxelStart = coord.CoordInLod * MyVoxelConstants.GEOMETRY_CELL_SIZE_IN_VOXELS - 1;
var voxelEnd = voxelStart + MyVoxelConstants.GEOMETRY_CELL_SIZE_IN_VOXELS //- 1
+ 1 // overlap to neighbor so geometry is stitched together within same LOD
+ 1; // for eg. 9 vertices in row we need 9 + 1 samples (voxels)
var generatedMesh = MyPrecalcComponent.IsoMesher.Precalc(storage, NAVMESH_LOD, voxelStart, voxelEnd, false, false, true);
ProfilerShort.End();
if (useCache)
cache[it.Current] = generatedMesh;
if (generatedMesh != null)
{
ProfilerShort.Begin("Mesh NOT NULL");
AddMeshTriangles(generatedMesh, offset, rotation, ownRotation);
ProfilerShort.End();
}
it.MoveNext();
}
ProfilerShort.End();
}
public override BoundingBoxD GetWorldBoundaries()
{
BoundingBoxD xd = new BoundingBoxD(this.A - this.Radius, this.B + this.Radius);
return(xd.TransformFast(base.Transformation));
}