public Bone(string name, int index, Bone parent, RotationOrder rotationOrder, bool inheritsScale, ChannelTriplet centerPoint, ChannelTriplet endPoint, ChannelTriplet orientation, ChannelTriplet rotation, ChannelTriplet translation, ChannelTriplet scale, Channel generalScale)
{
if (parent == null)
{
if (index != 0)
{
throw new InvalidOperationException("root bone must be first");
}
}
else if (parent.Index > index)
{
throw new ArgumentException("parent bones must have lower index");
}
Name = name;
Index = index;
Parent = parent;
RotationOrder = rotationOrder;
InheritsScale = inheritsScale;
CenterPoint = centerPoint;
EndPoint = endPoint;
Orientation = orientation;
Rotation = rotation;
Translation = translation;
Scale = scale;
GeneralScale = generalScale;
rotation.ExtractMinMax(out Vector3 minDegrees, out Vector3 maxDegrees);
Vector3 minRadians = MathExtensions.DegreesToRadians(minDegrees);
Vector3 maxRadians = MathExtensions.DegreesToRadians(maxDegrees);
RotationConstraint = TwistSwingConstraint.MakeFromRadians(rotationOrder.TwistAxis, minRadians, maxRadians);
}
internal static Vector3 GetClosestEuler(Quaternion q, Vector3 eulerHint, RotationOrder rotationOrder)
{
Vector3 result;
AnimationUtility.INTERNAL_CALL_GetClosestEuler(ref q, ref eulerHint, rotationOrder, out result);
return(result);
}
internal Vector3 GetLocalEulerAngles(RotationOrder order)
{
Vector3 result;
this.GetLocalEulerAngles_Injected(order, out result);
return(result);
}
public void OnEnable(SerializedProperty m_Rotation, GUIContent label)
{
this.m_Rotation = m_Rotation;
this.targets = m_Rotation.serializedObject.targetObjects;
this.m_OldRotationOrder = (this.targets[0] as Transform).rotationOrder;
this.rotationContent = label;
}
/// <summary>
///
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="z"></param>
/// <param name="order"></param>
public Euler(float x, float y, float z, RotationOrder order = RotationOrder.XYZ)
{
this.X = x;
this.Y = y;
this.Z = z;
this.Order = order;
}
public void OnEnable(SerializedProperty m_Rotation, GUIContent label)
{
this.m_Rotation = m_Rotation;
this.targets = m_Rotation.serializedObject.targetObjects;
this.m_OldRotationOrder = (this.targets[0] as Transform).rotationOrder;
this.rotationContent = label;
}
internal Vector3 GetLocalEulerAngles(RotationOrder order)
{
Vector3 vector;
INTERNAL_CALL_GetLocalEulerAngles(this, order, out vector);
return(vector);
}
public override string ToString()
{
StringBuilder builder = new StringBuilder();
builder.Append(Scale.X);
builder.Append(", ");
builder.Append(Scale.Y);
builder.Append(", ");
builder.Append(Scale.Z);
builder.Append(";");
builder.Append(Rotation.X);
builder.Append(", ");
builder.Append(Rotation.Y);
builder.Append(", ");
builder.Append(Rotation.Z);
builder.Append(";");
builder.Append(Position.X);
builder.Append(", ");
builder.Append(Position.Y);
builder.Append(", ");
builder.Append(Position.Z);
builder.Append(";");
builder.Append(RotationOrder.ToString());
return(builder.ToString());
}
public static RigidTransform Euler(float3 xyz, RotationOrder order = RotationOrder.ZXY)
{
switch (order)
{
case RotationOrder.XYZ:
return(EulerXYZ(xyz));
case RotationOrder.XZY:
return(EulerXZY(xyz));
case RotationOrder.YXZ:
return(EulerYXZ(xyz));
case RotationOrder.YZX:
return(EulerYZX(xyz));
case RotationOrder.ZXY:
return(EulerZXY(xyz));
case RotationOrder.ZYX:
return(EulerZYX(xyz));
default:
return(RigidTransform.identity);
}
}
private Matrix4 createTransformFor(FBXElem globalSettings, out RotationOrder order)
{
order = RotationOrder.OrderXYZ;
var frontAxis = (int)globalSettings.Children.GetProperty("FrontAxis").Properties[4].Value;
var frontAxisSign = (int)globalSettings.Children.GetProperty("FrontAxisSign").Properties[4].Value;
var upAxis = (int)globalSettings.Children.GetProperty("UpAxis").Properties[4].Value;
var upAxisSign = (int)globalSettings.Children.GetProperty("UpAxisSign").Properties[4].Value;
var coordAxis = (int)globalSettings.Children.GetProperty("CoordAxis").Properties[4].Value;
var coordAxisSign = (int)globalSettings.Children.GetProperty("CoordAxisSign").Properties[4].Value;
var front = (frontAxis * 2) + Math.Max(frontAxisSign, 0);
var up = (upAxis * 2) + Math.Max(upAxisSign, 0) << 3;
var coord = (coordAxis * 2) + Math.Max(coordAxisSign, 0) << 6;
var coords = (CoordinateSystem)(front + up + coord);
switch (coords)
{
// Blender 2.71 tells us that -Y is forward but the UI suggest +Y is forward.
case CoordinateSystem.nYpZpX:
order = RotationOrder.OrderXYZ;
return(Matrix4.CreateRotationX(MathHelper.DegreesToRadians(-90)));
case CoordinateSystem.pZpYpX:
order = RotationOrder.OrderXYZ;
return(Matrix4.Identity);
default:
throw new NotImplementedException(string.Format("Unsupported World Transformation Matrix: {0}", coords));
}
}
public static quaternion Euler(float3 xyz, RotationOrder order = RotationOrder.ZXY)
{
switch (order)
{
case RotationOrder.XYZ:
return(EulerXYZ(xyz));
case RotationOrder.XZY:
return(EulerXZY(xyz));
case RotationOrder.YXZ:
return(EulerYXZ(xyz));
case RotationOrder.YZX:
return(EulerYZX(xyz));
case RotationOrder.ZXY:
return(EulerZXY(xyz));
case RotationOrder.ZYX:
return(EulerZYX(xyz));
default:
return(quaternion.identity);
}
}
internal Vector3 GetLocalEulerAngles(RotationOrder order)
{
Vector3 result;
Transform.INTERNAL_CALL_GetLocalEulerAngles(this, order, out result);
return(result);
}
public Vector3 ToEuler(RotationOrder order)
{
Vector3 r = Vector3.Zero;
float r11, r12, r21, r31, r32;
r11 = r12 = r21 = r31 = r32 = 0;
switch (order)
{
case RotationOrder.OrderXYZ:
r11 = -2.0f * (X * Y - W * Z); // was r31
r21 = 2.0f * (X * Z + W * Y);
r31 = -2.0f * (Y * Z - W * X); // was r11
r12 = W * W + X * X - Y * Y - Z * Z; // was r32
r32 = W * W - X * X - Y * Y + Z * Z; // was r12
break;
case RotationOrder.OrderYZX:
r11 = -2.0f * (X * Z - W * Y);
r12 = W * W + X * X - Y * Y - Z * Z;
r21 = 2.0f * (X * Y + W * Z);
r31 = -2.0f * (Y * Z - W * X);
r32 = W * W - X * X + Y * Y - Z * Z;
break;
}
r.X = (float)Maths.RadiansToDegrees(Math.Atan2(r31, r32));
r.Y = (float)Maths.RadiansToDegrees(Math.Asin(r21));
r.Z = (float)Maths.RadiansToDegrees(Math.Atan2(r11, r12));
return(r);
}
/// <summary>
/// 指定した順序で3軸を回転させたクォータニオンを返します
/// </summary>
/// <param name="euler"></param>
/// <param name="order"></param>
/// <returns></returns>
static public Quaternion EulerToQuaternion(Vector3 euler, RotationOrder order)
{
Quaternion qX = Quaternion.AngleAxis(euler.x, Vector3.right);
Quaternion qY = Quaternion.AngleAxis(euler.y, Vector3.up);
Quaternion qZ = Quaternion.AngleAxis(euler.z, Vector3.forward);
// 「*」演算子は (後の回転) * (先の回転) となる
switch (order)
{
case RotationOrder.ZYX:
return(qX * qY * qZ);
case RotationOrder.YZX:
return(qX * qZ * qY);
case RotationOrder.ZXY: // Unity標準はこれ
return(qY * qX * qZ);
case RotationOrder.XZY:
return(qY * qZ * qX);
case RotationOrder.YXZ:
return(qZ * qX * qY);
case RotationOrder.XYZ:
return(qZ * qY * qX);
}
Debug.LogError("Wrong order : " + order);
return(Quaternion.identity);
}
public void RotationField(bool disabled)
{
Transform target1 = this.targets[0] as Transform;
Vector3 localEulerAngles1 = target1.GetLocalEulerAngles(target1.rotationOrder);
if ((double) this.m_OldEulerAngles.x != (double) localEulerAngles1.x || (double) this.m_OldEulerAngles.y != (double) localEulerAngles1.y || ((double) this.m_OldEulerAngles.z != (double) localEulerAngles1.z || this.m_OldRotationOrder != target1.rotationOrder))
{
this.m_EulerAngles = target1.GetLocalEulerAngles(target1.rotationOrder);
this.m_OldRotationOrder = target1.rotationOrder;
}
bool flag1 = false;
bool flag2 = false;
for (int index = 1; index < this.targets.Length; ++index)
{
Transform target2 = this.targets[index] as Transform;
Vector3 localEulerAngles2 = target2.GetLocalEulerAngles(target2.rotationOrder);
flag1 = ((flag1 ? 1 : 0) | ((double) localEulerAngles2.x != (double) localEulerAngles1.x || (double) localEulerAngles2.y != (double) localEulerAngles1.y ? 1 : ((double) localEulerAngles2.z != (double) localEulerAngles1.z ? 1 : 0))) != 0;
flag2 |= target2.rotationOrder != target1.rotationOrder;
}
Rect controlRect = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight * (!EditorGUIUtility.wideMode ? 2f : 1f), new GUILayoutOption[0]);
GUIContent label = EditorGUI.BeginProperty(controlRect, this.rotationContent, this.m_Rotation);
EditorGUI.showMixedValue = flag1;
EditorGUI.BeginChangeCheck();
int controlId = GUIUtility.GetControlID(TransformRotationGUI.s_FoldoutHash, EditorGUIUtility.native, controlRect);
string empty = string.Empty;
if (AnimationMode.InAnimationMode() && target1.rotationOrder != RotationOrder.OrderZXY)
{
string str1;
if (flag2)
{
str1 = "Mixed";
}
else
{
string str2 = target1.rotationOrder.ToString();
str1 = str2.Substring(str2.Length - 3);
}
label.text = label.text + " (" + str1 + ")";
}
Rect position = EditorGUI.MultiFieldPrefixLabel(controlRect, controlId, label, 3);
position.height = EditorGUIUtility.singleLineHeight;
EditorGUI.BeginDisabledGroup(disabled);
this.m_EulerAngles = EditorGUI.Vector3Field(position, GUIContent.none, this.m_EulerAngles);
EditorGUI.EndDisabledGroup();
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObjects(this.targets, "Inspector");
foreach (Transform target2 in this.targets)
{
target2.SetLocalEulerAngles(this.m_EulerAngles, target2.rotationOrder);
if ((UnityEngine.Object) target2.parent != (UnityEngine.Object) null)
target2.SendTransformChangedScale();
}
this.m_Rotation.serializedObject.SetIsDifferentCacheDirty();
}
EditorGUI.showMixedValue = false;
if (flag2)
EditorGUILayout.HelpBox("Transforms have different rotation orders, keyframes saved will have the same value but not the same local rotation", MessageType.Warning);
EditorGUI.EndProperty();
}
public RigidBone(Bone source, RigidBone parent)
{
Source = source;
Index = source.Index;
Parent = parent;
RotationOrder = source.RotationOrder;
Constraint = source.RotationConstraint;
}
public Transformation(Transformation other)
{
position = other.position;
rotation = other.rotation;
scale = other.scale;
transformOrder = other.transformOrder;
rotationOrder = other.rotationOrder;
}
/// <summary>
/// 指定クォータニオンは指定した順序で各軸周りに回転が行われたものであるとして、そのオイラー角を返します
/// </summary>
/// <param name="q"></param>
/// <param name="order"></param>
/// <seealso href="https://forum.unity.com/threads/rotation-order.13469/">参考</seealso>
/// <returns></returns>
static public Vector3 QuaternionToEuler(Quaternion q, RotationOrder order)
{
float[] ret;
switch (order)
{
case RotationOrder.XYZ:
ret = CalcAngles(2f * (q.x * q.y + q.w * q.z),
q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z,
-2f * (q.x * q.z - q.w * q.y),
2f * (q.y * q.z + q.w * q.x),
q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z);
return(new Vector3(ret[0], ret[1], ret[2]));
case RotationOrder.YXZ:
ret = CalcAngles(-2f * (q.x * q.y - q.w * q.z),
q.w * q.w - q.x * q.x + q.y * q.y - q.z * q.z,
2f * (q.y * q.z + q.w * q.x),
-2f * (q.x * q.z - q.w * q.y),
q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z);
return(new Vector3(ret[1], ret[0], ret[2]));
case RotationOrder.ZXY:
ret = CalcAngles(2f * (q.x * q.z + q.w * q.y),
q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z,
-2f * (q.y * q.z - q.w * q.x),
2f * (q.x * q.y + q.w * q.z),
q.w * q.w - q.x * q.x + q.y * q.y - q.z * q.z);
return(new Vector3(ret[1], ret[2], ret[0]));
case RotationOrder.XZY:
ret = CalcAngles(-2f * (q.x * q.z - q.w * q.y),
q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z,
2f * (q.x * q.y + q.w * q.z),
-2f * (q.y * q.z - q.w * q.x),
q.w * q.w - q.x * q.x + q.y * q.y - q.z * q.z);
return(new Vector3(ret[0], ret[2], ret[1]));
case RotationOrder.ZYX:
ret = CalcAngles(-2f * (q.y * q.z - q.w * q.x),
q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z,
2f * (q.x * q.z + q.w * q.y),
-2f * (q.x * q.y - q.w * q.z),
q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z);
return(new Vector3(ret[2], ret[1], ret[0]));
case RotationOrder.YZX:
ret = CalcAngles(2f * (q.y * q.z + q.w * q.x),
q.w * q.w - q.x * q.x + q.y * q.y - q.z * q.z,
-2f * (q.x * q.y - q.w * q.z),
2f * (q.x * q.z + q.w * q.y),
q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z);
return(new Vector3(ret[2], ret[0], ret[1]));
}
Debug.LogError("Wrong order : " + order);
return(Vector3.zero);
}
/// <summary>
///
/// </summary>
public void Reorder(RotationOrder newOrder)
{
// WARNING: this discards revolution information -bhouston
var q = new Quaternion().SetFromEuler(this);
this.Order = newOrder;
this.SetFromQuaternion(q);
}
/// <summary>
/// Clone transformations.
/// </summary>
public Transformations(Transformations other)
{
Position = other.Position;
Rotation = other.Rotation;
Scale = other.Scale;
TransformOrder = other.TransformOrder;
RotationOrder = other.RotationOrder;
RotationType = other.RotationType;
}
public static Vector3 ToEuler(this Quaternion q, RotationOrder order)
{
Vector3 r = Vector3.Zero;
//Single test = q.X * q.Y + q.Z * q.W;
//if (test > 0.499f)
//{
// r.X = 0;
// r.Y = (Single)MathHelper.RadiansToDegrees(Math.Atan2(q.X, q.W));
// r.Z = 90;
//}
//else if (test < -0.499f)
//{
// r.X = 0;
// r.Y = -(Single)MathHelper.RadiansToDegrees(Math.Atan2(q.X, q.W));
// r.Z = -90;
//}
//else
//{
// r.X = (Single)MathHelper.RadiansToDegrees(Math.Atan2(2 * q.X * q.W - 2 * q.Y * q.Z, 1 - 2 * (q.X * q.X) - 2 * (q.Z * q.Z)));
// r.Y = (Single)MathHelper.RadiansToDegrees(Math.Atan2(2 * q.Y * q.W - 2 * q.X * q.Z, 1 - 2 * (q.Y * q.Y) - 2 * (q.Z * q.Z)));
// r.Z = (Single)MathHelper.RadiansToDegrees(Math.Asin(2 * q.X * q.Y + 2 * q.Z * q.W));
//}
float r11, r12, r21, r31, r32;
r11 = r12 = r21 = r31 = r32 = 0;
switch (order)
{
case RotationOrder.OrderXYZ:
r11 = -2.0f * (q.X * q.Y - q.W * q.Z); // was r31
r21 = 2.0f * (q.X * q.Z + q.W * q.Y);
r31 = -2.0f * (q.Y * q.Z - q.W * q.X); // was r11
r12 = q.W * q.W + q.X * q.X - q.Y * q.Y - q.Z * q.Z; // was r32
r32 = q.W * q.W - q.X * q.X - q.Y * q.Y + q.Z * q.Z; // was r12
break;
case RotationOrder.OrderYZX:
r11 = -2.0f * (q.X * q.Z - q.W * q.Y);
r12 = q.W * q.W + q.X * q.X - q.Y * q.Y - q.Z * q.Z;
r21 = 2.0f * (q.X * q.Y + q.W * q.Z);
r31 = -2.0f * (q.Y * q.Z - q.W * q.X);
r32 = q.W * q.W - q.X * q.X + q.Y * q.Y - q.Z * q.Z;
break;
}
r.X = (Single)MathHelper.RadiansToDegrees(Math.Atan2(r31, r32));
r.Y = (Single)MathHelper.RadiansToDegrees(Math.Asin(r21));
r.Z = (Single)MathHelper.RadiansToDegrees(Math.Atan2(r11, r12));
//if (r.X < -90) { r.X += 360; }
//if (r.Y < -90) { r.Y += 360; }
//if (r.Z < -90) { r.Z += 360; }
return(r);
}
/// <summary>
///
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <param name="c"></param>
/// <param name="o"></param>
/// <returns></returns>
public Euler set(float a, float b, float c, RotationOrder o)
{
this.X = a;
this.Y = b;
this.Z = c;
this.Order = o;
return(this);
}
private void TestFromTwistSwingAngles(RotationOrder order)
{
MathAssert.AreEqual(order.FromTwistSwingAngles(new Vector3(0, 0, 0)).AsQuaternion(order.TwistAxis), Quaternion.Identity, Acc);
MathAssert.AreEqual(order.FromTwistSwingAngles(new Vector3(+1, 0, 0)).AsQuaternion(order.TwistAxis), Quaternion.RotationAxis(Vector3.UnitX, +1), Acc);
MathAssert.AreEqual(order.FromTwistSwingAngles(new Vector3(-1, 0, 0)).AsQuaternion(order.TwistAxis), Quaternion.RotationAxis(Vector3.UnitX, -1), Acc);
MathAssert.AreEqual(order.FromTwistSwingAngles(new Vector3(0, +1, 0)).AsQuaternion(order.TwistAxis), Quaternion.RotationAxis(Vector3.UnitY, +1), Acc);
MathAssert.AreEqual(order.FromTwistSwingAngles(new Vector3(0, -1, 0)).AsQuaternion(order.TwistAxis), Quaternion.RotationAxis(Vector3.UnitY, -1), Acc);
MathAssert.AreEqual(order.FromTwistSwingAngles(new Vector3(0, 0, +1)).AsQuaternion(order.TwistAxis), Quaternion.RotationAxis(Vector3.UnitZ, +1), Acc);
MathAssert.AreEqual(order.FromTwistSwingAngles(new Vector3(0, 0, -1)).AsQuaternion(order.TwistAxis), Quaternion.RotationAxis(Vector3.UnitZ, -1), Acc);
}
private void TestToTwistSwingAngles(RotationOrder order)
{
MathAssert.AreEqual(new Vector3(0, 0, 0), order.ToTwistSwingAngles(TwistSwing.Decompose(order.TwistAxis, Quaternion.Identity)), Acc);
MathAssert.AreEqual(new Vector3(+1, 0, 0), order.ToTwistSwingAngles(TwistSwing.Decompose(order.TwistAxis, Quaternion.RotationAxis(Vector3.UnitX, +1))), Acc);
MathAssert.AreEqual(new Vector3(-1, 0, 0), order.ToTwistSwingAngles(TwistSwing.Decompose(order.TwistAxis, Quaternion.RotationAxis(Vector3.UnitX, -1))), Acc);
MathAssert.AreEqual(new Vector3(0, +1, 0), order.ToTwistSwingAngles(TwistSwing.Decompose(order.TwistAxis, Quaternion.RotationAxis(Vector3.UnitY, +1))), Acc);
MathAssert.AreEqual(new Vector3(0, -1, 0), order.ToTwistSwingAngles(TwistSwing.Decompose(order.TwistAxis, Quaternion.RotationAxis(Vector3.UnitY, -1))), Acc);
MathAssert.AreEqual(new Vector3(0, 0, +1), order.ToTwistSwingAngles(TwistSwing.Decompose(order.TwistAxis, Quaternion.RotationAxis(Vector3.UnitZ, +1))), Acc);
MathAssert.AreEqual(new Vector3(0, 0, -1), order.ToTwistSwingAngles(TwistSwing.Decompose(order.TwistAxis, Quaternion.RotationAxis(Vector3.UnitZ, -1))), Acc);
}
private void TestTwistSwingRoundTrip(RotationOrder order)
{
TestTwistSwingRoundTrip(order, Quaternion.RotationYawPitchRoll(+0.1f, +0.2f, +0.3f));
TestTwistSwingRoundTrip(order, Quaternion.RotationYawPitchRoll(-0.1f, +0.2f, +0.3f));
TestTwistSwingRoundTrip(order, Quaternion.RotationYawPitchRoll(+0.1f, -0.2f, +0.3f));
TestTwistSwingRoundTrip(order, Quaternion.RotationYawPitchRoll(-0.1f, -0.2f, +0.3f));
TestTwistSwingRoundTrip(order, Quaternion.RotationYawPitchRoll(+0.1f, +0.2f, -0.3f));
TestTwistSwingRoundTrip(order, Quaternion.RotationYawPitchRoll(-0.1f, +0.2f, -0.3f));
TestTwistSwingRoundTrip(order, Quaternion.RotationYawPitchRoll(+0.1f, -0.2f, -0.3f));
TestTwistSwingRoundTrip(order, Quaternion.RotationYawPitchRoll(-0.1f, -0.2f, -0.3f));
}
private void TestRotationOrder(RotationOrder order)
{
TestFromEulerAngles(order);
TestToSmallEulerAngles(order);
TestToLargeSecondaryEulerAngle(order);
TestToEulerAnglesAtPositiveSingularity(order);
TestToEulerAnglesAtNegativeSingularity(order);
TestFromTwistSwingAngles(order);
TestToTwistSwingAngles(order);
TestTwistSwingRoundTrip(order);
}
private void TestFromEulerAngles(RotationOrder order)
{
Vector3 angles = new Vector3(0.1f, 0.2f, 0.3f);
Quaternion expectedQ = MakeExpectedQ(order, angles);
Quaternion actualQ = order.FromEulerAngles(angles);
Assert.AreEqual(expectedQ.W, actualQ.W, Acc, "w differs");
Assert.AreEqual(expectedQ.X, actualQ.X, Acc, "x differs");
Assert.AreEqual(expectedQ.Y, actualQ.Y, Acc, "y differs");
Assert.AreEqual(expectedQ.Z, actualQ.Z, Acc, "z differs");
}
/// <summary>
///
/// </summary>
/// <param name="q"></param>
/// <param name="order"></param>
/// <returns></returns>
public Euler SetFromQuaternion(Quaternion q, RotationOrder order)
{
// http://www.mathworks.com/matlabcentral/fileexchange/20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/content/SpinCalc.m
var sqx = q.X * q.X;
var sqy = q.Y * q.Y;
var sqz = q.Z * q.Z;
var sqw = q.W * q.W;
this.Order = order;
if (this.Order == RotationOrder.XYZ)
{
this.x = (float)System.Math.Atan2(2 * (q.X * q.W - q.Y * q.Z), (sqw - sqx - sqy + sqz));
this.y = (float)System.Math.Asin(Clamp(2 * (q.X * q.Z + q.Y * q.W), -1, 1));
this.z = (float)System.Math.Atan2(2 * (q.Z * q.W - q.X * q.Y), (sqw + sqx - sqy - sqz));
}
else if (this.Order == RotationOrder.YXZ)
{
this.x = (float)System.Math.Asin(Clamp(2 * (q.X * q.W - q.Y * q.Z), -1, 1));
this.y = (float)System.Math.Atan2(2 * (q.X * q.Z + q.Y * q.W), (sqw - sqx - sqy + sqz));
this.z = (float)System.Math.Atan2(2 * (q.X * q.Y + q.Z * q.W), (sqw - sqx + sqy - sqz));
}
else if (this.Order == RotationOrder.ZXY)
{
this.x = (float)System.Math.Asin(Clamp(2 * (q.X * q.W + q.Y * q.Z), -1, 1));
this.y = (float)System.Math.Atan2(2 * (q.Y * q.W - q.Z * q.X), (sqw - sqx - sqy + sqz));
this.z = (float)System.Math.Atan2(2 * (q.Z * q.W - q.X * q.Y), (sqw - sqx + sqy - sqz));
}
else if (this.Order == RotationOrder.ZYX)
{
this.x = (float)System.Math.Atan2(2 * (q.X * q.W + q.Z * q.Y), (sqw - sqx - sqy + sqz));
this.y = (float)System.Math.Asin(Clamp(2 * (q.Y * q.W - q.X * q.Z), -1, 1));
this.z = (float)System.Math.Atan2(2 * (q.X * q.Y + q.Z * q.W), (sqw + sqx - sqy - sqz));
}
else if (this.Order == RotationOrder.YZX)
{
this.x = (float)System.Math.Atan2(2 * (q.X * q.W - q.Z * q.Y), (sqw - sqx + sqy - sqz));
this.y = (float)System.Math.Atan2(2 * (q.Y * q.W - q.X * q.Z), (sqw + sqx - sqy - sqz));
this.z = (float)System.Math.Asin(Clamp(2 * (q.X * q.Y + q.Z * q.W), -1, 1));
}
else if (this.Order == RotationOrder.XZY)
{
this.x = (float)System.Math.Atan2(2 * (q.X * q.W + q.Y * q.Z), (sqw - sqx + sqy - sqz));
this.y = (float)System.Math.Atan2(2 * (q.X * q.Z + q.Y * q.W), (sqw + sqx - sqy - sqz));
this.z = (float)System.Math.Asin(Clamp(2 * (q.Z * q.W - q.X * q.Y), -1, 1));
}
this.OnPropertyChanged();
return(this);
}
/// <summary>
/// Clone transformations.
/// </summary>
public Transformations(Transformations other)
{
// set values from other
Position = other.Position;
Rotation = other.Rotation;
Scale = other.Scale;
TransformOrder = other.TransformOrder;
RotationOrder = other.RotationOrder;
RotationType = other.RotationType;
// count the object creation
Utils.CountAndAlert.Count(Utils.CountAndAlert.PredefAlertTypes.AddedOrCreated);
}
private void TestToEulerAnglesAtPositiveSingularity(RotationOrder order)
{
Vector3 expectedAngles = default(Vector3);
expectedAngles[order.secondaryAxis] = MathUtil.PiOverTwo;
expectedAngles[order.primaryAxis] = 0;
expectedAngles[order.tertiaryAxis] = +0.2f;
TestToEulerAngles(order, expectedAngles);
expectedAngles[order.tertiaryAxis] = -0.2f;
TestToEulerAngles(order, expectedAngles);
}
public Quaternion GetRotation(ChannelOutputs outputs)
{
OrientationSpace orientationSpace = GetOrientationSpace(outputs);
Vector3 rotationAngles = Rotation.GetValue(outputs);
TwistSwing rotationTwistSwing = RotationOrder.FromTwistSwingAngles(MathExtensions.DegreesToRadians(rotationAngles));
rotationTwistSwing = RotationConstraint.Clamp(rotationTwistSwing);
Quaternion orientedSpaceRotation = rotationTwistSwing.AsQuaternion(RotationOrder.TwistAxis);
Quaternion worldSpaceRotation = orientationSpace.TransformFromOrientedSpace(orientedSpaceRotation);
return(worldSpaceRotation);
}
private Quaternion MakeExpectedQ(RotationOrder order, Vector3 angles)
{
Quaternion[] axisRotations =
{
Quaternion.RotationAxis(Vector3.UnitX, angles.X),
Quaternion.RotationAxis(Vector3.UnitY, angles.Y),
Quaternion.RotationAxis(Vector3.UnitZ, angles.Z)
};
Quaternion expectedQ = axisRotations[order.primaryAxis]
.Chain(axisRotations[order.secondaryAxis])
.Chain(axisRotations[order.tertiaryAxis]);
return(expectedQ);
}
private Matrix4 createTransformFor(FBXElem globalSettings, out RotationOrder order)
{
order = RotationOrder.OrderXYZ;
var frontAxis = (int)globalSettings.Children.GetProperty("FrontAxis").Properties[4].Value;
var frontAxisSign = (int)globalSettings.Children.GetProperty("FrontAxisSign").Properties[4].Value;
var upAxis = (int)globalSettings.Children.GetProperty("UpAxis").Properties[4].Value;
var upAxisSign = (int)globalSettings.Children.GetProperty("UpAxisSign").Properties[4].Value;
var coordAxis = (int)globalSettings.Children.GetProperty("CoordAxis").Properties[4].Value;
var coordAxisSign = (int)globalSettings.Children.GetProperty("CoordAxisSign").Properties[4].Value;
var front = (frontAxis * 2) + Math.Max(frontAxisSign, 0);
var up = (upAxis * 2) + Math.Max(upAxisSign, 0) << 3;
var coord = (coordAxis * 2) + Math.Max(coordAxisSign, 0) << 6;
var coords = (CoordinateSystem)(front + up + coord);
switch (coords)
{
// Blender 2.71 tells us that -Y is forward but the UI suggest +Y is forward.
case CoordinateSystem.nYpZpX:
order = RotationOrder.OrderXYZ;
return Matrix4.CreateRotationX(MathHelper.DegreesToRadians(-90));
case CoordinateSystem.pZpYpX:
order = RotationOrder.OrderXYZ;
return Matrix4.Identity;
default:
throw new NotImplementedException(string.Format("Unsupported World Transformation Matrix: {0}", coords));
}
}
public Quaternion MakeQuaternion(Single x, Single y, Single z, RotationOrder order)
{
Quaternion q = Quaternion.Identity;
switch (order)
{
case RotationOrder.OrderXYZ:
q = Quaternion.FromAxisAngle(OpenTK.Vector3.UnitZ, MathHelper.DegreesToRadians(z)) *
Quaternion.FromAxisAngle(OpenTK.Vector3.UnitY, MathHelper.DegreesToRadians(y)) *
Quaternion.FromAxisAngle(OpenTK.Vector3.UnitX, MathHelper.DegreesToRadians(x));
break;
default:
throw new NotImplementedException(string.Format("Unhandled RotationOrder: {0}", order));
}
return q;
}
internal Vector3 GetLocalEulerAngles(RotationOrder order)
{
Vector3 vector3;
Transform.INTERNAL_CALL_GetLocalEulerAngles(this, order, out vector3);
return vector3;
}
private static extern void INTERNAL_CALL_GetLocalEulerAngles(Transform self, RotationOrder order, out Vector3 value);
public static Vector3 ToEuler(this Quaternion q, RotationOrder order)
{
Vector3 r = Vector3.Zero;
//Single test = q.X * q.Y + q.Z * q.W;
//if (test > 0.499f)
//{
// r.X = 0;
// r.Y = (Single)MathHelper.RadiansToDegrees(Math.Atan2(q.X, q.W));
// r.Z = 90;
//}
//else if (test < -0.499f)
//{
// r.X = 0;
// r.Y = -(Single)MathHelper.RadiansToDegrees(Math.Atan2(q.X, q.W));
// r.Z = -90;
//}
//else
//{
// r.X = (Single)MathHelper.RadiansToDegrees(Math.Atan2(2 * q.X * q.W - 2 * q.Y * q.Z, 1 - 2 * (q.X * q.X) - 2 * (q.Z * q.Z)));
// r.Y = (Single)MathHelper.RadiansToDegrees(Math.Atan2(2 * q.Y * q.W - 2 * q.X * q.Z, 1 - 2 * (q.Y * q.Y) - 2 * (q.Z * q.Z)));
// r.Z = (Single)MathHelper.RadiansToDegrees(Math.Asin(2 * q.X * q.Y + 2 * q.Z * q.W));
//}
float r11, r12, r21, r31, r32;
r11 = r12 = r21 = r31 = r32 = 0;
switch (order)
{
case RotationOrder.OrderXYZ:
r11 = -2.0f * (q.X * q.Y - q.W * q.Z); // was r31
r21 = 2.0f * (q.X * q.Z + q.W * q.Y);
r31 = -2.0f * (q.Y * q.Z - q.W * q.X); // was r11
r12 = q.W * q.W + q.X * q.X - q.Y * q.Y - q.Z * q.Z; // was r32
r32 = q.W * q.W - q.X * q.X - q.Y * q.Y + q.Z * q.Z; // was r12
break;
case RotationOrder.OrderYZX:
r11 = -2.0f * (q.X * q.Z - q.W * q.Y);
r12 = q.W * q.W + q.X * q.X - q.Y * q.Y - q.Z * q.Z;
r21 = 2.0f * (q.X * q.Y + q.W * q.Z);
r31 = -2.0f * (q.Y * q.Z - q.W * q.X);
r32 = q.W * q.W - q.X * q.X + q.Y * q.Y - q.Z * q.Z;
break;
}
r.X = (Single)MathHelper.RadiansToDegrees(Math.Atan2(r31, r32));
r.Y = (Single)MathHelper.RadiansToDegrees(Math.Asin(r21));
r.Z = (Single)MathHelper.RadiansToDegrees(Math.Atan2(r11, r12));
//if (r.X < -90) { r.X += 360; }
//if (r.Y < -90) { r.Y += 360; }
//if (r.Z < -90) { r.Z += 360; }
return r;
}
internal void SetLocalEulerAngles(Vector3 euler, RotationOrder order)
{
Transform.INTERNAL_CALL_SetLocalEulerAngles(this, ref euler, order);
}
private static extern void INTERNAL_CALL_SetLocalEulerAngles(Transform self, ref Vector3 euler, RotationOrder order);
/**
@brief
@param name
@param rotationOrder
@param localMat
@param globalMatInv
*/
/// <summary>
/// ボーンを追加する。
/// </summary>
/// <param name="name">ボーンの名称</param>
/// <param name="parentBoneIndex">親ボーンのインデックス(親がない場合は-1)</param>
/// <param name="rotationOrder">ボーンの回転行列の計算方法</param>
/// <param name="localMat">ボーンのローカル変形行列</param>
public void AddBone(string name, int parentBoneIndex, RotationOrder rotationOrder, asd.Matrix44 localMat)
{
SwigObject.AddBone(name, parentBoneIndex, (swig.RotationOrder)rotationOrder, ref localMat);
}
public void RotationField(bool disabled)
{
Transform transform = this.targets[0] as Transform;
Vector3 localEulerAngles = transform.GetLocalEulerAngles(transform.rotationOrder);
if (((this.m_OldEulerAngles.x != localEulerAngles.x) || (this.m_OldEulerAngles.y != localEulerAngles.y)) || ((this.m_OldEulerAngles.z != localEulerAngles.z) || (this.m_OldRotationOrder != transform.rotationOrder)))
{
this.m_EulerAngles = transform.GetLocalEulerAngles(transform.rotationOrder);
this.m_OldRotationOrder = transform.rotationOrder;
}
bool flag = false;
bool flag2 = false;
for (int i = 1; i < this.targets.Length; i++)
{
Transform transform2 = this.targets[i] as Transform;
Vector3 vector2 = transform2.GetLocalEulerAngles(transform2.rotationOrder);
flag |= ((vector2.x != localEulerAngles.x) || (vector2.y != localEulerAngles.y)) || (vector2.z != localEulerAngles.z);
flag2 |= transform2.rotationOrder != transform.rotationOrder;
}
Rect totalPosition = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight * (!EditorGUIUtility.wideMode ? ((float) 2) : ((float) 1)), new GUILayoutOption[0]);
GUIContent label = EditorGUI.BeginProperty(totalPosition, this.rotationContent, this.m_Rotation);
EditorGUI.showMixedValue = flag;
EditorGUI.BeginChangeCheck();
int id = GUIUtility.GetControlID(s_FoldoutHash, FocusType.Keyboard, totalPosition);
string str = "";
if (AnimationMode.InAnimationMode() && (transform.rotationOrder != RotationOrder.OrderZXY))
{
if (flag2)
{
str = "Mixed";
}
else
{
str = transform.rotationOrder.ToString();
str = str.Substring(str.Length - 3);
}
label.text = label.text + " (" + str + ")";
}
totalPosition = EditorGUI.MultiFieldPrefixLabel(totalPosition, id, label, 3);
totalPosition.height = EditorGUIUtility.singleLineHeight;
using (new EditorGUI.DisabledScope(disabled))
{
this.m_EulerAngles = EditorGUI.Vector3Field(totalPosition, GUIContent.none, this.m_EulerAngles);
}
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObjects(this.targets, "Inspector");
foreach (Transform transform3 in this.targets)
{
transform3.SetLocalEulerAngles(this.m_EulerAngles, transform3.rotationOrder);
if (transform3.parent != null)
{
transform3.SendTransformChangedScale();
}
}
this.m_Rotation.serializedObject.SetIsDifferentCacheDirty();
}
EditorGUI.showMixedValue = false;
if (flag2)
{
EditorGUILayout.HelpBox("Transforms have different rotation orders, keyframes saved will have the same value but not the same local rotation", MessageType.Warning);
}
EditorGUI.EndProperty();
}
