void CollectBlock(MySlimBlock block, MyPhysicsOption physicsOption, IDictionary <Vector3I, HkMassElement> massResults, bool allowSegmentation = true)
{
if (!block.HasPhysics)
{
return;
}
if (massResults != null)
{
AddMass(block, massResults);
}
if (block.BlockDefinition.BlockTopology == MyBlockTopology.Cube)
{
Debug.Assert(block.Min == block.Max, "Calculation assume that cube blocks have size 1x1x1");
var cubeTopology = block.BlockDefinition.CubeDefinition.CubeTopology;
if (MyFakes.ENABLE_SIMPLE_GRID_PHYSICS)
{
physicsOption = MyPhysicsOption.Box;
}
else if ((cubeTopology == MyCubeTopology.Box) && block.CubeGrid.Skeleton.IsDeformed(block.Min, 0.05f, block.CubeGrid, false))
{
physicsOption = MyPhysicsOption.Convex;
}
switch (physicsOption)
{
case MyPhysicsOption.Box:
AddBoxes(block);
break;
case MyPhysicsOption.Convex:
AddConvexShape(block, true);
break;
}
}
else
{
if (physicsOption != MyPhysicsOption.None)
{
var havokShapes = block.FatBlock.ModelCollision.HavokCollisionShapes;
if ((havokShapes != null && havokShapes.Length > 0) && !MyFakes.ENABLE_SIMPLE_GRID_PHYSICS)
{
// first set of shapes goes into block.Position
Vector3 blockPos;
if (block.FatBlock.ModelCollision.ExportedWrong)
{
blockPos = block.Position * block.CubeGrid.GridSize;
}
else
{
blockPos = block.FatBlock.PositionComp.LocalMatrix.Translation;
}
HkShape[] shapes = block.FatBlock.ModelCollision.HavokCollisionShapes;
Quaternion blockOrientation;
block.Orientation.GetQuaternion(out blockOrientation);
if (shapes.Length == 1 && shapes[0].ShapeType == HkShapeType.List)
{
HkListShape list = (HkListShape)shapes[0];
for (int i = 0; i < list.TotalChildrenCount; i++)
{
HkShape child = list.GetChildByIndex(i);
System.Diagnostics.Debug.Assert(child.IsConvex, "Children in the list must be convex!");
Shapes.Add(new HkConvexTransformShape((HkConvexShape)child, ref blockPos, ref blockOrientation, ref Vector3.One, HkReferencePolicy.None));
}
}
else
if (shapes.Length == 1 && shapes[0].ShapeType == HkShapeType.Mopp)
{
HkMoppBvTreeShape list = (HkMoppBvTreeShape)shapes[0];
for (int i = 0; i < list.ShapeCollection.ShapeCount; i++)
{
HkShape child = list.ShapeCollection.GetShape((uint)i, null);
System.Diagnostics.Debug.Assert(child.IsConvex, "Children in the list must be convex!");
Shapes.Add(new HkConvexTransformShape((HkConvexShape)child, ref blockPos, ref blockOrientation, ref Vector3.One, HkReferencePolicy.None));
}
}
else
{
for (int i = 0; i < shapes.Length; i++)
{
Shapes.Add(new HkConvexTransformShape((HkConvexShape)shapes[i], ref blockPos, ref blockOrientation, ref Vector3.One, HkReferencePolicy.None));
}
}
ShapeInfos.Add(new ShapeInfo()
{
Count = shapes.Length, Min = block.Min, Max = block.Max
});
}
else
{
// This will add boxes
for (int x = block.Min.X; x <= block.Max.X; x++)
{
for (int y = block.Min.Y; y <= block.Max.Y; y++)
{
for (int z = block.Min.Z; z <= block.Max.Z; z++)
{
var pos = new Vector3I(x, y, z);
// NOTE: Disabled because it's not visually represented
//if (block.CubeGrid.Skeleton.IsDeformed(pos, 0.05f) && !MyFakes.ENABLE_SIMPLE_GRID_PHYSICS)
//{
// AddConvexShape(pos, block.CubeGrid.Skeleton, false);
//}
//else
if (allowSegmentation)
{
m_tmpCubes.Add(pos);
}
else
{
Vector3 min = pos * block.CubeGrid.GridSize - new Vector3(block.CubeGrid.GridSize / 2.0f);
Vector3 max = pos * block.CubeGrid.GridSize + new Vector3(block.CubeGrid.GridSize / 2.0f);
AddBox(pos, pos, ref min, ref max);
}
}
}
}
}
}
}
}
private void CollectBlock(MySlimBlock block, MyPhysicsOption physicsOption, IDictionary <Vector3I, HkMassElement> massResults, bool allowSegmentation = true)
{
if (block.BlockDefinition.HasPhysics && (block.CubeGrid != null))
{
if (massResults != null)
{
this.AddMass(block, massResults);
}
if (block.BlockDefinition.BlockTopology == MyBlockTopology.Cube)
{
MyCubeTopology topology = (block.BlockDefinition.CubeDefinition != null) ? block.BlockDefinition.CubeDefinition.CubeTopology : MyCubeTopology.Box;
if (MyFakes.ENABLE_SIMPLE_GRID_PHYSICS)
{
physicsOption = MyPhysicsOption.Box;
}
else if (topology == MyCubeTopology.Box)
{
if (!block.ShowParts)
{
physicsOption = MyPhysicsOption.Box;
}
else if ((block.BlockDefinition.CubeDefinition != null) && block.CubeGrid.Skeleton.IsDeformed(block.Min, 0.05f, block.CubeGrid, false))
{
physicsOption = MyPhysicsOption.Convex;
}
}
if (physicsOption == MyPhysicsOption.Box)
{
this.AddBoxes(block);
}
else if (physicsOption == MyPhysicsOption.Convex)
{
this.AddConvexShape(block, block.ShowParts);
}
}
else if (physicsOption != MyPhysicsOption.None)
{
HkShape[] havokCollisionShapes = null;
if (block.FatBlock != null)
{
havokCollisionShapes = block.FatBlock.ModelCollision.HavokCollisionShapes;
}
if (((havokCollisionShapes != null) && (havokCollisionShapes.Length != 0)) && !MyFakes.ENABLE_SIMPLE_GRID_PHYSICS)
{
Vector3 translation;
Quaternion quaternion;
if (block.FatBlock.ModelCollision.ExportedWrong)
{
translation = (Vector3)(block.Position * block.CubeGrid.GridSize);
}
else
{
translation = block.FatBlock.PositionComp.LocalMatrix.Translation;
}
HkShape[] havokCollisionShapes = block.FatBlock.ModelCollision.HavokCollisionShapes;
block.Orientation.GetQuaternion(out quaternion);
Vector3 scale = Vector3.One * block.FatBlock.ModelCollision.ScaleFactor;
if ((havokCollisionShapes.Length == 1) && (havokCollisionShapes[0].ShapeType == HkShapeType.List))
{
HkListShape shape = (HkListShape)havokCollisionShapes[0];
for (int i = 0; i < shape.TotalChildrenCount; i++)
{
HkShape childByIndex = shape.GetChildByIndex(i);
this.Shapes.Add((HkShape) new HkConvexTransformShape((HkConvexShape)childByIndex, ref translation, ref quaternion, ref scale, HkReferencePolicy.None));
}
}
else if ((havokCollisionShapes.Length != 1) || (havokCollisionShapes[0].ShapeType != HkShapeType.Mopp))
{
for (int i = 0; i < havokCollisionShapes.Length; i++)
{
this.Shapes.Add((HkShape) new HkConvexTransformShape((HkConvexShape)havokCollisionShapes[i], ref translation, ref quaternion, ref scale, HkReferencePolicy.None));
}
}
else
{
HkMoppBvTreeShape shape3 = (HkMoppBvTreeShape)havokCollisionShapes[0];
int num2 = 0;
while (true)
{
HkShapeCollection shapeCollection = shape3.ShapeCollection;
if (num2 >= shapeCollection.ShapeCount)
{
break;
}
HkShape shape = shape3.ShapeCollection.GetShape((uint)num2, null);
this.Shapes.Add((HkShape) new HkConvexTransformShape((HkConvexShape)shape, ref translation, ref quaternion, ref scale, HkReferencePolicy.None));
num2++;
}
}
ShapeInfo item = new ShapeInfo {
Count = havokCollisionShapes.Length,
Min = block.Min,
Max = block.Max
};
this.ShapeInfos.Add(item);
}
else
{
int x = block.Min.X;
while (x <= block.Max.X)
{
int y = block.Min.Y;
while (true)
{
if (y > block.Max.Y)
{
x++;
break;
}
int z = block.Min.Z;
while (true)
{
if (z > block.Max.Z)
{
y++;
break;
}
Vector3I item = new Vector3I(x, y, z);
if (allowSegmentation)
{
this.m_tmpCubes.Add(item);
}
else
{
Vector3 min = ((Vector3)(item * block.CubeGrid.GridSize)) - new Vector3(block.CubeGrid.GridSize / 2f);
Vector3 max = (item * block.CubeGrid.GridSize) + new Vector3(block.CubeGrid.GridSize / 2f);
this.AddBox(item, item, ref min, ref max);
}
z++;
}
}
}
}
}
}
}
