public IndexedQuaternion(Microsoft.Xna.Framework.Quaternion q)
{
X = q.X;
Y = q.Y;
Z = q.Z;
W = q.W;
}
public void MultiplyTest()
{
Quaternion[] QuaternionPatterns = { Quaternion.Identity, Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), 0.72m), Quaternion.CreateFromAxisAngle(new Vector3(0.5m, 0.5m, 0), 0.72m), Quaternion.CreateFromAxisAngle(new Vector3(0, 0.5m, 0.5m), 0.72m) };
foreach (Quaternion q1 in QuaternionPatterns)
{
foreach (Quaternion q2 in QuaternionPatterns)
{
Quaternion quaternion1 = q1, quaternion2 = q2;
Quaternion result;
quaternion1.Normalize();
quaternion2.Normalize();
Quaternion.Multiply(ref quaternion1, ref quaternion2, out result);
Microsoft.Xna.Framework.Quaternion xnaq1 = new Microsoft.Xna.Framework.Quaternion((float)q1.X, (float)q1.Y, (float)q1.Z, (float)q1.W);
Microsoft.Xna.Framework.Quaternion xnaq2 = new Microsoft.Xna.Framework.Quaternion((float)q2.X, (float)q2.Y, (float)q2.Z, (float)q2.W);
Microsoft.Xna.Framework.Quaternion xnaactual;
Microsoft.Xna.Framework.Quaternion.Multiply(ref xnaq1, ref xnaq2, out xnaactual);
Quaternion actual = new Quaternion {
X = (decimal)xnaactual.X, Y = (decimal)xnaactual.Y, Z = (decimal)xnaactual.Z, W = (decimal)xnaactual.W
};
actual.Normalize();
result.Normalize();
Assert.IsTrue(Math.Abs(actual.X - result.X) < 0.01m);
Assert.IsTrue(Math.Abs(actual.Y - result.Y) < 0.01m);
Assert.IsTrue(Math.Abs(actual.Z - result.Z) < 0.01m);
Assert.IsTrue(Math.Abs(actual.W - result.W) < 0.01m);
}
}
}
private Quaterion(Quat q)
{
_quaterion = q;
q.Length();
q.LengthSquared();
q.Normalize();
}
private Quaterion(Quat q)
{
_quaterion = q;
q.Length();
q.LengthSquared();
q.Normalize();
}
public void SlerpTest()
{
Quaternion[] QuaternionPatterns = { /*Quaternion.Identity,*/ Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), 0.72m), Quaternion.CreateFromAxisAngle(new Vector3(0.5m, 0.5m, 0), 0.72m), Quaternion.CreateFromAxisAngle(new Vector3(0, 0.5m, 0.5m), 0.72m) };
decimal[] ratePatterns = { 0m, 0.2m, 0.25m, 0.6m, 0.8m, 1m };
foreach (Quaternion q1 in QuaternionPatterns)
{
foreach (Quaternion q2 in QuaternionPatterns)
{
foreach (decimal rate in ratePatterns)
{
Quaternion quaternion1 = q1, quaternion2 = q2;
Quaternion result;
quaternion1.Normalize();
quaternion2.Normalize();
Quaternion.Slerp(ref quaternion1, ref quaternion2, rate, out result);
Microsoft.Xna.Framework.Quaternion xnaq1 = new Microsoft.Xna.Framework.Quaternion((float)q1.X, (float)q1.Y, (float)q1.Z, (float)q1.W);
Microsoft.Xna.Framework.Quaternion xnaq2 = new Microsoft.Xna.Framework.Quaternion((float)q2.X, (float)q2.Y, (float)q2.Z, (float)q2.W);
Microsoft.Xna.Framework.Quaternion xnaactual;
Microsoft.Xna.Framework.Quaternion.Slerp(ref xnaq1, ref xnaq2, (float)rate, out xnaactual);
Quaternion actual = new Quaternion {
X = (decimal)xnaactual.X, Y = (decimal)xnaactual.Y, Z = (decimal)xnaactual.Z, W = (decimal)xnaactual.W
};
actual.Normalize();
result.Normalize();
Assert.AreEqual(Math.Abs(actual.X - result.X) < 0.01m, true);
Assert.AreEqual(Math.Abs(actual.Y - result.Y) < 0.01m, true);
Assert.AreEqual(Math.Abs(actual.Z - result.Z) < 0.01m, true);
Assert.AreEqual(Math.Abs(actual.W - result.W) < 0.01m, true);
}
}
}
}
public static void Convert(ref Quaternion quaternion, out BEPUutilities.Quaternion bepuQuaternion)
{
bepuQuaternion.X = quaternion.X;
bepuQuaternion.Y = quaternion.Y;
bepuQuaternion.Z = quaternion.Z;
bepuQuaternion.W = quaternion.W;
}
public static void Convert(ref BEPUutilities.Quaternion bepuQuaternion, out Quaternion quaternion)
{
quaternion.X = bepuQuaternion.X;
quaternion.Y = bepuQuaternion.Y;
quaternion.Z = bepuQuaternion.Z;
quaternion.W = bepuQuaternion.W;
}
public void ReplaceRotation(Microsoft.Xna.Framework.Quaternion newValue)
{
var index = GameComponentsLookup.Rotation;
var component = CreateComponent <RotationComponent>(index);
component.value = newValue;
ReplaceComponent(index, component);
}
public static BEPUutilities.Quaternion Convert(Quaternion quaternion)
{
BEPUutilities.Quaternion toReturn;
toReturn.X = quaternion.X;
toReturn.Y = quaternion.Y;
toReturn.Z = quaternion.Z;
toReturn.W = quaternion.W;
return(toReturn);
}
public static Quaternion ConvertFrom(Microsoft.Xna.Framework.Quaternion value)
{
return(new Quaternion()
{
X = value.X,
Y = value.Y,
Z = value.Z,
W = value.W
});
}
public static Microsoft.Xna.Framework.Quaternion GetRotation(this Matrix4x4 matrix)
{
var q = new Microsoft.Xna.Framework.Quaternion();
q.X = (float)Math.Sqrt(Math.Max(0, 1f + matrix.M11 - matrix.M22 - matrix.M33)) / 2f;
q.Y = (float)Math.Sqrt(Math.Max(0, 1f - matrix.M11 + matrix.M22 - matrix.M33)) / 2f;
q.W = (float)Math.Sqrt(Math.Max(0, 1f + matrix.M11 + matrix.M22 + matrix.M33)) / 2f;
q.Z = (float)Math.Sqrt(Math.Max(0, 1f - matrix.M11 - matrix.M22 + matrix.M33)) / 2f;
q.X = CopySign(q.X, matrix.M32 - matrix.M23);
q.Y = CopySign(q.Y, matrix.M13 - matrix.M31);
q.Z = CopySign(q.Z, matrix.M21 - matrix.M12);
return(q);
}
public static AffineTransform Blend(ReadOnlySpan <AffineTransform> transforms, ReadOnlySpan <float> weights)
{
var s = XNAV3.Zero;
var r = default(XNAQUAT);
var t = XNAV3.Zero;
for (int i = 0; i < transforms.Length; ++i)
{
var w = weights[i];
s += transforms[i].Scale * w;
r += transforms[i].Rotation * w;
t += transforms[i].Translation * w;
}
r = XNAQUAT.Normalize(r);
return(new AffineTransform(s, r, t));
}
public Matrix InterpolateBoneRelativeMatrices(Matrix mat1, Matrix mat2, float factor)
{
Vector3 trans1 = Vector3.TransformCoordinate(Vector3.Zero, mat1);
Vector3 trans2 = Vector3.TransformCoordinate(Vector3.Zero, mat1);
if ((trans1 - trans2).LengthSquared() > 0.0001f)
{
throw new InvalidOperationException("Translation changes of bones is not supported");
}
var rot1 = mat1 * Matrix.Translation(-trans1);
var rot2 = mat2 * Matrix.Translation(-trans2);
var q1 = Microsoft.Xna.Framework.Quaternion.CreateFromRotationMatrix(rot1.xna());
var q2 = Microsoft.Xna.Framework.Quaternion.CreateFromRotationMatrix(rot2.xna());
var q = Quaternion.Slerp(q1, q2, factor);
return(Microsoft.Xna.Framework.Matrix.CreateFromQuaternion(q).dx() * Matrix.Translation(trans1));
}
public void TransformTest()
{
Quaternion[] rotationTestPatterns = { Quaternion.Identity, Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), 0.72m), Quaternion.CreateFromAxisAngle(new Vector3(0.5m, 0.5m, 0), 0.72m), Quaternion.CreateFromAxisAngle(new Vector3(0, 0.5m, 0.5m), 0.72m) };
Vector3[] transrationTestPatterns = { Vector3.Zero, Vector3.One, new Vector3(5, 1, 1), new Vector3(1, 5, 1), new Vector3(1, 1, 5), new Vector3(5, 5, 1), new Vector3(5, 1, 5), new Vector3(1, 5, 5), new Vector3(5, 5, 5) };
foreach (var rot in rotationTestPatterns)
{
foreach (var vec in transrationTestPatterns)
{
Vector3 value = vec, result;
Quaternion rotation = rot;
Vector3.Transform(ref value, ref rotation, out result);
Microsoft.Xna.Framework.Vector3 value2 = new Microsoft.Xna.Framework.Vector3((float)vec.X, (float)vec.Y, (float)vec.Z), actual_xna;
Microsoft.Xna.Framework.Quaternion rotation2 = new Microsoft.Xna.Framework.Quaternion((float)rot.X, (float)rot.Y, (float)rot.Z, (float)rot.W);
Microsoft.Xna.Framework.Vector3.Transform(ref value2, ref rotation2, out actual_xna);
Vector3 acutual = new Vector3((decimal)actual_xna.X, (decimal)actual_xna.Y, (decimal)actual_xna.Z);
Assert.IsTrue(Math.Abs(result.X - acutual.X) < 0.001m);
Assert.IsTrue(Math.Abs(result.Y - acutual.Y) < 0.001m);
Assert.IsTrue(Math.Abs(result.Z - acutual.Z) < 0.001m);
}
}
}
public void TransformTest()
{
Quaternion[] rotationTestPatterns = { Quaternion.Identity, Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), 0.72m), Quaternion.CreateFromAxisAngle(new Vector3(0.5m, 0.5m, 0), 0.72m), Quaternion.CreateFromAxisAngle(new Vector3(0, 0.5m, 0.5m), 0.72m) };
Vector3[] transrationTestPatterns = { Vector3.Zero, Vector3.One, new Vector3(5, 1, 1), new Vector3(1, 5, 1), new Vector3(1, 1, 5), new Vector3(5, 5, 1), new Vector3(5, 1, 5), new Vector3(1, 5, 5), new Vector3(5, 5, 5) };
foreach (var rot in rotationTestPatterns)
{
foreach (var vec in transrationTestPatterns)
{
Vector3 value = vec, result;
Quaternion rotation = rot;
Vector3.Transform(ref value, ref rotation, out result);
Microsoft.Xna.Framework.Vector3 value2 = new Microsoft.Xna.Framework.Vector3((float)vec.X, (float)vec.Y, (float)vec.Z), actual_xna;
Microsoft.Xna.Framework.Quaternion rotation2 = new Microsoft.Xna.Framework.Quaternion((float)rot.X, (float)rot.Y, (float)rot.Z, (float)rot.W);
Microsoft.Xna.Framework.Vector3.Transform(ref value2, ref rotation2, out actual_xna);
Vector3 acutual = new Vector3((decimal)actual_xna.X, (decimal)actual_xna.Y, (decimal)actual_xna.Z);
Assert.IsTrue(Math.Abs(result.X - acutual.X) < 0.001m);
Assert.IsTrue(Math.Abs(result.Y - acutual.Y) < 0.001m);
Assert.IsTrue(Math.Abs(result.Z - acutual.Z) < 0.001m);
}
}
}
public Group(byte[] bytes)
{
Stream s = new MemoryStream(bytes);
BinaryReader br = new BinaryReader(s);
s.Seek(4, SeekOrigin.Begin);
ShaderIndex = br.ReadInt16();
IndiceStart = br.ReadInt16();
IndiceCount = br.ReadInt16();
s.Seek(4 + 2 + 16, SeekOrigin.Current);
Quaternion = new Microsoft.Xna.Framework.Quaternion(br.ReadSingle(), br.ReadSingle(), br.ReadSingle(), br.ReadSingle());
float[] f = new float[] { br.ReadSingle(), br.ReadSingle(), br.ReadSingle(), br.ReadSingle(), br.ReadSingle(), br.ReadSingle() };
BoundingBox = new Microsoft.Xna.Framework.BoundingBox(new Microsoft.Xna.Framework.Vector3(f[0], f[2], f[4]), new Microsoft.Xna.Framework.Vector3(f[1], f[3], f[5]));
}
public void SetParameter(string name, Microsoft.Xna.Framework.Quaternion value)
{
XNAEffect.Parameters[name].SetValue(value);
}
public Quaterion(float x, float y, float z, float w)
{
_quaterion = new Quat(x, y, z, w);
}
public static Quaterion FromAxisAngle(Vector3 axis, float angle)
{
return(Quat.CreateFromAxisAngle(axis, angle));
}
public static Quaterion FromRotationMatrix(Matrix matrix)
{
return(Quat.CreateFromRotationMatrix(matrix));
}
public Quaterion(float x, float y, float z, float w)
{
_quaterion = new Quat(x, y, z, w);
}
public void SlerpTest()
{
Quaternion[] QuaternionPatterns = { /*Quaternion.Identity,*/ Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), 0.72m), Quaternion.CreateFromAxisAngle(new Vector3(0.5m, 0.5m, 0), 0.72m), Quaternion.CreateFromAxisAngle(new Vector3(0, 0.5m, 0.5m), 0.72m) };
decimal[] ratePatterns = { 0m, 0.2m, 0.25m, 0.6m, 0.8m, 1m };
foreach (Quaternion q1 in QuaternionPatterns)
{
foreach (Quaternion q2 in QuaternionPatterns)
{
foreach (decimal rate in ratePatterns)
{
Quaternion quaternion1 = q1, quaternion2 = q2;
Quaternion result;
quaternion1.Normalize();
quaternion2.Normalize();
Quaternion.Slerp(ref quaternion1, ref quaternion2, rate, out result);
Microsoft.Xna.Framework.Quaternion xnaq1 = new Microsoft.Xna.Framework.Quaternion((float)q1.X, (float)q1.Y, (float)q1.Z, (float)q1.W);
Microsoft.Xna.Framework.Quaternion xnaq2 = new Microsoft.Xna.Framework.Quaternion((float)q2.X, (float)q2.Y, (float)q2.Z, (float)q2.W);
Microsoft.Xna.Framework.Quaternion xnaactual;
Microsoft.Xna.Framework.Quaternion.Slerp(ref xnaq1, ref xnaq2, (float)rate, out xnaactual);
Quaternion actual = new Quaternion { X = (decimal)xnaactual.X, Y = (decimal)xnaactual.Y, Z = (decimal)xnaactual.Z, W = (decimal)xnaactual.W };
actual.Normalize();
result.Normalize();
Assert.AreEqual(Math.Abs(actual.X- result.X)<0.01m, true);
Assert.AreEqual(Math.Abs(actual.Y - result.Y) < 0.01m, true);
Assert.AreEqual(Math.Abs(actual.Z- result.Z)<0.01m, true);
Assert.AreEqual(Math.Abs(actual.W- result.W) < 0.01m, true);
}
}
}
}
public static Quaterion FromYawPitchRoll(float yaw, float pitch, float roll)
{
return(Quat.CreateFromYawPitchRoll(yaw, pitch, roll));
}
public static Vector3 Transform(Vector3 vector, Quaternion transform)
{
return(new Vector3(
MonoGameVector3.Transform(vector.MonoGameVector, transform)
));
}
public static System.Numerics.Quaternion ToCS(this Microsoft.Xna.Framework.Quaternion quaternion)
{
return(new System.Numerics.Quaternion(quaternion.X, quaternion.Y, quaternion.Z, quaternion.W));
}
public static SlimDX.Quaternion dx(this Microsoft.Xna.Framework.Quaternion v)
{
return(new SlimDX.Quaternion(v.X, v.Y, v.Z, v.W));
}
//negative y becomes positive z
//positive z becomes positive y
private Quaternion QuatConvert(Microsoft.Xna.Framework.Quaternion quat)
{
return(new Quaternion(-quat.Z, -quat.X, quat.Y, quat.W)); // x mirror
//return new Quaternion(-quat.Z, quat.X, -quat.Y, quat.W); //good
}
public static System.Numerics.Quaternion ToNumerics(this Microsoft.Xna.Framework.Quaternion q)
{
return(new System.Numerics.Quaternion(q.X, q.Y, q.Z, q.W));
}
public virtual void OnRotation(GameEntity entity, Microsoft.Xna.Framework.Quaternion value)
{
transform.rotation = new Quaternion(value.X, value.Y, value.Z, value.W);
}
public void MultiplyTest()
{
Quaternion[] QuaternionPatterns = { Quaternion.Identity, Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), 0.72m), Quaternion.CreateFromAxisAngle(new Vector3(0.5m, 0.5m, 0), 0.72m), Quaternion.CreateFromAxisAngle(new Vector3(0, 0.5m, 0.5m), 0.72m) };
foreach (Quaternion q1 in QuaternionPatterns)
{
foreach (Quaternion q2 in QuaternionPatterns)
{
Quaternion quaternion1 = q1, quaternion2 = q2;
Quaternion result;
quaternion1.Normalize();
quaternion2.Normalize();
Quaternion.Multiply(ref quaternion1, ref quaternion2, out result);
Microsoft.Xna.Framework.Quaternion xnaq1 = new Microsoft.Xna.Framework.Quaternion((float)q1.X, (float)q1.Y, (float)q1.Z, (float)q1.W);
Microsoft.Xna.Framework.Quaternion xnaq2 = new Microsoft.Xna.Framework.Quaternion((float)q2.X, (float)q2.Y, (float)q2.Z, (float)q2.W);
Microsoft.Xna.Framework.Quaternion xnaactual;
Microsoft.Xna.Framework.Quaternion.Multiply(ref xnaq1, ref xnaq2, out xnaactual);
Quaternion actual = new Quaternion { X = (decimal)xnaactual.X, Y = (decimal)xnaactual.Y, Z = (decimal)xnaactual.Z, W = (decimal)xnaactual.W };
actual.Normalize();
result.Normalize();
Assert.IsTrue(Math.Abs(actual.X - result.X) < 0.01m);
Assert.IsTrue(Math.Abs(actual.Y - result.Y) < 0.01m);
Assert.IsTrue(Math.Abs(actual.Z - result.Z) < 0.01m);
Assert.IsTrue(Math.Abs(actual.W - result.W) < 0.01m);
}
}
}
