public static Vector3I Transform(this Vector3I size, SerializableBlockOrientation orientation)
{
var matrix = Matrix.CreateFromDir(Base6Directions.GetVector(orientation.Forward), Base6Directions.GetVector(orientation.Up));
var rotation = Quaternion.CreateFromRotationMatrix(matrix);
return(Vector3I.Transform(size, rotation));
}
public void SetRotation(Direction newDirection)
{
RotationDirection = newDirection;
if (RotationDirection == Direction.Forward || RotationDirection == Direction.None)
{
BlockOrientation = new MyBlockOrientation(Base6Directions.Direction.Forward, Base6Directions.Direction.Up);
}
if (RotationDirection == Direction.Left)
{
BlockOrientation = new MyBlockOrientation(Base6Directions.Direction.Left, Base6Directions.Direction.Up);
}
if (RotationDirection == Direction.Backward)
{
BlockOrientation = new MyBlockOrientation(Base6Directions.Direction.Forward, Base6Directions.Direction.Up);
}
if (RotationDirection == Direction.Right)
{
BlockOrientation = new MyBlockOrientation(Base6Directions.Direction.Forward, Base6Directions.Direction.Up);
}
if (RotationDirection == Direction.Up)
{
BlockOrientation = new MyBlockOrientation(Base6Directions.Direction.Up, Base6Directions.Direction.Backward);
}
if (RotationDirection == Direction.Forward)
{
BlockOrientation = new MyBlockOrientation(Base6Directions.Direction.Down, Base6Directions.Direction.Forward);
}
}
public StoredSettings()
{
Mode = BehaviorMode.Init;
CurrentTargetEntityId = 0;
StoredCustomBooleans = new Dictionary <string, bool>();
StoredCustomCounters = new Dictionary <string, int>();
Triggers = new List <TriggerProfile>();
DamageTriggers = new List <TriggerProfile>();
CommandTriggers = new List <TriggerProfile>();
CompromisedTriggers = new List <TriggerProfile>();
TotalDamageAccumulated = 0;
LastDamageTakenTime = MyAPIGateway.Session.GameDateTime;
CustomTargetProfile = "";
RotationDirection = Direction.Forward;
BlockOrientation = new SerializableBlockOrientation(Base6Directions.Direction.Forward, Base6Directions.Direction.Up);
DespawnCoords = Vector3D.Zero;
StoredCoords = Vector3D.Zero;
StartCoords = Vector3D.Zero;
LastDamagerEntity = 0;
AutoPilotFlags = NewAutoPilotMode.None;
APDataMode = AutoPilotDataMode.Primary;
PrimaryAutopilotId = "";
SecondaryAutopilotId = "";
TertiaryAutopilotId = "";
IgnoreTriggers = false;
}
public StoredSettings(StoredSettings oldSettings, bool preserveSettings, bool preserveTriggers, bool preserveTargetProfile) : base()
{
//Stuff From Old Settings
if (!preserveSettings)
{
return;
}
//this.Mode = oldSettings.Mode;
this.StoredCustomBooleans = oldSettings.StoredCustomBooleans;
this.StoredCustomCounters = oldSettings.StoredCustomCounters;
this.TotalDamageAccumulated = oldSettings.TotalDamageAccumulated;
this.LastDamageTakenTime = oldSettings.LastDamageTakenTime;
this.RotationDirection = oldSettings.RotationDirection;
this.BlockOrientation = oldSettings.BlockOrientation;
this.DespawnCoords = oldSettings.DespawnCoords;
this.StoredCoords = oldSettings.StoredCoords;
this.StartCoords = oldSettings.StartCoords;
this.LastDamagerEntity = oldSettings.LastDamagerEntity;
this.AutoPilotFlags = oldSettings.AutoPilotFlags;
this.APDataMode = oldSettings.APDataMode;
//Triggers
if (preserveTriggers)
{
this.Triggers = oldSettings.Triggers;
this.DamageTriggers = oldSettings.DamageTriggers;
this.CommandTriggers = oldSettings.CommandTriggers;
this.CompromisedTriggers = oldSettings.CompromisedTriggers;
}
else
{
IgnoreTriggers = true;
}
//TargetProfile
if (preserveTargetProfile)
{
this.CustomTargetProfile = oldSettings.CustomTargetProfile;
this.CurrentTargetEntityId = oldSettings.CurrentTargetEntityId;
}
this.SetRotation(RotationDirection);
}
public StoredSettings()
{
Mode = BehaviorMode.Init;
CurrentTargetEntityId = 0;
StoredCustomBooleans = new Dictionary <string, bool>();
StoredCustomCounters = new Dictionary <string, int>();
Triggers = new List <TriggerProfile>();
DamageTriggers = new List <TriggerProfile>();
CommandTriggers = new List <TriggerProfile>();
CompromisedTriggers = new List <TriggerProfile>();
TotalDamageAccumulated = 0;
LastDamageTakenTime = MyAPIGateway.Session.GameDateTime;
CustomTargetProfile = "";
RotationDirection = Direction.Forward;
BlockOrientation = new SerializableBlockOrientation(Base6Directions.Direction.Forward, Base6Directions.Direction.Up);
}
public void RotateComponent()
{
var d1 = SpaceEngineersApi.GetCubeDefinition(new MyObjectBuilderType(typeof(MyObjectBuilder_Thrust)), MyCubeSize.Large, "LargeBlockLargeThrust");
Assert.AreEqual("DisplayName_Block_LargeThrust", d1.DisplayNameEnum.Value.String, "Must match");
Assert.AreEqual(MyCubeSize.Large, d1.CubeSize, "Must match");
Assert.AreEqual(3, d1.Size.X, "Must match");
Assert.AreEqual(2, d1.Size.Y, "Must match");
Assert.AreEqual(4, d1.Size.Z, "Must match");
//======//
var orient = new SerializableBlockOrientation(Base6Directions.Direction.Forward, Base6Directions.Direction.Up);
var f = Base6Directions.GetVector(orient.Forward);
var u = Base6Directions.GetVector(orient.Up);
var m = Matrix.CreateFromDir(f, u);
var q = Quaternion.CreateFromRotationMatrix(m);
var nf = Base6Directions.GetForward(q);
var nu = Base6Directions.GetUp(q);
// Test that Space Engineers orientation methods are working as expected. Forward is still Forward, Up is still Up.
Assert.AreEqual(nf, orient.Forward, "Initial Orientation Forward must match.");
Assert.AreEqual(nu, orient.Up, "Initial Orientation Forward must match.");
//======//
var v = d1.Size;
var fV1 = Vector3.Transform(v, m);
// Orientation of Forward/Up should provide the exact same dimentions as the original Component above.
Assert.AreEqual(3, fV1.X, "Must match");
Assert.AreEqual(2, fV1.Y, "Must match");
Assert.AreEqual(4, fV1.Z, "Must match");
//======//
var newOrient = new SerializableBlockOrientation(Base6Directions.Direction.Down, Base6Directions.Direction.Right);
var newM = Matrix.CreateFromDir(Base6Directions.GetVector(newOrient.Forward), Base6Directions.GetVector(newOrient.Up));
var fV2 = Vector3.Transform(v, newM);
// The reoriented Component size should now have changed.
Assert.AreEqual(2, fV2.X, "Must match");
Assert.AreEqual(4, fV2.Y, "Must match");
Assert.AreEqual(3, fV2.Z, "Must match");
//======//
// Reducing complexity of code with Extension.
var direction = new SerializableBlockOrientation(Base6Directions.Direction.Down, Base6Directions.Direction.Right);
var fV3 = d1.Size.Transform(direction);
// The reoriented Component size should now have changed.
Assert.AreEqual(2, fV3.X, "Must match");
Assert.AreEqual(4, fV3.Y, "Must match");
Assert.AreEqual(3, fV3.Z, "Must match");
}
public static Vector3D Transform(this Vector3D vector, SerializableBlockOrientation orientation)
{
var matrix = MatrixD.CreateFromDir(Base6Directions.GetVector(orientation.Forward), Base6Directions.GetVector(orientation.Up));
return(Vector3D.Transform(vector, matrix));
}
public static Quaternion ToQuaternion(this SerializableBlockOrientation blockOrientation)
{
var matrix = Matrix.CreateFromDir(Base6Directions.GetVector(blockOrientation.Forward), Base6Directions.GetVector(blockOrientation.Up));
return(Quaternion.CreateFromRotationMatrix(matrix));
}
private static void MirrorCubeOrientation(MyCubeBlockDefinition definition, SerializableBlockOrientation orientation, MirrorDirection xMirror, MirrorDirection yMirror, MirrorDirection zMirror, out MyCubeBlockDefinition mirrorDefinition, out SerializableBlockOrientation mirrorOrientation)
{
if (string.IsNullOrEmpty(definition.MirroringBlock))
{
mirrorDefinition = definition;
}
else
{
var definitionId = new MyDefinitionId(definition.Id.TypeId, definition.MirroringBlock);
mirrorDefinition = MyDefinitionManager.Static.GetCubeBlockDefinition(definitionId);
}
Matrix sourceMatrix = Matrix.CreateFromDir(Base6Directions.GetVector(orientation.Forward), Base6Directions.GetVector(orientation.Up));
Matrix targetMatrix;
Vector3 mirrorNormal = Vector3.Zero;
if (xMirror != MirrorDirection.None)
{
mirrorNormal = Vector3.Right;
}
else if (yMirror != MirrorDirection.None)
{
mirrorNormal = Vector3.Up;
}
else if (zMirror != MirrorDirection.None)
{
mirrorNormal = Vector3.Forward;
}
MySymmetryAxisEnum blockMirrorAxis = MySymmetryAxisEnum.None;
if (MyUtils.IsZero(Math.Abs(Vector3.Dot(sourceMatrix.Right, mirrorNormal)) - 1.0f))
{
blockMirrorAxis = MySymmetryAxisEnum.X;
}
else if (MyUtils.IsZero(Math.Abs(Vector3.Dot(sourceMatrix.Up, mirrorNormal)) - 1.0f))
{
blockMirrorAxis = MySymmetryAxisEnum.Y;
}
else if (MyUtils.IsZero(Math.Abs(Vector3.Dot(sourceMatrix.Forward, mirrorNormal)) - 1.0f))
{
blockMirrorAxis = MySymmetryAxisEnum.Z;
}
MySymmetryAxisEnum blockMirrorOption = MySymmetryAxisEnum.None;
switch (blockMirrorAxis)
{
case MySymmetryAxisEnum.X: blockMirrorOption = definition.SymmetryX; break;
case MySymmetryAxisEnum.Y: blockMirrorOption = definition.SymmetryY; break;
case MySymmetryAxisEnum.Z: blockMirrorOption = definition.SymmetryZ; break;
default:
throw new Exception("Invalid mirror option");
}
switch (blockMirrorOption)
{
case MySymmetryAxisEnum.X:
targetMatrix = Matrix.CreateRotationX(MathHelper.Pi) * sourceMatrix;
break;
case MySymmetryAxisEnum.Y:
case MySymmetryAxisEnum.YThenOffsetX:
targetMatrix = Matrix.CreateRotationY(MathHelper.Pi) * sourceMatrix;
break;
case MySymmetryAxisEnum.Z:
case MySymmetryAxisEnum.ZThenOffsetX:
targetMatrix = Matrix.CreateRotationZ(MathHelper.Pi) * sourceMatrix;
break;
case MySymmetryAxisEnum.HalfX:
targetMatrix = Matrix.CreateRotationX(-MathHelper.PiOver2) * sourceMatrix;
break;
case MySymmetryAxisEnum.HalfY:
targetMatrix = Matrix.CreateRotationY(-MathHelper.PiOver2) * sourceMatrix;
break;
case MySymmetryAxisEnum.HalfZ:
targetMatrix = Matrix.CreateRotationZ(-MathHelper.PiOver2) * sourceMatrix;
break;
case MySymmetryAxisEnum.XHalfY:
targetMatrix = Matrix.CreateRotationX(MathHelper.Pi) * sourceMatrix;
targetMatrix = Matrix.CreateRotationY(MathHelper.PiOver2) * targetMatrix;
break;
case MySymmetryAxisEnum.YHalfY:
targetMatrix = Matrix.CreateRotationY(MathHelper.Pi) * sourceMatrix;
targetMatrix = Matrix.CreateRotationY(MathHelper.PiOver2) * targetMatrix;
break;
case MySymmetryAxisEnum.ZHalfY:
targetMatrix = Matrix.CreateRotationZ(MathHelper.Pi) * sourceMatrix;
targetMatrix = Matrix.CreateRotationY(MathHelper.PiOver2) * targetMatrix;
break;
case MySymmetryAxisEnum.XHalfX:
targetMatrix = Matrix.CreateRotationX(MathHelper.Pi) * sourceMatrix;
targetMatrix = Matrix.CreateRotationX(-MathHelper.PiOver2) * targetMatrix;
break;
case MySymmetryAxisEnum.YHalfX:
targetMatrix = Matrix.CreateRotationY(MathHelper.Pi) * sourceMatrix;
targetMatrix = Matrix.CreateRotationX(-MathHelper.PiOver2) * targetMatrix;
break;
case MySymmetryAxisEnum.ZHalfX:
targetMatrix = Matrix.CreateRotationZ(MathHelper.Pi) * sourceMatrix;
targetMatrix = Matrix.CreateRotationX(-MathHelper.PiOver2) * targetMatrix;
break;
case MySymmetryAxisEnum.XHalfZ:
targetMatrix = Matrix.CreateRotationX(MathHelper.Pi) * sourceMatrix;
targetMatrix = Matrix.CreateRotationZ(-MathHelper.PiOver2) * targetMatrix;
break;
case MySymmetryAxisEnum.YHalfZ:
targetMatrix = Matrix.CreateRotationY(MathHelper.Pi) * sourceMatrix;
targetMatrix = Matrix.CreateRotationZ(-MathHelper.PiOver2) * targetMatrix;
break;
case MySymmetryAxisEnum.ZHalfZ:
targetMatrix = Matrix.CreateRotationZ(MathHelper.Pi) * sourceMatrix;
targetMatrix = Matrix.CreateRotationZ(-MathHelper.PiOver2) * targetMatrix;
break;
case MySymmetryAxisEnum.XMinusHalfZ:
targetMatrix = Matrix.CreateRotationX(MathHelper.Pi) * sourceMatrix;
targetMatrix = Matrix.CreateRotationZ(MathHelper.PiOver2) * targetMatrix;
break;
case MySymmetryAxisEnum.YMinusHalfZ:
targetMatrix = Matrix.CreateRotationY(MathHelper.Pi) * sourceMatrix;
targetMatrix = Matrix.CreateRotationZ(MathHelper.PiOver2) * targetMatrix;
break;
case MySymmetryAxisEnum.ZMinusHalfZ:
targetMatrix = Matrix.CreateRotationZ(MathHelper.Pi) * sourceMatrix;
targetMatrix = Matrix.CreateRotationZ(MathHelper.PiOver2) * targetMatrix;
break;
case MySymmetryAxisEnum.XMinusHalfX:
targetMatrix = Matrix.CreateRotationX(MathHelper.Pi) * sourceMatrix;
targetMatrix = Matrix.CreateRotationX(MathHelper.PiOver2) * targetMatrix;
break;
case MySymmetryAxisEnum.YMinusHalfX:
targetMatrix = Matrix.CreateRotationY(MathHelper.Pi) * sourceMatrix;
targetMatrix = Matrix.CreateRotationX(MathHelper.PiOver2) * targetMatrix;
break;
case MySymmetryAxisEnum.ZMinusHalfX:
targetMatrix = Matrix.CreateRotationZ(MathHelper.Pi) * sourceMatrix;
targetMatrix = Matrix.CreateRotationX(MathHelper.PiOver2) * targetMatrix;
break;
case MySymmetryAxisEnum.MinusHalfX:
targetMatrix = Matrix.CreateRotationX(MathHelper.PiOver2) * sourceMatrix;
break;
case MySymmetryAxisEnum.MinusHalfY:
targetMatrix = Matrix.CreateRotationY(MathHelper.PiOver2) * sourceMatrix;
break;
case MySymmetryAxisEnum.MinusHalfZ:
targetMatrix = Matrix.CreateRotationZ(MathHelper.PiOver2) * sourceMatrix;
break;
default: // or MySymmetryAxisEnum.None
targetMatrix = sourceMatrix;
break;
}
// Note, the Base6Directions methods call GetDirection(), which rounds off the vector, which should prevent floating point errors creeping in.
mirrorOrientation = new SerializableBlockOrientation(Base6Directions.GetForward(ref targetMatrix), Base6Directions.GetUp(ref targetMatrix));
}
