private void MirrorGizmoSpace(MyGizmoSpaceProperties targetSpace, MyGizmoSpaceProperties sourceSpace, MySymmetrySettingModeEnum mirrorPlane, Vector3I mirrorPosition, bool isOdd,
MyCubeBlockDefinition cubeBlockDefinition, MyCubeGrid cubeGrid)
{
targetSpace.m_addPos = MirrorBlockByPlane(mirrorPlane, mirrorPosition, isOdd, sourceSpace.m_addPos);
targetSpace.m_localMatrixAdd.Translation = targetSpace.m_addPos;
targetSpace.m_addDir = MirrorDirByPlane(mirrorPlane, mirrorPosition, isOdd, sourceSpace.m_addDir);
targetSpace.m_removePos = MirrorBlockByPlane(mirrorPlane, mirrorPosition, isOdd, sourceSpace.m_removePos);
targetSpace.m_removeBlock = cubeGrid.GetCubeBlock(targetSpace.m_removePos);
if (sourceSpace.m_startBuild.HasValue)
targetSpace.m_startBuild = MirrorBlockByPlane(mirrorPlane, mirrorPosition, isOdd, sourceSpace.m_startBuild.Value);
else
targetSpace.m_startBuild = null;
if (sourceSpace.m_continueBuild.HasValue)
targetSpace.m_continueBuild = MirrorBlockByPlane(mirrorPlane, mirrorPosition, isOdd, sourceSpace.m_continueBuild.Value);
else
targetSpace.m_continueBuild = null;
if (sourceSpace.m_startRemove.HasValue)
targetSpace.m_startRemove = MirrorBlockByPlane(mirrorPlane, mirrorPosition, isOdd, sourceSpace.m_startRemove.Value);
else
targetSpace.m_startRemove = null;
//Find block axis ortogonal to mirror plane normal
Vector3 mirrorNormal = Vector3.Zero;
switch (mirrorPlane)
{
case MySymmetrySettingModeEnum.XPlane:
mirrorNormal = Vector3.Right;
break;
case MySymmetrySettingModeEnum.YPlane:
mirrorNormal = Vector3.Up;
break;
case MySymmetrySettingModeEnum.ZPlane:
mirrorNormal = Vector3.Forward;
break;
default:
System.Diagnostics.Debug.Assert(false);
break;
}
var blockMirrorAxis = Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.None;
if (MyUtils.IsZero(Math.Abs(Vector3.Dot(sourceSpace.m_localMatrixAdd.Right, mirrorNormal)) - 1.0f))
{
blockMirrorAxis = Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.X;
}
else
if (MyUtils.IsZero(Math.Abs(Vector3.Dot(sourceSpace.m_localMatrixAdd.Up, mirrorNormal)) - 1.0f))
{
blockMirrorAxis = Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.Y;
}
else
if (MyUtils.IsZero(Math.Abs(Vector3.Dot(sourceSpace.m_localMatrixAdd.Forward, mirrorNormal)) - 1.0f))
{
blockMirrorAxis = Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.Z;
}
var blockMirrorOption = Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.None;
switch (blockMirrorAxis)
{
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.X:
blockMirrorOption = cubeBlockDefinition.SymmetryX;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.Y:
blockMirrorOption = cubeBlockDefinition.SymmetryY;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.Z:
blockMirrorOption = cubeBlockDefinition.SymmetryZ;
break;
default:
System.Diagnostics.Debug.Assert(false);
break;
}
switch (blockMirrorOption)
{
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.X:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationX(MathHelper.Pi) * sourceSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.Y:
//targetSpace.m_gizmoLocalMatrixAdd = sourceSpace.m_gizmoLocalMatrixAdd;
targetSpace.m_localMatrixAdd = Matrix.CreateRotationY(MathHelper.Pi) * sourceSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.Z:
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.ZThenOffsetX:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationZ(MathHelper.Pi) * sourceSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.HalfX:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationX(-MathHelper.PiOver2) * sourceSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.HalfY:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationY(-MathHelper.PiOver2) * sourceSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.HalfZ:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationZ(-MathHelper.PiOver2) * sourceSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.XHalfY:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationX(MathHelper.Pi) * sourceSpace.m_localMatrixAdd;
targetSpace.m_localMatrixAdd = Matrix.CreateRotationY(MathHelper.PiOver2) * targetSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.YHalfY:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationY(MathHelper.Pi) * sourceSpace.m_localMatrixAdd;
targetSpace.m_localMatrixAdd = Matrix.CreateRotationY(MathHelper.PiOver2) * targetSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.ZHalfY:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationZ(MathHelper.Pi) * sourceSpace.m_localMatrixAdd;
targetSpace.m_localMatrixAdd = Matrix.CreateRotationY(MathHelper.PiOver2) * targetSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.XHalfX:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationX(MathHelper.Pi) * sourceSpace.m_localMatrixAdd;
targetSpace.m_localMatrixAdd = Matrix.CreateRotationX(-MathHelper.PiOver2) * targetSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.YHalfX:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationY(MathHelper.Pi) * sourceSpace.m_localMatrixAdd;
targetSpace.m_localMatrixAdd = Matrix.CreateRotationX(-MathHelper.PiOver2) * targetSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.ZHalfX:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationZ(MathHelper.Pi) * sourceSpace.m_localMatrixAdd;
targetSpace.m_localMatrixAdd = Matrix.CreateRotationX(-MathHelper.PiOver2) * targetSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.XHalfZ:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationX(MathHelper.Pi) * sourceSpace.m_localMatrixAdd;
targetSpace.m_localMatrixAdd = Matrix.CreateRotationZ(-MathHelper.PiOver2) * targetSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.YHalfZ:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationY(MathHelper.Pi) * sourceSpace.m_localMatrixAdd;
targetSpace.m_localMatrixAdd = Matrix.CreateRotationZ(-MathHelper.PiOver2) * targetSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.ZHalfZ:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationZ(MathHelper.Pi) * sourceSpace.m_localMatrixAdd;
targetSpace.m_localMatrixAdd = Matrix.CreateRotationZ(-MathHelper.PiOver2) * targetSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.XMinusHalfZ:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationX(MathHelper.Pi) * sourceSpace.m_localMatrixAdd;
targetSpace.m_localMatrixAdd = Matrix.CreateRotationZ(MathHelper.PiOver2) * targetSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.YMinusHalfZ:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationY(MathHelper.Pi) * sourceSpace.m_localMatrixAdd;
targetSpace.m_localMatrixAdd = Matrix.CreateRotationZ(MathHelper.PiOver2) * targetSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.ZMinusHalfZ:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationZ(MathHelper.Pi) * sourceSpace.m_localMatrixAdd;
targetSpace.m_localMatrixAdd = Matrix.CreateRotationZ(MathHelper.PiOver2) * targetSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.XMinusHalfX:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationX(MathHelper.Pi) * sourceSpace.m_localMatrixAdd;
targetSpace.m_localMatrixAdd = Matrix.CreateRotationX(MathHelper.PiOver2) * targetSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.YMinusHalfX:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationY(MathHelper.Pi) * sourceSpace.m_localMatrixAdd;
targetSpace.m_localMatrixAdd = Matrix.CreateRotationX(MathHelper.PiOver2) * targetSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.ZMinusHalfX:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationZ(MathHelper.Pi) * sourceSpace.m_localMatrixAdd;
targetSpace.m_localMatrixAdd = Matrix.CreateRotationX(MathHelper.PiOver2) * targetSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.MinusHalfX:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationX(MathHelper.PiOver2) * sourceSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.MinusHalfY:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationY(MathHelper.PiOver2) * sourceSpace.m_localMatrixAdd;
break;
case Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.MinusHalfZ:
targetSpace.m_localMatrixAdd = Matrix.CreateRotationZ(MathHelper.PiOver2) * sourceSpace.m_localMatrixAdd;
break;
default:
targetSpace.m_localMatrixAdd = sourceSpace.m_localMatrixAdd;
break;
}
if (!string.IsNullOrEmpty(sourceSpace.m_blockDefinition.MirroringBlock))
{
targetSpace.m_blockDefinition = MyDefinitionManager.Static.GetCubeBlockDefinition(new MyDefinitionId(typeof(MyObjectBuilder_CubeBlock), sourceSpace.m_blockDefinition.MirroringBlock));
}
else
targetSpace.m_blockDefinition = sourceSpace.m_blockDefinition;
// Correct mirroring of objects with center offset
// if (blockMirrorOption == Common.ObjectBuilders.Definitions.MySymmetryAxisEnum.None)
if (cubeBlockDefinition.SymmetryX == MySymmetryAxisEnum.None && cubeBlockDefinition.SymmetryY == MySymmetryAxisEnum.None && cubeBlockDefinition.SymmetryZ == MySymmetryAxisEnum.None)
{
Vector3 min = sourceSpace.m_min * cubeGrid.GridSize - new Vector3(cubeGrid.GridSize / 2);
Vector3 max = sourceSpace.m_max * cubeGrid.GridSize + new Vector3(cubeGrid.GridSize / 2);
BoundingBox box = new BoundingBox(min, max);
//Mirroring algorithm
// 1. Find vector from closest source box side to mirror (vector A)
// 2. Find vector from source box pos to opposite side (vector B)
// 3. Correct mirrored position is source box pos + A - B
if (box.Size.X > 1 * cubeGrid.GridSize || box.Size.Y > 1 * cubeGrid.GridSize || box.Size.Z > 1 * cubeGrid.GridSize)
{
//align to mirror
BoundingBox worldAABB = box.Transform((Matrix)cubeGrid.WorldMatrix);
//VRageRender.MyRenderProxy.DebugDrawAABB(worldAABB, Vector3.One, 1, 1, false);
Vector3 sourceCenterFloatLocal = sourceSpace.m_localMatrixAdd.Translation * cubeGrid.GridSize;
Vector3 sourceCenterWorld = Vector3.Transform(sourceCenterFloatLocal, cubeGrid.WorldMatrix);
//VRageRender.MyRenderProxy.DebugDrawSphere(sourceCenterWorld, 0.5f, Vector3.One, 1, false, false);
Vector3I localToMirror = mirrorPosition - new Vector3I(sourceSpace.m_localMatrixAdd.Translation);
Vector3 floatLocalToMirror = localToMirror * cubeGrid.GridSize;
if (isOdd)
{
floatLocalToMirror.X -= cubeGrid.GridSize / 2;
floatLocalToMirror.Y -= cubeGrid.GridSize / 2;
floatLocalToMirror.Z += cubeGrid.GridSize / 2;
}
Vector3 fullFloatLocalToMirror = floatLocalToMirror;
Vector3 alignedFloatLocalToMirror = Vector3.Clamp(sourceCenterFloatLocal + floatLocalToMirror, box.Min, box.Max) - sourceCenterFloatLocal;
Vector3 alignedFloatLocalToBoxEnd = Vector3.Clamp(sourceCenterFloatLocal + floatLocalToMirror * 100, box.Min, box.Max) - sourceCenterFloatLocal;
Vector3 oppositeFromMirror = Vector3.Clamp(sourceCenterFloatLocal - floatLocalToMirror * 100, box.Min, box.Max) - sourceCenterFloatLocal;
if (mirrorPlane == MySymmetrySettingModeEnum.XPlane || mirrorPlane == MySymmetrySettingModeEnum.XPlaneOdd)
{
oppositeFromMirror.Y = 0;
oppositeFromMirror.Z = 0;
alignedFloatLocalToMirror.Y = 0;
alignedFloatLocalToMirror.Z = 0;
fullFloatLocalToMirror.Y = 0;
fullFloatLocalToMirror.Z = 0;
alignedFloatLocalToBoxEnd.Y = 0;
alignedFloatLocalToBoxEnd.Z = 0;
}
else
if (mirrorPlane == MySymmetrySettingModeEnum.YPlane || mirrorPlane == MySymmetrySettingModeEnum.YPlaneOdd)
{
oppositeFromMirror.X = 0;
oppositeFromMirror.Z = 0;
alignedFloatLocalToMirror.X = 0;
alignedFloatLocalToMirror.Z = 0;
fullFloatLocalToMirror.X = 0;
fullFloatLocalToMirror.Z = 0;
alignedFloatLocalToBoxEnd.X = 0;
alignedFloatLocalToBoxEnd.Z = 0;
}
else
if (mirrorPlane == MySymmetrySettingModeEnum.ZPlane || mirrorPlane == MySymmetrySettingModeEnum.ZPlaneOdd)
{
oppositeFromMirror.Y = 0;
oppositeFromMirror.X = 0;
alignedFloatLocalToMirror.Y = 0;
alignedFloatLocalToMirror.X = 0;
fullFloatLocalToMirror.Y = 0;
fullFloatLocalToMirror.X = 0;
alignedFloatLocalToBoxEnd.Y = 0;
alignedFloatLocalToBoxEnd.X = 0;
}
Vector3 sideLocalToMirror = fullFloatLocalToMirror - alignedFloatLocalToMirror;
Vector3 alignedWorldToMirror = Vector3.TransformNormal(alignedFloatLocalToMirror, cubeGrid.WorldMatrix);
Vector3 fullWorldToMirror = Vector3.TransformNormal(fullFloatLocalToMirror, cubeGrid.WorldMatrix);
Vector3 oppositeWorldToMirror = Vector3.TransformNormal(oppositeFromMirror, cubeGrid.WorldMatrix);
//VRageRender.MyRenderProxy.DebugDrawLine3D(sourceCenterWorld, sourceCenterWorld + alignedWorldToMirror, Color.Red, Color.Red, false);
//VRageRender.MyRenderProxy.DebugDrawLine3D(sourceCenterWorld + alignedWorldToMirror, sourceCenterWorld + fullWorldToMirror, Color.Yellow, Color.Yellow, false);
//VRageRender.MyRenderProxy.DebugDrawLine3D(sourceCenterWorld, sourceCenterWorld + oppositeWorldToMirror, Color.Blue, Color.Blue, false);
bool isInsideMirror = false;
if (fullFloatLocalToMirror.LengthSquared() < alignedFloatLocalToBoxEnd.LengthSquared())
{
isInsideMirror = true;
}
Vector3 newOffsetFromMirror = sideLocalToMirror;
Vector3 newOffsetFromBox = -oppositeFromMirror;
Vector3 newOffsetFromMirrorWorld = Vector3.TransformNormal(newOffsetFromMirror, cubeGrid.WorldMatrix);
Vector3 newOffsetFromBoxWorld = Vector3.TransformNormal(newOffsetFromBox, cubeGrid.WorldMatrix);
Vector3 mirrorPositionWorld = sourceCenterWorld + fullWorldToMirror;
//VRageRender.MyRenderProxy.DebugDrawLine3D(mirrorPositionWorld, mirrorPositionWorld + newOffsetFromMirrorWorld, Color.Yellow, Color.Yellow, false);
//VRageRender.MyRenderProxy.DebugDrawLine3D(mirrorPositionWorld + newOffsetFromMirrorWorld, mirrorPositionWorld + newOffsetFromMirrorWorld + newOffsetFromBoxWorld, Color.Blue, Color.Blue, false);
Vector3 newLocalFromMirror = newOffsetFromMirror + newOffsetFromBox;
Vector3 newWorldFromMirror = Vector3.TransformNormal(newLocalFromMirror, cubeGrid.WorldMatrix);
//VRageRender.MyRenderProxy.DebugDrawLine3D(mirrorPositionWorld, mirrorPositionWorld + newWorldFromMirror, Color.Green, Color.Green, false);
Vector3 fromMirrorFloat = sourceSpace.m_localMatrixAdd.Translation + (fullFloatLocalToMirror + newLocalFromMirror) / cubeGrid.GridSize;
if (!isInsideMirror)
{
Vector3 worldFromMirror = Vector3.TransformNormal(fromMirrorFloat, cubeGrid.WorldMatrix);
//VRageRender.MyRenderProxy.DebugDrawLine3D(sourceCenterWorld, sourceCenterWorld + worldFromMirror, Color.White, Color.Black, false);
Vector3 newPos = fromMirrorFloat;// / CurrentGrid.GridSize;
//VRageRender.MyRenderProxy.DebugDrawSphere(Vector3.Transform(targetSpace.m_gizmoAddPos * CurrentGrid.GridSize, CurrentGrid.WorldMatrix), 0.2f, Vector3.One, 1, false);
targetSpace.m_mirroringOffset = new Vector3I(newPos) - targetSpace.m_addPos;
targetSpace.m_addPos += targetSpace.m_mirroringOffset;
targetSpace.m_removePos += targetSpace.m_mirroringOffset;
targetSpace.m_removeBlock = cubeGrid.GetCubeBlock(targetSpace.m_removePos);
targetSpace.m_addDir = sourceSpace.m_addDir;
targetSpace.m_localMatrixAdd.Translation = targetSpace.m_addPos;
if (targetSpace.m_startBuild != null)
targetSpace.m_startBuild = targetSpace.m_startBuild + targetSpace.m_mirroringOffset;
}
else
{
targetSpace.m_mirroringOffset = Vector3I.Zero;
targetSpace.m_addPos = sourceSpace.m_addPos;
targetSpace.m_removePos = sourceSpace.m_removePos;
targetSpace.m_removeBlock = cubeGrid.GetCubeBlock(sourceSpace.m_removePos);
}
}
}
if (blockMirrorOption == MySymmetryAxisEnum.ZThenOffsetX)
{
Vector3I offset = new Vector3I(targetSpace.m_localMatrixAdd.Down);
targetSpace.m_mirroringOffset = offset;
targetSpace.m_addPos += targetSpace.m_mirroringOffset;
targetSpace.m_removePos += targetSpace.m_mirroringOffset;
targetSpace.m_removeBlock = cubeGrid.GetCubeBlock(targetSpace.m_removePos);
//targetSpace.m_gizmoAddDir = sourceSpace.m_gizmoAddDir;
targetSpace.m_localMatrixAdd.Translation += offset;
}
targetSpace.m_worldMatrixAdd = targetSpace.m_localMatrixAdd * cubeGrid.WorldMatrix;
Debug.Assert(!targetSpace.m_worldMatrixAdd.IsNan(), "Invalid gizmo matrix");
}
Color DrawSymmetryPlane(MySymmetrySettingModeEnum plane, MyCubeGrid localGrid, Vector3 center)
{
var localGridBB = localGrid.PositionComp.LocalAABB;
float sizeMultiplier = 1.0f;
float sizeOffset = localGrid.GridSize;
Vector3 l0 = Vector3.Zero;
Vector3 l1 = Vector3.Zero;
Vector3 l2 = Vector3.Zero;
Vector3 l3 = Vector3.Zero;
float alpha = 0.3f;
Color color = Color.Gray;
switch (plane)
{
case MySymmetrySettingModeEnum.XPlane:
case MySymmetrySettingModeEnum.XPlaneOdd:
{
color = new Color(1.0f, 0, 0, alpha);
center.X -= localGridBB.Center.X + (plane == MySymmetrySettingModeEnum.XPlaneOdd ? localGrid.GridSize * 0.5f : 0);
center.Y = 0;
center.Z = 0;
l0 = new Vector3(0, localGridBB.HalfExtents.Y * sizeMultiplier + sizeOffset, localGridBB.HalfExtents.Z * sizeMultiplier + sizeOffset) + localGridBB.Center + center;
l1 = new Vector3(0, -localGridBB.HalfExtents.Y * sizeMultiplier - sizeOffset, localGridBB.HalfExtents.Z * sizeMultiplier + sizeOffset) + localGridBB.Center + center;
l2 = new Vector3(0, localGridBB.HalfExtents.Y * sizeMultiplier + sizeOffset, -localGridBB.HalfExtents.Z * sizeMultiplier - sizeOffset) + localGridBB.Center + center;
l3 = new Vector3(0, -localGridBB.HalfExtents.Y * sizeMultiplier - sizeOffset, -localGridBB.HalfExtents.Z * sizeMultiplier - sizeOffset) + localGridBB.Center + center;
}
break;
case MySymmetrySettingModeEnum.YPlane:
case MySymmetrySettingModeEnum.YPlaneOdd:
{
color = new Color(0.0f, 1.0f, 0, alpha);
center.X = 0;
center.Y -= localGridBB.Center.Y + (plane == MySymmetrySettingModeEnum.YPlaneOdd ? localGrid.GridSize * 0.5f : 0);
center.Z = 0;
l0 = new Vector3(localGridBB.HalfExtents.X * sizeMultiplier + sizeOffset, 0, localGridBB.HalfExtents.Z * sizeMultiplier + sizeOffset) + localGridBB.Center + center;
l1 = new Vector3(-localGridBB.HalfExtents.X * sizeMultiplier - sizeOffset, 0, localGridBB.HalfExtents.Z * sizeMultiplier + sizeOffset) + localGridBB.Center + center;
l2 = new Vector3(localGridBB.HalfExtents.X * sizeMultiplier + sizeOffset, 0, -localGridBB.HalfExtents.Z * sizeMultiplier - sizeOffset) + localGridBB.Center + center;
l3 = new Vector3(-localGridBB.HalfExtents.X * sizeMultiplier - sizeOffset, 0, -localGridBB.HalfExtents.Z * sizeMultiplier - sizeOffset) + localGridBB.Center + center;
}
break;
case MySymmetrySettingModeEnum.ZPlane:
case MySymmetrySettingModeEnum.ZPlaneOdd:
{
color = new Color(0.0f, 0, 1.0f, alpha);
center.X = 0;
center.Y = 0;
center.Z -= localGridBB.Center.Z - (plane == MySymmetrySettingModeEnum.ZPlaneOdd ? localGrid.GridSize * 0.5f : 0);
l0 = new Vector3(localGridBB.HalfExtents.X * sizeMultiplier + sizeOffset, localGridBB.HalfExtents.Y * sizeMultiplier + sizeOffset, 0) + localGridBB.Center + center;
l1 = new Vector3(-localGridBB.HalfExtents.X * sizeMultiplier - sizeOffset, localGridBB.HalfExtents.Y * sizeMultiplier + sizeOffset, 0) + localGridBB.Center + center;
l2 = new Vector3(localGridBB.HalfExtents.X * sizeMultiplier + sizeOffset, -localGridBB.HalfExtents.Y * sizeMultiplier - sizeOffset, 0) + localGridBB.Center + center;
l3 = new Vector3(-localGridBB.HalfExtents.X * sizeMultiplier - sizeOffset, -localGridBB.HalfExtents.Y * sizeMultiplier - sizeOffset, 0) + localGridBB.Center + center;
}
break;
}
Vector3 p0 = Vector3.Transform(l0, (Matrix)CurrentGrid.WorldMatrix);
Vector3 p1 = Vector3.Transform(l1, (Matrix)CurrentGrid.WorldMatrix);
Vector3 p2 = Vector3.Transform(l2, (Matrix)CurrentGrid.WorldMatrix);
Vector3 p3 = Vector3.Transform(l3, (Matrix)CurrentGrid.WorldMatrix);
VRageRender.MyRenderProxy.DebugDrawTriangle(p0, p1, p2, color, true, true);
VRageRender.MyRenderProxy.DebugDrawTriangle(p2, p1, p3, color, true, true);
return(color);
}
private static Vector3I MirrorDirByPlane(MySymmetrySettingModeEnum mirror, Vector3I mirrorDir, bool isOdd, Vector3I sourceDir)
{
Vector3I mirroredDir = sourceDir;
if (mirror == MySymmetrySettingModeEnum.XPlane)
{
mirroredDir = new Vector3I(-sourceDir.X, sourceDir.Y, sourceDir.Z);
}
if (mirror == MySymmetrySettingModeEnum.YPlane)
{
mirroredDir = new Vector3I(sourceDir.X, -sourceDir.Y, sourceDir.Z);
}
if (mirror == MySymmetrySettingModeEnum.ZPlane)
{
mirroredDir = new Vector3I(sourceDir.X, sourceDir.Y, -sourceDir.Z);
}
return mirroredDir;
}
private static Vector3I MirrorBlockByPlane(MySymmetrySettingModeEnum mirror, Vector3I mirrorPosition, bool isOdd, Vector3I sourcePosition)
{
Vector3I mirroredPosition = sourcePosition;
if (mirror == MySymmetrySettingModeEnum.XPlane)
{
mirroredPosition = new Vector3I(mirrorPosition.X - (sourcePosition.X - mirrorPosition.X), sourcePosition.Y, sourcePosition.Z);
if (isOdd)
mirroredPosition.X -= 1;
}
if (mirror == MySymmetrySettingModeEnum.YPlane)
{
mirroredPosition = new Vector3I(sourcePosition.X, mirrorPosition.Y - (sourcePosition.Y - mirrorPosition.Y), sourcePosition.Z);
if (isOdd)
mirroredPosition.Y -= 1;
}
if (mirror == MySymmetrySettingModeEnum.ZPlane)
{
mirroredPosition = new Vector3I(sourcePosition.X, sourcePosition.Y, mirrorPosition.Z - (sourcePosition.Z - mirrorPosition.Z));
if (isOdd)
mirroredPosition.Z += 1;
}
return mirroredPosition;
}
public bool HandleGameInput()
{
m_rotationHintRotating = false;
int frameDt = MySandboxGame.TotalGamePlayTimeInMilliseconds - m_lastInputHandleTime;
m_lastInputHandleTime += frameDt;
bool disallowCockpitBuilding = MySession.ControlledEntity is MyCockpit && !DeveloperSpectatorIsBuilding;
// Don't allow cube builder when paused or when in cockpit and not in developer spectator mode
if (MySandboxGame.IsPaused || disallowCockpitBuilding)
return false;
//batch convert should be active in any game mode
if (MyInput.Static.ENABLE_DEVELOPER_KEYS && MyInput.Static.IsNewKeyPressed(MyKeys.R) && MyInput.Static.IsAnyCtrlKeyPressed() && !MyInput.Static.IsAnyShiftKeyPressed() && !MyInput.Static.IsAnyMousePressed())
{
MyGuiAudio.PlaySound(MyGuiSounds.HudMouseClick);
MyCubeGrid.ConvertPrefabsToObjs();
return true;
}
if (MyInput.Static.ENABLE_DEVELOPER_KEYS && MyInput.Static.IsNewKeyPressed(MyKeys.T) && MyInput.Static.IsAnyCtrlKeyPressed() && !MyInput.Static.IsAnyShiftKeyPressed() && !MyInput.Static.IsAnyMousePressed() && MyPerGameSettings.EnableObjectExport)
{
MyGuiAudio.PlaySound(MyGuiSounds.HudMouseClick);
MyCubeGrid.PlacePrefabsToWorld();
return true;
}
if (MyInput.Static.IsNewKeyPressed(MyKeys.E) && MyInput.Static.IsAnyAltKeyPressed() && MyInput.Static.IsAnyCtrlKeyPressed() && !MyInput.Static.IsAnyShiftKeyPressed() && !MyInput.Static.IsAnyMousePressed() && MyPerGameSettings.EnableObjectExport)
{
MyGuiAudio.PlaySound(MyGuiSounds.HudMouseClick);
var targetGrid = MyCubeGrid.GetTargetGrid();
if (targetGrid != null)
{
MyCubeGrid.ExportObject(targetGrid, false, true);
}
return true;
}
if (MyInput.Static.IsNewGameControlPressed(ME_SI_VIEW))
{
MyCubeGrid.ShowStructuralIntegrity = !MyCubeGrid.ShowStructuralIntegrity;
}
var context = (IsActivated && MySession.ControlledEntity is MyCharacter) ? MySession.ControlledEntity.ControlContext : MyStringId.NullOrEmpty;
if (IsActivated && MyControllerHelper.IsControl(context, MyControlsSpace.BUILD_MODE))
{
IsBuildMode = !IsBuildMode;
}
// When spectator active, building is instant
if (MySession.Static.CreativeMode || DeveloperSpectatorIsBuilding)
{
if (MySession.Static.EnableCopyPaste)
{
if (MyInput.Static.IsNewKeyPressed(MyKeys.C) && MyInput.Static.IsAnyCtrlKeyPressed() && !MyInput.Static.IsAnyMousePressed())
{
if (MySession.Static.CameraController is MyCharacter || MySession.GetCameraControllerEnum() == MyCameraControllerEnum.Spectator)
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
if (m_clipboard.IsActive == false)
{
MySessionComponentVoxelHand.Static.Enabled = false;
DeactivateMultiBlockClipboard();
if (!MyInput.Static.IsAnyShiftKeyPressed())
{
m_clipboard.CopyGroup(MyCubeGrid.GetTargetGrid());
}
else
m_clipboard.CopyGrid(MyCubeGrid.GetTargetGrid());
UpdatePasteNotification(MySpaceTexts.CubeBuilderPasteNotification);
}
return true;
}
}
if (MyInput.Static.IsNewKeyPressed(MyKeys.X) && MyInput.Static.IsAnyCtrlKeyPressed())
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
MyEntity entity = MyCubeGrid.GetTargetEntity();
if (entity == null)
{
return true;
}
else if (entity is MyCubeGrid && m_clipboard.IsActive == false)
{
bool cutGroup = !MyInput.Static.IsAnyShiftKeyPressed();
if (MyFakes.CLIPBOARD_CUT_CONFIRMATION)
{
MyEntities.EnableEntityBoundingBoxDraw(entity, true);
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox(
buttonType: MyMessageBoxButtonsType.YES_NO,
messageText: MyTexts.Get(MySpaceTexts.MessageBoxTextAreYouSureToMoveGridToClipboard),
messageCaption: MyTexts.Get(MySpaceTexts.MessageBoxCaptionPleaseConfirm),
callback: (v) =>
{
if (v == MyGuiScreenMessageBox.ResultEnum.YES)
OnCutConfirm(entity as MyCubeGrid, cutGroup);
MyEntities.EnableEntityBoundingBoxDraw(entity, false);
}));
}
else
OnCutConfirm(entity as MyCubeGrid, cutGroup);
}
else if (entity is MyVoxelMap && m_voxelClipboard.IsActive == false &&
MyPerGameSettings.GUI.VoxelMapEditingScreen == typeof(MyGuiScreenDebugSpawnMenu) // hack to disable this in ME
)
{
if (MyFakes.CLIPBOARD_CUT_CONFIRMATION)
{
MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox(
buttonType: MyMessageBoxButtonsType.YES_NO,
messageText: MyTexts.Get(MySpaceTexts.MessageBoxTextAreYouSureToRemoveAsteroid),
messageCaption: MyTexts.Get(MySpaceTexts.MessageBoxCaptionPleaseConfirm),
callback: (v) =>
{
if (v == MyGuiScreenMessageBox.ResultEnum.YES)
OnCutAsteroidConfirm(entity as MyVoxelMap);
MyEntities.EnableEntityBoundingBoxDraw(entity, false);
}));
}
else
OnCutAsteroidConfirm(entity as MyVoxelMap);
}
return true;
}
if (MyInput.Static.IsNewKeyPressed(MyKeys.V) && MyInput.Static.IsAnyCtrlKeyPressed() && !MyInput.Static.IsAnyShiftKeyPressed())
{
DeactivateBlockCreation();
if (m_clipboard.PasteGrid())
{
UpdatePasteNotification(MySpaceTexts.CubeBuilderPasteNotification);
return true;
}
}
if (HandleBlockCreationMovement(context))
return true;
}
if (MyInput.Static.IsAnyCtrlKeyPressed() && m_shipCreationClipboard.IsActive)
{
if (MyInput.Static.PreviousMouseScrollWheelValue() < MyInput.Static.MouseScrollWheelValue())
{
m_shipCreationClipboard.MoveEntityFurther();
return true;
}
else if (MyInput.Static.PreviousMouseScrollWheelValue() > MyInput.Static.MouseScrollWheelValue())
{
m_shipCreationClipboard.MoveEntityCloser();
return true;
}
}
if (MyInput.Static.IsNewKeyPressed(MyKeys.Escape))
{
if (m_clipboard.IsActive)
{
m_clipboard.Deactivate();
UpdatePasteNotification(MySpaceTexts.CubeBuilderPasteNotification);
return true;
}
if (m_floatingObjectClipboard.IsActive)
{
m_floatingObjectClipboard.Deactivate();
UpdatePasteNotification(MySpaceTexts.CubeBuilderPasteNotification);
return true;
}
if (m_voxelClipboard.IsActive)
{
m_voxelClipboard.Deactivate();
UpdatePasteNotification(MySpaceTexts.CubeBuilderPasteNotification);
return true;
}
if (m_shipCreationClipboard.IsActive)
{
m_shipCreationClipboard.Deactivate();
UpdatePasteNotification(MySpaceTexts.CubeBuilderPasteNotification);
return true;
}
//if (m_multiBlockCreationClipboard.IsActive)
//{
// m_multiBlockCreationClipboard.Deactivate();
// UpdatePasteNotification(MySpaceTexts.CubeBuilderPasteNotification);
// return true;
//}
}
if (MyInput.Static.IsNewGameControlPressed(ME_PICK_BLOCK) && !MyInput.Static.IsAnyCtrlKeyPressed())
{
LineD line = new LineD(MySector.MainCamera.Position, MySector.MainCamera.Position + MySector.MainCamera.ForwardVector * 100);
MyCubeGrid grid = m_currentGrid;
Vector3D hitPos;
if (grid != null || MyCubeGrid.TryRayCastGrid(ref line, out grid, out hitPos))
{
var result = grid.RayCastBlocks(MySector.MainCamera.Position, MySector.MainCamera.Position + MySector.MainCamera.ForwardVector * 100);
if (result.HasValue)
{
var slot = MyToolbarComponent.CurrentToolbar.SelectedSlot;
SelectBlockToToolbar(grid.GetCubeBlock(result.Value), slot.HasValue ? false : true);
if (slot.HasValue)
MyToolbarComponent.CurrentToolbar.ActivateItemAtSlot(slot.Value);
}
}
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.PRIMARY_TOOL_ACTION))
{
if (m_clipboard.IsActive)
{
if (m_clipboard.PasteGrid())
{
UpdatePasteNotification(MySpaceTexts.CubeBuilderPasteNotification);
return true;
}
}
if (m_floatingObjectClipboard.IsActive)
{
if (m_floatingObjectClipboard.PasteFloatingObject())
{
UpdatePasteNotification(MySpaceTexts.CubeBuilderPasteNotification);
return true;
}
}
if (m_voxelClipboard.IsActive)
{
if (m_voxelClipboard.PasteVoxelMap())
{
UpdatePasteNotification(MySpaceTexts.CubeBuilderPasteNotification);
return true;
}
}
if (m_shipCreationClipboard.IsActive)
{
if (m_shipCreationClipboard.PasteGrid())
{
MyGuiAudio.PlaySound(MyGuiSounds.HudPlaceBlock);
return true;
}
}
if (m_multiBlockCreationClipboard.IsActive)
{
if (m_multiBlockCreationClipboard.PasteGrid(deactivate: false))
MyGuiAudio.PlaySound(MyGuiSounds.HudPlaceBlock);
return true;
}
}
if (CurrentGrid != null)
{
if (MyControllerHelper.IsControl(context, MyControlsSpace.SYMMETRY_SWITCH, MyControlStateType.NEW_PRESSED))
{
if (BlockCreationIsActivated)
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
switch (m_symmetrySettingMode)
{
case MySymmetrySettingModeEnum.NoPlane:
m_symmetrySettingMode = MySymmetrySettingModeEnum.XPlane;
UpdateSymmetryNotification(MySpaceTexts.SettingSymmetryX);
break;
case MySymmetrySettingModeEnum.XPlane:
m_symmetrySettingMode = MySymmetrySettingModeEnum.XPlaneOdd;
UpdateSymmetryNotification(MySpaceTexts.SettingSymmetryXOffset);
break;
case MySymmetrySettingModeEnum.XPlaneOdd:
m_symmetrySettingMode = MySymmetrySettingModeEnum.YPlane;
UpdateSymmetryNotification(MySpaceTexts.SettingSymmetryY);
break;
case MySymmetrySettingModeEnum.YPlane:
m_symmetrySettingMode = MySymmetrySettingModeEnum.YPlaneOdd;
UpdateSymmetryNotification(MySpaceTexts.SettingSymmetryYOffset);
break;
case MySymmetrySettingModeEnum.YPlaneOdd:
m_symmetrySettingMode = MySymmetrySettingModeEnum.ZPlane;
UpdateSymmetryNotification(MySpaceTexts.SettingSymmetryZ);
break;
case MySymmetrySettingModeEnum.ZPlane:
m_symmetrySettingMode = MySymmetrySettingModeEnum.ZPlaneOdd;
UpdateSymmetryNotification(MySpaceTexts.SettingSymmetryZOffset);
break;
case MySymmetrySettingModeEnum.ZPlaneOdd:
m_symmetrySettingMode = MySymmetrySettingModeEnum.NoPlane;
RemoveSymmetryNotification();
break;
}
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.USE_SYMMETRY, MyControlStateType.NEW_PRESSED))
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
if (m_symmetrySettingMode != MySymmetrySettingModeEnum.NoPlane)
{
UseSymmetry = false;
m_symmetrySettingMode = MySymmetrySettingModeEnum.NoPlane;
RemoveSymmetryNotification();
return true;
}
UseSymmetry = !UseSymmetry;
}
if (CurrentBlockDefinition == null || !BlockCreationIsActivated)
{
m_symmetrySettingMode = MySymmetrySettingModeEnum.NoPlane;
RemoveSymmetryNotification();
}
if (IsInSymmetrySettingMode)
{
if (MyControllerHelper.IsControl(context, MyControlsSpace.PRIMARY_TOOL_ACTION, MyControlStateType.NEW_PRESSED))
{
if (m_gizmo.SpaceDefault.m_removeBlock != null)
{
Vector3I center = (m_gizmo.SpaceDefault.m_removeBlock.Min + m_gizmo.SpaceDefault.m_removeBlock.Max) / 2;
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
switch (m_symmetrySettingMode)
{
case MySymmetrySettingModeEnum.NoPlane:
System.Diagnostics.Debug.Assert(false, "Cannot get here");
break;
case MySymmetrySettingModeEnum.XPlane:
CurrentGrid.XSymmetryPlane = center;
CurrentGrid.XSymmetryOdd = false;
break;
case MySymmetrySettingModeEnum.XPlaneOdd:
CurrentGrid.XSymmetryPlane = center;
CurrentGrid.XSymmetryOdd = true;
break;
case MySymmetrySettingModeEnum.YPlane:
CurrentGrid.YSymmetryPlane = center;
CurrentGrid.YSymmetryOdd = false;
break;
case MySymmetrySettingModeEnum.YPlaneOdd:
CurrentGrid.YSymmetryPlane = center;
CurrentGrid.YSymmetryOdd = true;
break;
case MySymmetrySettingModeEnum.ZPlane:
CurrentGrid.ZSymmetryPlane = center;
CurrentGrid.ZSymmetryOdd = false;
break;
case MySymmetrySettingModeEnum.ZPlaneOdd:
CurrentGrid.ZSymmetryPlane = center;
CurrentGrid.ZSymmetryOdd = true;
break;
}
}
return true;
} //if (input.IsNewLeftMousePressed())
if (MyControllerHelper.IsControl(context, MyControlsSpace.SECONDARY_TOOL_ACTION, MyControlStateType.NEW_PRESSED))
{
MyGuiAudio.PlaySound(MyGuiSounds.HudDeleteBlock);
switch (m_symmetrySettingMode)
{
case MySymmetrySettingModeEnum.NoPlane:
System.Diagnostics.Debug.Assert(false, "Cannot get here");
break;
case MySymmetrySettingModeEnum.XPlane:
case MySymmetrySettingModeEnum.XPlaneOdd:
CurrentGrid.XSymmetryPlane = null;
CurrentGrid.XSymmetryOdd = false;
break;
case MySymmetrySettingModeEnum.YPlane:
case MySymmetrySettingModeEnum.YPlaneOdd:
CurrentGrid.YSymmetryPlane = null;
CurrentGrid.YSymmetryOdd = false;
break;
case MySymmetrySettingModeEnum.ZPlane:
case MySymmetrySettingModeEnum.ZPlaneOdd:
CurrentGrid.ZSymmetryPlane = null;
CurrentGrid.ZSymmetryOdd = false;
break;
}
return false;
}
} //if (IsInSymmetrySettingMode)
if (MyInput.Static.IsNewKeyPressed(MyKeys.Escape))
{
if (m_symmetrySettingMode != MySymmetrySettingModeEnum.NoPlane)
{
m_symmetrySettingMode = MySymmetrySettingModeEnum.NoPlane;
RemoveSymmetryNotification();
return true;
}
if (m_gizmo.SpaceDefault.m_continueBuild != null)
{
m_gizmo.SpaceDefault.m_startBuild = null;
m_gizmo.SpaceDefault.m_startRemove = null;
m_gizmo.SpaceDefault.m_continueBuild = null;
return true;
}
}
if (MyInput.Static.IsNewLeftMousePressed() || MyControllerHelper.IsControl(context, MyControlsSpace.PRIMARY_BUILD_ACTION))
{
if (!PlacingSmallGridOnLargeStatic && (MyInput.Static.IsAnyCtrlKeyPressed() || BuildingMode != BuildingModeEnum.SingleBlock))
{
StartBuilding();
}
else
{
Add();
}
}
if (MyInput.Static.IsNewRightMousePressed() || MyControllerHelper.IsControl(context, MyControlsSpace.SECONDARY_BUILD_ACTION))
{
if (MyInput.Static.IsAnyCtrlKeyPressed() || BuildingMode != BuildingModeEnum.SingleBlock)
{
StartRemoving();
}
else
{
if (MyFakes.ENABLE_COMPOUND_BLOCKS && !CompoundEnabled)
{
foreach (var gizmoSpace in m_gizmo.Spaces)
{
if (!gizmoSpace.Enabled)
continue;
gizmoSpace.m_blockIdInCompound = null;
}
}
Remove();
}
}
if (MyInput.Static.IsLeftMousePressed() ||
MyInput.Static.IsRightMousePressed())
{
ContinueBuilding(MyInput.Static.IsAnyShiftKeyPressed() || BuildingMode == BuildingModeEnum.Plane);
}
if (MyInput.Static.IsNewLeftMouseReleased() ||
MyInput.Static.IsNewRightMouseReleased())
{
StopBuilding();
}
} //if (CurrentGrid != null)
else if (CurrentVoxelMap != null)
{
//RKTODO - creation of blocks in line or plane will be done when server function will be prepared
// (need to create grid with one block - the first target and then build all other blocks in the grid)
//if (MyInput.Static.IsNewKeyPressed(Keys.Escape))
//{
// if (m_gizmo.SpaceDefault.m_continueBuild != null)
// {
// m_gizmo.SpaceDefault.m_startBuild = null;
// m_gizmo.SpaceDefault.m_startRemove = null;
// m_gizmo.SpaceDefault.m_continueBuild = null;
// return true;
// }
//}
if (MyControllerHelper.IsControl(context, MyControlsSpace.PRIMARY_TOOL_ACTION))
{
//if (MyInput.Static.IsAnyCtrlKeyPressed() || BuildingMode != BuildingModeEnum.SingleBlock)
//{
// StartBuilding();
//}
//else
{
Add();
}
}
//if (MyInput.Static.IsLeftMousePressed() ||
// MyInput.Static.IsRightMousePressed())
//{
// ContinueBuilding(MyInput.Static.IsAnyShiftKeyPressed() || BuildingMode == BuildingModeEnum.Plane);
//}
//if (MyInput.Static.IsNewLeftMouseReleased() ||
// MyInput.Static.IsNewRightMouseReleased())
//{
// StopBuilding();
//}
} //if (CurrentVoxelMap != null)
else if (DynamicMode)
{
if (MyControllerHelper.IsControl(context, MyControlsSpace.PRIMARY_TOOL_ACTION))
{
Add();
}
} // if (DynamicMode)
}
else if (MySession.Static.SimpleSurvival)
{
if (DynamicMode && HandleBlockCreationMovement(context))
return true;
if (MyControllerHelper.IsControl(MySpaceBindingCreator.CX_CHARACTER, MyControlsSpace.SECONDARY_TOOL_ACTION))
{
if (MyFakes.ENABLE_COMPOUND_BLOCKS && !CompoundEnabled)
{
foreach (var gizmoSpace in m_gizmo.Spaces)
{
if (!gizmoSpace.Enabled)
continue;
gizmoSpace.m_blockIdInCompound = null;
}
}
Remove();
}
}
else if (MyFakes.ENABLE_BATTLE_SYSTEM && MySession.Static.Battle)
{
if (MyControllerHelper.IsControl(context, MyControlsSpace.PRIMARY_TOOL_ACTION))
{
if (m_clipboard.IsActive)
{
if (m_clipboard.PasteGrid())
{
UpdatePasteNotification(MySpaceTexts.CubeBuilderPasteNotification);
return true;
}
}
}
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.SWITCH_COMPOUND, MyControlStateType.NEW_PRESSED))
CompoundEnabled = !CompoundEnabled;
if (MyInput.Static.IsNewGameControlPressed(ME_PRESS_TO_COMPOUND))
CompoundEnabled = true;
if (MyInput.Static.IsNewGameControlReleased(ME_PRESS_TO_COMPOUND))
CompoundEnabled = false;
if (MyInput.Static.IsNewKeyPressed(MyKeys.B) && MyInput.Static.IsAnyCtrlKeyPressed() && !MyInput.Static.IsAnyMousePressed())
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
if (!m_clipboard.IsActive && !MySession.Static.Battle)
{
MySessionComponentVoxelHand.Static.Enabled = false;
var copiedGrid = MyCubeGrid.GetTargetGrid();
if (!MyInput.Static.IsAnyShiftKeyPressed())
m_clipboard.CopyGroup(copiedGrid);
else
m_clipboard.CopyGrid(copiedGrid);
UpdatePasteNotification(MySpaceTexts.CubeBuilderPasteNotification);
var blueprintScreen = new MyGuiBlueprintScreen(m_clipboard);
if (copiedGrid != null)
{
blueprintScreen.CreateFromClipboard(true);
}
m_clipboard.Deactivate();
MyGuiSandbox.AddScreen(blueprintScreen);
}
return true;
}
if (MyInput.Static.IsNewKeyPressed(MyKeys.Escape))
{
if (m_shipCreationClipboard.IsActive)
{
/*m_shipCreationClipboard.Deactivate();*/
Deactivate();
return true;
}
}
if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.LANDING_GEAR) && MySession.LocalHumanPlayer != null && MySession.LocalHumanPlayer.Identity.Character == MySession.ControlledEntity)
{
if (!MyInput.Static.IsAnyShiftKeyPressed() && MyGuiScreenGamePlay.ActiveGameplayScreen == null)
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
MyGuiSandbox.AddScreen(MyGuiScreenGamePlay.ActiveGameplayScreen = new MyGuiScreenColorPicker());
}
}
if (CurrentGrid != null && MyInput.Static.IsNewGameControlPressed(MyControlsSpace.LANDING_GEAR))
{
if (MyInput.Static.IsAnyShiftKeyPressed())
{
foreach (var gizmoSpace in m_gizmo.Spaces)
{
if (gizmoSpace.m_removeBlock != null)
MyToolbar.ColorMaskHSV = gizmoSpace.m_removeBlock.ColorMaskHSV;
}
}
}
if (CurrentGrid != null && MyInput.Static.IsGameControlPressed(MyControlsSpace.CUBE_COLOR_CHANGE))
{
int expand = MyInput.Static.IsAnyCtrlKeyPressed() ? 1 : 0;
expand = MyInput.Static.IsAnyShiftKeyPressed() ? 3 : expand;
Change(expand);
}
if (IsActivated)
{
for (int i = 0; i < 6; ++i)
{
bool standardRotation = MyControllerHelper.IsControl(context, m_rotationControls[i], MyControlStateType.PRESSED);
if (standardRotation)
{
bool newStandardPress = MyControllerHelper.IsControl(context, m_rotationControls[i], MyControlStateType.NEW_PRESSED);
bool newPress = newStandardPress;
int axis = -1;
int direction = m_rotationDirections[i];
if (MyFakes.ENABLE_STANDARD_AXES_ROTATION)
{
axis = GetStandardRotationAxisAndDirection(i, ref direction);
}
else
{
if (i < 2)
{
axis = m_rotationHints.RotationUpAxis;
direction *= m_rotationHints.RotationUpDirection;
}
if (i >= 2 && i < 4)
{
axis = m_rotationHints.RotationRightAxis;
direction *= m_rotationHints.RotationRightDirection;
}
if (i >= 4)
{
axis = m_rotationHints.RotationForwardAxis;
direction *= m_rotationHints.RotationForwardDirection;
}
}
if (axis != -1)
{
m_rotationHintRotating |= !newPress;
RotateAxis(axis, direction, newPress, frameDt);
}
}
}
}
if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.SWITCH_LEFT))
{
if (IsActivated && (CurrentBlockDefinition == null || MyFakes.ENABLE_BLOCK_COLORING))
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
MyToolbar.PrevColorSlot();
}
}
if (MyInput.Static.IsNewGameControlPressed(MyControlsSpace.SWITCH_RIGHT))
{
if (IsActivated && (CurrentBlockDefinition == null || MyFakes.ENABLE_BLOCK_COLORING))
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
MyToolbar.NextColorSlot();
}
}
if (MyFakes.ENABLE_BLOCK_STAGES && CurrentBlockDefinition != null && CurrentBlockDefinitionStages.Count > 0)
{
bool? switchForward = null;
if (!MyInput.Static.IsGameControlPressed(MyControlsSpace.LOOKAROUND) && !MyInput.Static.IsAnyCtrlKeyPressed() && !MyInput.Static.IsAnyShiftKeyPressed())
{
if (MyInput.Static.PreviousMouseScrollWheelValue() < MyInput.Static.MouseScrollWheelValue()
|| MyControllerHelper.IsControl(context, MyControlsSpace.NEXT_BLOCK_STAGE, MyControlStateType.NEW_PRESSED))
{
switchForward = true;
}
else if (MyInput.Static.PreviousMouseScrollWheelValue() > MyInput.Static.MouseScrollWheelValue()
|| MyControllerHelper.IsControl(context, MyControlsSpace.PREV_BLOCK_STAGE, MyControlStateType.NEW_PRESSED))
{
switchForward = false;
}
}
//if (switchForward == null && MyInput.Static.IsNewGameControlPressed(ME_SWITCH_STAGES))
//{
// switchForward = true;
// if (MyInput.Static.IsAnyShiftKeyPressed())
// switchForward = false;
//}
if (switchForward.HasValue)
{
int currDefinitionIndex = CurrentBlockDefinitionStages.IndexOf(CurrentBlockDefinition);
int nextIndex;
if (switchForward.Value)
{
nextIndex = 0;
if (currDefinitionIndex != -1 && currDefinitionIndex < CurrentBlockDefinitionStages.Count - 1)
nextIndex = currDefinitionIndex + 1;
}
else
{
nextIndex = CurrentBlockDefinitionStages.Count - 1;
if (currDefinitionIndex != -1 && currDefinitionIndex > 0)
nextIndex = currDefinitionIndex - 1;
}
UpdateCubeBlockStageDefinition(CurrentBlockDefinitionStages[nextIndex]);
}
}
if (MyFakes.ENABLE_CUBE_BUILDER_DYNAMIC_MODE
&& (CurrentBlockDefinition != null || (MyFakes.ENABLE_ALTERNATIVE_CLIPBOARD && m_clipboard.IsActive))
&& MyControllerHelper.IsControl(context, MyControlsSpace.SWITCH_BUILDING_MODE, MyControlStateType.NEW_PRESSED))
{
DynamicMode = !DynamicMode;
if (DynamicMode)
{
if (MySession.Static.SurvivalMode && !DeveloperSpectatorIsBuilding && CurrentBlockDefinition != null)
{
float gridSize = MyDefinitionManager.Static.GetCubeSize(CurrentBlockDefinition.CubeSize);
float maxSize = MathHelper.Max(CurrentBlockDefinition.Size.X, CurrentBlockDefinition.Size.Y, CurrentBlockDefinition.Size.Z) * gridSize;
IntersectionDistance = 1 + maxSize;
m_multiBlockCreationClipboard.SetDragDistance(IntersectionDistance);
}
}
else
{
IntersectionDistance = DEFAULT_BLOCK_BUILDING_DISTANCE;
m_multiBlockCreationClipboard.SetDragDistance(IntersectionDistance);
}
if (MyFakes.ENABLE_ALTERNATIVE_CLIPBOARD)
{
((MyGridClipboard2)m_clipboard).DynamicModeChanged();
}
}
return false;
}
Color DrawSymmetryPlane(MySymmetrySettingModeEnum plane, MyCubeGrid localGrid, Vector3 center)
{
var localGridBB = localGrid.PositionComp.LocalAABB;
float sizeMultiplier = 1.0f;
float sizeOffset = localGrid.GridSize;
Vector3 l0 = Vector3.Zero;
Vector3 l1 = Vector3.Zero;
Vector3 l2 = Vector3.Zero;
Vector3 l3 = Vector3.Zero;
float alpha = 0.3f;
Color color = Color.Gray;
switch (plane)
{
case MySymmetrySettingModeEnum.XPlane:
case MySymmetrySettingModeEnum.XPlaneOdd:
{
color = new Color(1.0f, 0, 0, alpha);
center.X -= localGridBB.Center.X + (plane == MySymmetrySettingModeEnum.XPlaneOdd ? localGrid.GridSize * 0.5f : 0);
center.Y = 0;
center.Z = 0;
l0 = new Vector3(0, localGridBB.HalfExtents.Y * sizeMultiplier + sizeOffset, localGridBB.HalfExtents.Z * sizeMultiplier + sizeOffset) + localGridBB.Center + center;
l1 = new Vector3(0, -localGridBB.HalfExtents.Y * sizeMultiplier - sizeOffset, localGridBB.HalfExtents.Z * sizeMultiplier + sizeOffset) + localGridBB.Center + center;
l2 = new Vector3(0, localGridBB.HalfExtents.Y * sizeMultiplier + sizeOffset, -localGridBB.HalfExtents.Z * sizeMultiplier - sizeOffset) + localGridBB.Center + center;
l3 = new Vector3(0, -localGridBB.HalfExtents.Y * sizeMultiplier - sizeOffset, -localGridBB.HalfExtents.Z * sizeMultiplier - sizeOffset) + localGridBB.Center + center;
}
break;
case MySymmetrySettingModeEnum.YPlane:
case MySymmetrySettingModeEnum.YPlaneOdd:
{
color = new Color(0.0f, 1.0f, 0, alpha);
center.X = 0;
center.Y -= localGridBB.Center.Y + (plane == MySymmetrySettingModeEnum.YPlaneOdd ? localGrid.GridSize * 0.5f : 0);
center.Z = 0;
l0 = new Vector3(localGridBB.HalfExtents.X * sizeMultiplier + sizeOffset, 0, localGridBB.HalfExtents.Z * sizeMultiplier + sizeOffset) + localGridBB.Center + center;
l1 = new Vector3(-localGridBB.HalfExtents.X * sizeMultiplier - sizeOffset, 0, localGridBB.HalfExtents.Z * sizeMultiplier + sizeOffset) + localGridBB.Center + center;
l2 = new Vector3(localGridBB.HalfExtents.X * sizeMultiplier + sizeOffset, 0, -localGridBB.HalfExtents.Z * sizeMultiplier - sizeOffset) + localGridBB.Center + center;
l3 = new Vector3(-localGridBB.HalfExtents.X * sizeMultiplier - sizeOffset, 0, -localGridBB.HalfExtents.Z * sizeMultiplier - sizeOffset) + localGridBB.Center + center;
}
break;
case MySymmetrySettingModeEnum.ZPlane:
case MySymmetrySettingModeEnum.ZPlaneOdd:
{
color = new Color(0.0f, 0, 1.0f, alpha);
center.X = 0;
center.Y = 0;
center.Z -= localGridBB.Center.Z - (plane == MySymmetrySettingModeEnum.ZPlaneOdd ? localGrid.GridSize * 0.5f : 0);
l0 = new Vector3(localGridBB.HalfExtents.X * sizeMultiplier + sizeOffset, localGridBB.HalfExtents.Y * sizeMultiplier + sizeOffset, 0) + localGridBB.Center + center;
l1 = new Vector3(-localGridBB.HalfExtents.X * sizeMultiplier - sizeOffset, localGridBB.HalfExtents.Y * sizeMultiplier + sizeOffset, 0) + localGridBB.Center + center;
l2 = new Vector3(localGridBB.HalfExtents.X * sizeMultiplier + sizeOffset, -localGridBB.HalfExtents.Y * sizeMultiplier - sizeOffset, 0) + localGridBB.Center + center;
l3 = new Vector3(-localGridBB.HalfExtents.X * sizeMultiplier - sizeOffset, -localGridBB.HalfExtents.Y * sizeMultiplier - sizeOffset, 0) + localGridBB.Center + center;
}
break;
}
Vector3 p0 = Vector3.Transform(l0, (Matrix)CurrentGrid.WorldMatrix);
Vector3 p1 = Vector3.Transform(l1, (Matrix)CurrentGrid.WorldMatrix);
Vector3 p2 = Vector3.Transform(l2, (Matrix)CurrentGrid.WorldMatrix);
Vector3 p3 = Vector3.Transform(l3, (Matrix)CurrentGrid.WorldMatrix);
VRageRender.MyRenderProxy.DebugDrawTriangle(p0, p1, p2, color, true, true);
VRageRender.MyRenderProxy.DebugDrawTriangle(p2, p1, p3, color, true, true);
return color;
}
/// <summary>
/// Handles input related when current grid being targeted.
/// </summary>
/// <returns></returns>
private bool HandleCurrentGridInput(MyStringId context)
{
if (MyControllerHelper.IsControl(context, MyControlsSpace.SYMMETRY_SWITCH, MyControlStateType.NEW_PRESSED) && !(MySession.Static.ControlledEntity is MyShipController))
{
if (BlockCreationIsActivated)
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
switch (m_symmetrySettingMode)
{
case MySymmetrySettingModeEnum.NoPlane:
m_symmetrySettingMode = MySymmetrySettingModeEnum.XPlane;
UpdateSymmetryNotification(MyCommonTexts.SettingSymmetryX);
break;
case MySymmetrySettingModeEnum.XPlane:
m_symmetrySettingMode = MySymmetrySettingModeEnum.XPlaneOdd;
UpdateSymmetryNotification(MyCommonTexts.SettingSymmetryXOffset);
break;
case MySymmetrySettingModeEnum.XPlaneOdd:
m_symmetrySettingMode = MySymmetrySettingModeEnum.YPlane;
UpdateSymmetryNotification(MyCommonTexts.SettingSymmetryY);
break;
case MySymmetrySettingModeEnum.YPlane:
m_symmetrySettingMode = MySymmetrySettingModeEnum.YPlaneOdd;
UpdateSymmetryNotification(MyCommonTexts.SettingSymmetryYOffset);
break;
case MySymmetrySettingModeEnum.YPlaneOdd:
m_symmetrySettingMode = MySymmetrySettingModeEnum.ZPlane;
UpdateSymmetryNotification(MyCommonTexts.SettingSymmetryZ);
break;
case MySymmetrySettingModeEnum.ZPlane:
m_symmetrySettingMode = MySymmetrySettingModeEnum.ZPlaneOdd;
UpdateSymmetryNotification(MyCommonTexts.SettingSymmetryZOffset);
break;
case MySymmetrySettingModeEnum.ZPlaneOdd:
m_symmetrySettingMode = MySymmetrySettingModeEnum.NoPlane;
RemoveSymmetryNotification();
break;
}
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.USE_SYMMETRY, MyControlStateType.NEW_PRESSED) && !(MySession.Static.ControlledEntity is MyShipController))
{
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
if (m_symmetrySettingMode != MySymmetrySettingModeEnum.NoPlane)
{
UseSymmetry = false;
m_symmetrySettingMode = MySymmetrySettingModeEnum.NoPlane;
RemoveSymmetryNotification();
return true;
}
UseSymmetry = !UseSymmetry;
}
if (CurrentBlockDefinition == null || !BlockCreationIsActivated)
{
m_symmetrySettingMode = MySymmetrySettingModeEnum.NoPlane;
RemoveSymmetryNotification();
}
if (IsInSymmetrySettingMode && !(MySession.Static.ControlledEntity is MyShipController))
{
if (MyControllerHelper.IsControl(context, MyControlsSpace.PRIMARY_TOOL_ACTION, MyControlStateType.NEW_PRESSED))
{
if (m_gizmo.SpaceDefault.m_removeBlock != null)
{
Vector3I center = (m_gizmo.SpaceDefault.m_removeBlock.Min + m_gizmo.SpaceDefault.m_removeBlock.Max) / 2;
MyGuiAudio.PlaySound(MyGuiSounds.HudClick);
switch (m_symmetrySettingMode)
{
case MySymmetrySettingModeEnum.NoPlane:
System.Diagnostics.Debug.Assert(false, "Cannot get here");
break;
case MySymmetrySettingModeEnum.XPlane:
CurrentGrid.XSymmetryPlane = center;
CurrentGrid.XSymmetryOdd = false;
break;
case MySymmetrySettingModeEnum.XPlaneOdd:
CurrentGrid.XSymmetryPlane = center;
CurrentGrid.XSymmetryOdd = true;
break;
case MySymmetrySettingModeEnum.YPlane:
CurrentGrid.YSymmetryPlane = center;
CurrentGrid.YSymmetryOdd = false;
break;
case MySymmetrySettingModeEnum.YPlaneOdd:
CurrentGrid.YSymmetryPlane = center;
CurrentGrid.YSymmetryOdd = true;
break;
case MySymmetrySettingModeEnum.ZPlane:
CurrentGrid.ZSymmetryPlane = center;
CurrentGrid.ZSymmetryOdd = false;
break;
case MySymmetrySettingModeEnum.ZPlaneOdd:
CurrentGrid.ZSymmetryPlane = center;
CurrentGrid.ZSymmetryOdd = true;
break;
}
}
return true;
}
if (MyControllerHelper.IsControl(context, MyControlsSpace.SECONDARY_TOOL_ACTION, MyControlStateType.NEW_PRESSED))
{
MyGuiAudio.PlaySound(MyGuiSounds.HudDeleteBlock);
switch (m_symmetrySettingMode)
{
case MySymmetrySettingModeEnum.NoPlane:
System.Diagnostics.Debug.Assert(false, "Cannot get here");
break;
case MySymmetrySettingModeEnum.XPlane:
case MySymmetrySettingModeEnum.XPlaneOdd:
CurrentGrid.XSymmetryPlane = null;
CurrentGrid.XSymmetryOdd = false;
break;
case MySymmetrySettingModeEnum.YPlane:
case MySymmetrySettingModeEnum.YPlaneOdd:
CurrentGrid.YSymmetryPlane = null;
CurrentGrid.YSymmetryOdd = false;
break;
case MySymmetrySettingModeEnum.ZPlane:
case MySymmetrySettingModeEnum.ZPlaneOdd:
CurrentGrid.ZSymmetryPlane = null;
CurrentGrid.ZSymmetryOdd = false;
break;
}
return false;
}
}
if (MyInput.Static.IsNewKeyPressed(MyKeys.Escape))
{
if (m_symmetrySettingMode != MySymmetrySettingModeEnum.NoPlane)
{
m_symmetrySettingMode = MySymmetrySettingModeEnum.NoPlane;
RemoveSymmetryNotification();
return true;
}
if (CancelBuilding())
return true;
}
if (MyInput.Static.IsNewLeftMousePressed() || MyControllerHelper.IsControl(context, MyControlsSpace.PRIMARY_BUILD_ACTION))
{
if (!PlacingSmallGridOnLargeStatic && (MyInput.Static.IsAnyCtrlKeyPressed() || BuildingMode != BuildingModeEnum.SingleBlock))
{
StartBuilding();
}
else
{
Add();
}
}
if (MyInput.Static.IsNewRightMousePressed() || MyControllerHelper.IsControl(context, MyControlsSpace.SECONDARY_BUILD_ACTION))
{
if (MyInput.Static.IsAnyCtrlKeyPressed() || BuildingMode != BuildingModeEnum.SingleBlock)
{
StartRemoving();
}
else
{
if (MyFakes.ENABLE_COMPOUND_BLOCKS && !CompoundEnabled)
{
foreach (var gizmoSpace in m_gizmo.Spaces)
{
if (!gizmoSpace.Enabled)
continue;
gizmoSpace.m_blockIdInCompound = null;
}
}
PrepareBlocksToRemove();
Remove();
}
}
if (MyInput.Static.IsLeftMousePressed() ||
MyInput.Static.IsRightMousePressed() ||
MyControllerHelper.IsControl(context, MyControlsSpace.PRIMARY_BUILD_ACTION, MyControlStateType.PRESSED))
{
ContinueBuilding(MyInput.Static.IsAnyShiftKeyPressed() || BuildingMode == BuildingModeEnum.Plane);
}
if (MyInput.Static.IsNewLeftMouseReleased() ||
MyInput.Static.IsNewRightMouseReleased() ||
MyControllerHelper.IsControl(context, MyControlsSpace.PRIMARY_BUILD_ACTION, MyControlStateType.NEW_RELEASED))
{
StopBuilding();
}
return false;
}
