public static Vector3I Transform(this SerializableVector3I size, SerializableBlockOrientation orientation)
{
var matrix = Matrix.CreateFromDir(Base6Directions.GetVector(orientation.Forward), Base6Directions.GetVector(orientation.Up));
var rotation = Quaternion.CreateFromRotationMatrix(matrix);
return(Vector3I.Transform(size.ToVector3I(), rotation));
}
internal static SerializableVector3I Mirror(this SerializableVector3I vector, Mirror xMirror, int xAxis, Mirror yMirror, int yAxis, Mirror zMirror, int zAxis)
{
var newVector = new Vector3I(vector.X, vector.Y, vector.Z);
switch (xMirror)
{
case Support.Mirror.Odd: newVector.X = xAxis - (vector.X - xAxis); break;
case Support.Mirror.EvenUp: newVector.X = xAxis - (vector.X - xAxis) + 1; break;
case Support.Mirror.EvenDown: newVector.X = xAxis - (vector.X - xAxis) - 1; break;
}
switch (yMirror)
{
case Support.Mirror.Odd: newVector.Y = yAxis - (vector.Y - yAxis); break;
case Support.Mirror.EvenUp: newVector.Y = yAxis - (vector.Y - yAxis) + 1; break;
case Support.Mirror.EvenDown: newVector.Y = yAxis - (vector.Y - yAxis) - 1; break;
}
switch (zMirror)
{
case Support.Mirror.Odd: newVector.Z = zAxis - (vector.Z - zAxis); break;
case Support.Mirror.EvenUp: newVector.Z = zAxis - (vector.Z - zAxis) + 1; break;
case Support.Mirror.EvenDown: newVector.Z = zAxis - (vector.Z - zAxis) - 1; break;
}
return(newVector);
}
public void RepositionAround(SerializableVector3I pivotPos)
{
_cube.Min.x -= pivotPos.x;
_cube.Min.y -= pivotPos.y;
_cube.Min.z -= pivotPos.z;
Position = new BindablePoint3DIModel(_cube.Min);
}
public ClientData(MyObjectBuilder_CubeGrid grid, IMyFaction faction, Vector3I controlledBlock)
{
Grid = grid;
ControlledBlock = controlledBlock;
if (faction != null)
{
Faction = new FactionData(faction);
}
else
{
Faction = new FactionData();
}
}
public void RepositionAround(SerializableVector3I pivotPos)
{
_dataModel.RepositionAround(pivotPos);
}
public static Vector3D ToVector3D(this SerializableVector3I vector)
{
return(new Vector3D(vector.X, vector.Y, vector.Z));
}
public static SerializableVector3I Add(this SerializableVector3I size, int value)
{
return(new SerializableVector3I(size.X + value, size.Y + value, size.Z + value));
}
private static IEnumerable <MyObjectBuilder_CubeBlock> MirrorCubes(IMyCubeGrid shipEntity, bool integrate, MirrorDirection xMirror, int xAxis, MirrorDirection yMirror, int yAxis, MirrorDirection zMirror, int zAxis)
{
var blocks = new List <MyObjectBuilder_CubeBlock>();
if (xMirror == MirrorDirection.None && yMirror == MirrorDirection.None && zMirror == MirrorDirection.None)
{
return(blocks);
}
List <IMySlimBlock> cubeBlocks = new List <IMySlimBlock>();
shipEntity.GetBlocks(cubeBlocks);
foreach (var block in cubeBlocks)
{
MyObjectBuilder_CubeBlock newBlock = (MyObjectBuilder_CubeBlock)block.GetObjectBuilder().Clone();
// Need to use the Min from the GetObjectBuilder(), as block.Position is NOT representative.
Vector3I oldMin = newBlock.Min;
newBlock.EntityId = 0;
MyObjectBuilder_MotorBase motorBase = newBlock as MyObjectBuilder_MotorBase;
if (motorBase != null)
{
motorBase.RotorEntityId = 0;
}
MyObjectBuilder_PistonBase pistonBase = newBlock as MyObjectBuilder_PistonBase;
if (pistonBase != null)
{
pistonBase.TopBlockId = 0;
}
MyCubeBlockDefinition definition = MyDefinitionManager.Static.GetCubeBlockDefinition(newBlock);
MyCubeBlockDefinition mirrorDefinition;
MirrorCubeOrientation(definition, block.Orientation, xMirror, yMirror, zMirror, out mirrorDefinition, out newBlock.BlockOrientation);
newBlock.SubtypeName = mirrorDefinition.Id.SubtypeName;
if (definition.Size.X == 1 && definition.Size.Y == 1 && definition.Size.Z == 1)
{
newBlock.Min = oldMin.Mirror(xMirror, xAxis, yMirror, yAxis, zMirror, zAxis);
}
else
{
// resolve size of component, and transform to original orientation.
var orientSize = definition.Size.Add(-1).Transform(block.Orientation).Abs();
var min = oldMin.Mirror(xMirror, xAxis, yMirror, yAxis, zMirror, zAxis);
var blockMax = new SerializableVector3I(oldMin.X + orientSize.X, oldMin.Y + orientSize.Y, oldMin.Z + orientSize.Z);
var max = ((Vector3I)blockMax).Mirror(xMirror, xAxis, yMirror, yAxis, zMirror, zAxis);
if (xMirror != MirrorDirection.None)
{
newBlock.Min = new SerializableVector3I(max.X, min.Y, min.Z);
}
if (yMirror != MirrorDirection.None)
{
newBlock.Min = new SerializableVector3I(min.X, max.Y, min.Z);
}
if (zMirror != MirrorDirection.None)
{
newBlock.Min = new SerializableVector3I(min.X, min.Y, max.Z);
}
}
Vector3I newPosition = ComputePositionInGrid(new MatrixI(newBlock.BlockOrientation), mirrorDefinition, newBlock.Min);
// Don't place a block if one already exists there in the mirror.
if (integrate && cubeBlocks.Any(b => b.Position.X == newPosition.X && b.Position.Y == newPosition.Y && b.Position.Z == newPosition.Z))
{
continue;
}
//VRage.Utils.MyLog.Default.WriteLineAndConsole($"## CHECK ## new block {newBlock.SubtypeName}");
blocks.Add(newBlock);
// Alternate to using AddBlock().
//Quaternion q;
//((MyBlockOrientation)newBlock.BlockOrientation).GetQuaternion(out q);
//((MyCubeGrid)shipEntity).BuildGeneratedBlock(new MyCubeGrid.MyBlockLocation(mirrorDefinition.Id, newBlock.Min, newBlock.Min, newBlock.Min, q, 0, 0) , newBlock.ColorMaskHSV);
}
return(blocks);
}
private static IEnumerable<MyObjectBuilder_CubeBlock> MirrorCubes(StructureCubeGridModel viewModel, bool integrate, Mirror xMirror, int xAxis, Mirror yMirror, int yAxis, Mirror zMirror, int zAxis)
{
var blocks = new List<MyObjectBuilder_CubeBlock>();
SubtypeId outVal;
if (xMirror == Mirror.None && yMirror == Mirror.None && zMirror == Mirror.None)
return blocks;
foreach (var block in viewModel.CubeGrid.CubeBlocks.Where(b => b.SubtypeName == "" || (Enum.TryParse<SubtypeId>(b.SubtypeName, out outVal) && !InvalidMirrorBlocks.Contains(outVal))))
{
var newBlock = block.Clone() as MyObjectBuilder_CubeBlock;
newBlock.EntityId = block.EntityId == 0 ? 0 : SpaceEngineersApi.GenerateEntityId(IDType.ENTITY);
if (block is MyObjectBuilder_MotorBase)
{
((MyObjectBuilder_MotorBase)newBlock).RotorEntityId = ((MyObjectBuilder_MotorBase)block).RotorEntityId == 0 ? 0 : SpaceEngineersApi.GenerateEntityId(IDType.ENTITY);
}
if (block is MyObjectBuilder_PistonBase)
{
((MyObjectBuilder_PistonBase)newBlock).TopBlockId = ((MyObjectBuilder_PistonBase)block).TopBlockId == 0 ? 0 : SpaceEngineersApi.GenerateEntityId(IDType.ENTITY);
}
newBlock.BlockOrientation = MirrorCubeOrientation(block.SubtypeName, block.BlockOrientation, xMirror, yMirror, zMirror);
var definition = SpaceEngineersApi.GetCubeDefinition(block.TypeId, viewModel.GridSize, block.SubtypeName);
if (definition.Size.X == 1 && definition.Size.Y == 1 && definition.Size.z == 1)
{
newBlock.Min = block.Min.Mirror(xMirror, xAxis, yMirror, yAxis, zMirror, zAxis);
}
else
{
// resolve size of component, and transform to original orientation.
var orientSize = definition.Size.Add(-1).Transform(block.BlockOrientation).Abs();
var min = block.Min.Mirror(xMirror, xAxis, yMirror, yAxis, zMirror, zAxis);
var blockMax = new SerializableVector3I(block.Min.X + orientSize.X, block.Min.Y + orientSize.Y, block.Min.Z + orientSize.Z);
var max = blockMax.Mirror(xMirror, xAxis, yMirror, yAxis, zMirror, zAxis);
if (xMirror != Mirror.None)
newBlock.Min = new SerializableVector3I(max.X, min.Y, min.Z);
if (yMirror != Mirror.None)
newBlock.Min = new SerializableVector3I(min.X, max.Y, min.Z);
if (zMirror != Mirror.None)
newBlock.Min = new SerializableVector3I(min.X, min.Y, max.Z);
}
// Don't place a block if one already exists there in the mirror.
if (integrate && viewModel.CubeGrid.CubeBlocks.Any(b => b.Min.X == newBlock.Min.X && b.Min.Y == newBlock.Min.Y && b.Min.Z == newBlock.Min.Z /*|| b.Max == newBlock.Min*/)) // TODO: check cubeblock size.
continue;
blocks.Add(newBlock);
}
return blocks;
}
