public static void Invert(ref FixMatrix matrix, out FixMatrix result)
{
Fix64 determinantInverse = 1 / matrix.Determinant();
Fix64 m11 = (matrix.M22 * matrix.M33 - matrix.M23 * matrix.M32) * determinantInverse;
Fix64 m12 = (matrix.M13 * matrix.M32 - matrix.M33 * matrix.M12) * determinantInverse;
Fix64 m13 = (matrix.M12 * matrix.M23 - matrix.M22 * matrix.M13) * determinantInverse;
Fix64 m21 = (matrix.M23 * matrix.M31 - matrix.M21 * matrix.M33) * determinantInverse;
Fix64 m22 = (matrix.M11 * matrix.M33 - matrix.M13 * matrix.M31) * determinantInverse;
Fix64 m23 = (matrix.M13 * matrix.M21 - matrix.M11 * matrix.M23) * determinantInverse;
Fix64 m31 = (matrix.M21 * matrix.M32 - matrix.M22 * matrix.M31) * determinantInverse;
Fix64 m32 = (matrix.M12 * matrix.M31 - matrix.M11 * matrix.M32) * determinantInverse;
Fix64 m33 = (matrix.M11 * matrix.M22 - matrix.M12 * matrix.M21) * determinantInverse;
result.M11 = m11;
result.M12 = m12;
result.M13 = m13;
result.M21 = m21;
result.M22 = m22;
result.M23 = m23;
result.M31 = m31;
result.M32 = m32;
result.M33 = m33;
}
public void TestSecretExit()
{
Assert.AreSame(level.Segments[6], level.SecretReturnSegment);
var expectedOrientation = new FixMatrix(new FixVector(0, 0, -1), new FixVector(0, 1, 0), new FixVector(1, 0, 0));
Assert.AreEqual(expectedOrientation, level.SecretReturnOrientation);
Assert.AreEqual(TriggerType.SecretExit, level.Triggers[1].Type);
}
/// <summary>
/// Transforms a vector by the transposed of the given Matrix.
/// </summary>
/// <param name="position">The vector to transform.</param>
/// <param name="matrix">The transform matrix.</param>
/// <param name="result">The transformed vector.</param>
public static void TransposedTransform(ref FixVector3 position, ref FixMatrix matrix, out FixVector3 result)
{
Fix64 num0 = ((position.x * matrix.M11) + (position.y * matrix.M12)) + (position.z * matrix.M13);
Fix64 num1 = ((position.x * matrix.M21) + (position.y * matrix.M22)) + (position.z * matrix.M23);
Fix64 num2 = ((position.x * matrix.M31) + (position.y * matrix.M32)) + (position.z * matrix.M33);
result.x = num0;
result.y = num1;
result.z = num2;
}
/// <summary>
/// Creates the transposed matrix.
/// </summary>
/// <param name="matrix">The matrix which should be transposed.</param>
/// <param name="result">The transposed JMatrix.</param>
public static void Transpose(ref FixMatrix matrix, out FixMatrix result)
{
result.M11 = matrix.M11;
result.M12 = matrix.M21;
result.M13 = matrix.M31;
result.M21 = matrix.M12;
result.M22 = matrix.M22;
result.M23 = matrix.M32;
result.M31 = matrix.M13;
result.M32 = matrix.M23;
result.M33 = matrix.M33;
}
/// <summary>
/// Changes every sign of the matrix entry to '+'
/// </summary>
/// <param name="matrix">The matrix.</param>
/// <param name="result">The absolute matrix.</param>
#region public static void Absolute(ref JMatrix matrix,out JMatrix result)
public static void Absolute(ref FixMatrix matrix, out FixMatrix result)
{
result.M11 = Fix64.Abs(matrix.M11);
result.M12 = Fix64.Abs(matrix.M12);
result.M13 = Fix64.Abs(matrix.M13);
result.M21 = Fix64.Abs(matrix.M21);
result.M22 = Fix64.Abs(matrix.M22);
result.M23 = Fix64.Abs(matrix.M23);
result.M31 = Fix64.Abs(matrix.M31);
result.M32 = Fix64.Abs(matrix.M32);
result.M33 = Fix64.Abs(matrix.M33);
}
/// <summary>
/// Matrices are added.
/// </summary>
/// <param name="matrix1">The first matrix.</param>
/// <param name="matrix2">The second matrix.</param>
/// <param name="result">The sum of both matrices.</param>
public static void Add(ref FixMatrix matrix1, ref FixMatrix matrix2, out FixMatrix result)
{
result.M11 = matrix1.M11 + matrix2.M11;
result.M12 = matrix1.M12 + matrix2.M12;
result.M13 = matrix1.M13 + matrix2.M13;
result.M21 = matrix1.M21 + matrix2.M21;
result.M22 = matrix1.M22 + matrix2.M22;
result.M23 = matrix1.M23 + matrix2.M23;
result.M31 = matrix1.M31 + matrix2.M31;
result.M32 = matrix1.M32 + matrix2.M32;
result.M33 = matrix1.M33 + matrix2.M33;
}
static FixMatrix()
{
Zero = new FixMatrix();
Identity = new FixMatrix
{
M11 = Fix64.One,
M22 = Fix64.One,
M33 = Fix64.One
};
InternalIdentity = Identity;
}
/// <summary>
/// Multiply a matrix by a scalefactor.
/// </summary>
/// <param name="matrix1">The matrix.</param>
/// <param name="scaleFactor">The scale factor.</param>
/// <param name="result">A JMatrix multiplied by the scale factor.</param>
public static void Multiply(ref FixMatrix matrix1, Fix64 scaleFactor, out FixMatrix result)
{
Fix64 num = scaleFactor;
result.M11 = matrix1.M11 * num;
result.M12 = matrix1.M12 * num;
result.M13 = matrix1.M13 * num;
result.M21 = matrix1.M21 * num;
result.M22 = matrix1.M22 * num;
result.M23 = matrix1.M23 * num;
result.M31 = matrix1.M31 * num;
result.M32 = matrix1.M32 * num;
result.M33 = matrix1.M33 * num;
}
public static void CreateRotationZ(Fix64 radians, out FixMatrix result)
{
Fix64 num2 = Fix64.Cos(radians);
Fix64 num = Fix64.Sin(radians);
result.M11 = num2;
result.M12 = num;
result.M13 = Fix64.Zero;
result.M21 = -num;
result.M22 = num2;
result.M23 = Fix64.Zero;
result.M31 = Fix64.Zero;
result.M32 = Fix64.Zero;
result.M33 = Fix64.One;
}
public static void LookAt(FixVector3 forward, FixVector3 upwards, out FixMatrix result)
{
FixVector3 zaxis = forward; zaxis.Normalize();
FixVector3 xaxis = FixVector3.Cross(upwards, zaxis); xaxis.Normalize();
FixVector3 yaxis = FixVector3.Cross(zaxis, xaxis);
result.M11 = xaxis.x;
result.M21 = yaxis.x;
result.M31 = zaxis.x;
result.M12 = xaxis.y;
result.M22 = yaxis.y;
result.M32 = zaxis.y;
result.M13 = xaxis.z;
result.M23 = yaxis.z;
result.M33 = zaxis.z;
}
/// <summary>
/// Calculates the inverse of a give matrix.
/// </summary>
/// <param name="matrix">The matrix to invert.</param>
/// <param name="result">The inverted JMatrix.</param>
public static void Inverse(ref FixMatrix matrix, out FixMatrix result)
{
Fix64 det = 1024 * matrix.M11 * matrix.M22 * matrix.M33 -
1024 * matrix.M11 * matrix.M23 * matrix.M32 -
1024 * matrix.M12 * matrix.M21 * matrix.M33 +
1024 * matrix.M12 * matrix.M23 * matrix.M31 +
1024 * matrix.M13 * matrix.M21 * matrix.M32 -
1024 * matrix.M13 * matrix.M22 * matrix.M31;
Fix64 num11 = 1024 * matrix.M22 * matrix.M33 - 1024 * matrix.M23 * matrix.M32;
Fix64 num12 = 1024 * matrix.M13 * matrix.M32 - 1024 * matrix.M12 * matrix.M33;
Fix64 num13 = 1024 * matrix.M12 * matrix.M23 - 1024 * matrix.M22 * matrix.M13;
Fix64 num21 = 1024 * matrix.M23 * matrix.M31 - 1024 * matrix.M33 * matrix.M21;
Fix64 num22 = 1024 * matrix.M11 * matrix.M33 - 1024 * matrix.M31 * matrix.M13;
Fix64 num23 = 1024 * matrix.M13 * matrix.M21 - 1024 * matrix.M23 * matrix.M11;
Fix64 num31 = 1024 * matrix.M21 * matrix.M32 - 1024 * matrix.M31 * matrix.M22;
Fix64 num32 = 1024 * matrix.M12 * matrix.M31 - 1024 * matrix.M32 * matrix.M11;
Fix64 num33 = 1024 * matrix.M11 * matrix.M22 - 1024 * matrix.M21 * matrix.M12;
if (det == 0)
{
result.M11 = Fix64.PositiveInfinity;
result.M12 = Fix64.PositiveInfinity;
result.M13 = Fix64.PositiveInfinity;
result.M21 = Fix64.PositiveInfinity;
result.M22 = Fix64.PositiveInfinity;
result.M23 = Fix64.PositiveInfinity;
result.M31 = Fix64.PositiveInfinity;
result.M32 = Fix64.PositiveInfinity;
result.M33 = Fix64.PositiveInfinity;
}
else
{
result.M11 = num11 / det;
result.M12 = num12 / det;
result.M13 = num13 / det;
result.M21 = num21 / det;
result.M22 = num22 / det;
result.M23 = num23 / det;
result.M31 = num31 / det;
result.M32 = num32 / det;
result.M33 = num33 / det;
}
}
public override bool Equals(object obj)
{
if (!(obj is FixMatrix))
{
return(false);
}
FixMatrix other = (FixMatrix)obj;
return(this.M11 == other.M11 &&
this.M12 == other.M12 &&
this.M13 == other.M13 &&
this.M21 == other.M21 &&
this.M22 == other.M22 &&
this.M23 == other.M23 &&
this.M31 == other.M31 &&
this.M32 == other.M32 &&
this.M33 == other.M33);
}
/// <summary>
/// Creates a quaternion from a matrix.
/// </summary>
/// <param name="matrix">A matrix representing an orientation.</param>
/// <param name="result">JQuaternion representing an orientation.</param>
public static void CreateFromMatrix(ref FixMatrix matrix, out FixQuaternion result)
{
Fix64 num8 = (matrix.M11 + matrix.M22) + matrix.M33;
if (num8 > Fix64.Zero)
{
Fix64 num = Fix64.Sqrt((num8 + Fix64.One));
result.w = num * Fix64.Half;
num = Fix64.Half / num;
result.x = (matrix.M23 - matrix.M32) * num;
result.y = (matrix.M31 - matrix.M13) * num;
result.z = (matrix.M12 - matrix.M21) * num;
}
else if ((matrix.M11 >= matrix.M22) && (matrix.M11 >= matrix.M33))
{
Fix64 num7 = Fix64.Sqrt((((Fix64.One + matrix.M11) - matrix.M22) - matrix.M33));
Fix64 num4 = Fix64.Half / num7;
result.x = Fix64.Half * num7;
result.y = (matrix.M12 + matrix.M21) * num4;
result.z = (matrix.M13 + matrix.M31) * num4;
result.w = (matrix.M23 - matrix.M32) * num4;
}
else if (matrix.M22 > matrix.M33)
{
Fix64 num6 = Fix64.Sqrt((((Fix64.One + matrix.M22) - matrix.M11) - matrix.M33));
Fix64 num3 = Fix64.Half / num6;
result.x = (matrix.M21 + matrix.M12) * num3;
result.y = Fix64.Half * num6;
result.z = (matrix.M32 + matrix.M23) * num3;
result.w = (matrix.M31 - matrix.M13) * num3;
}
else
{
Fix64 num5 = Fix64.Sqrt((((Fix64.One + matrix.M33) - matrix.M11) - matrix.M22));
Fix64 num2 = Fix64.Half / num5;
result.x = (matrix.M31 + matrix.M13) * num2;
result.y = (matrix.M32 + matrix.M23) * num2;
result.z = Fix64.Half * num5;
result.w = (matrix.M12 - matrix.M21) * num2;
}
}
/// <summary>
/// Creates a JMatrix representing an orientation from a quaternion.
/// </summary>
/// <param name="quaternion">The quaternion the matrix should be created from.</param>
/// <param name="result">JMatrix representing an orientation.</param>
public static void CreateFromQuaternion(ref FixQuaternion quaternion, out FixMatrix result)
{
Fix64 num9 = quaternion.x * quaternion.x;
Fix64 num8 = quaternion.y * quaternion.y;
Fix64 num7 = quaternion.z * quaternion.z;
Fix64 num6 = quaternion.x * quaternion.y;
Fix64 num5 = quaternion.z * quaternion.w;
Fix64 num4 = quaternion.z * quaternion.x;
Fix64 num3 = quaternion.y * quaternion.w;
Fix64 num2 = quaternion.y * quaternion.z;
Fix64 num = quaternion.x * quaternion.w;
result.M11 = Fix64.One - (2 * (num8 + num7));
result.M12 = 2 * (num6 + num5);
result.M13 = 2 * (num4 - num3);
result.M21 = 2 * (num6 - num5);
result.M22 = Fix64.One - (2 * (num7 + num9));
result.M23 = 2 * (num2 + num);
result.M31 = 2 * (num4 + num3);
result.M32 = 2 * (num2 - num);
result.M33 = Fix64.One - (2 * (num8 + num9));
}
/// <summary>
/// Multiply two matrices. Notice: matrix multiplication is not commutative.
/// </summary>
/// <param name="matrix1">The first matrix.</param>
/// <param name="matrix2">The second matrix.</param>
/// <param name="result">The product of both matrices.</param>
public static void Multiply(ref FixMatrix matrix1, ref FixMatrix matrix2, out FixMatrix result)
{
Fix64 num0 = ((matrix1.M11 * matrix2.M11) + (matrix1.M12 * matrix2.M21)) + (matrix1.M13 * matrix2.M31);
Fix64 num1 = ((matrix1.M11 * matrix2.M12) + (matrix1.M12 * matrix2.M22)) + (matrix1.M13 * matrix2.M32);
Fix64 num2 = ((matrix1.M11 * matrix2.M13) + (matrix1.M12 * matrix2.M23)) + (matrix1.M13 * matrix2.M33);
Fix64 num3 = ((matrix1.M21 * matrix2.M11) + (matrix1.M22 * matrix2.M21)) + (matrix1.M23 * matrix2.M31);
Fix64 num4 = ((matrix1.M21 * matrix2.M12) + (matrix1.M22 * matrix2.M22)) + (matrix1.M23 * matrix2.M32);
Fix64 num5 = ((matrix1.M21 * matrix2.M13) + (matrix1.M22 * matrix2.M23)) + (matrix1.M23 * matrix2.M33);
Fix64 num6 = ((matrix1.M31 * matrix2.M11) + (matrix1.M32 * matrix2.M21)) + (matrix1.M33 * matrix2.M31);
Fix64 num7 = ((matrix1.M31 * matrix2.M12) + (matrix1.M32 * matrix2.M22)) + (matrix1.M33 * matrix2.M32);
Fix64 num8 = ((matrix1.M31 * matrix2.M13) + (matrix1.M32 * matrix2.M23)) + (matrix1.M33 * matrix2.M33);
result.M11 = num0;
result.M12 = num1;
result.M13 = num2;
result.M21 = num3;
result.M22 = num4;
result.M23 = num5;
result.M31 = num6;
result.M32 = num7;
result.M33 = num8;
}
/// <summary>
/// Creates a matrix which rotates around the given axis by the given angle.
/// </summary>
/// <param name="axis">The axis.</param>
/// <param name="angle">The angle.</param>
/// <param name="result">The resulting rotation matrix</param>
#region public static void CreateFromAxisAngle(ref JVector axis, Fix64 angle, out JMatrix result)
public static void CreateFromAxisAngle(ref FixVector3 axis, Fix64 angle, out FixMatrix result)
{
Fix64 x = axis.x;
Fix64 y = axis.y;
Fix64 z = axis.z;
Fix64 num2 = Fix64.Sin(angle);
Fix64 num = Fix64.Cos(angle);
Fix64 num11 = x * x;
Fix64 num10 = y * y;
Fix64 num9 = z * z;
Fix64 num8 = x * y;
Fix64 num7 = x * z;
Fix64 num6 = y * z;
result.M11 = num11 + (num * (Fix64.One - num11));
result.M12 = (num8 - (num * num8)) + (num2 * z);
result.M13 = (num7 - (num * num7)) - (num2 * y);
result.M21 = (num8 - (num * num8)) - (num2 * z);
result.M22 = num10 + (num * (Fix64.One - num10));
result.M23 = (num6 - (num * num6)) + (num2 * x);
result.M31 = (num7 - (num * num7)) + (num2 * y);
result.M32 = (num6 - (num * num6)) - (num2 * x);
result.M33 = num9 + (num * (Fix64.One - num9));
}
/// <summary>
/// Calculates the inverse of a give matrix.
/// </summary>
/// <param name="matrix">The matrix to invert.</param>
/// <returns>The inverted JMatrix.</returns>
#region public static JMatrix Inverse(JMatrix matrix)
public static FixMatrix Inverse(FixMatrix matrix)
{
FixMatrix.Inverse(ref matrix, out FixMatrix result);
return(result);
}
/// <summary>
/// Subtracts two matrices.
/// </summary>
/// <param name="value1">The first matrix.</param>
/// <param name="value2">The second matrix.</param>
/// <returns>The difference of both values.</returns>
#region public static JMatrix operator -(JMatrix value1, JMatrix value2)
public static FixMatrix operator -(FixMatrix value1, FixMatrix value2)
{
FixMatrix.Multiply(ref value2, -Fix64.One, out value2);
FixMatrix.Add(ref value1, ref value2, out FixMatrix result);
return(result);
}
public void TestObjects()
{
Assert.AreEqual(5, level.Objects.Count);
// Player
Assert.AreEqual(ObjectType.Player, level.Objects[0].Type);
Assert.AreEqual(0, level.Objects[0].SubtypeID);
Assert.AreEqual(MovementTypeID.Physics, level.Objects[0].MoveTypeID);
Assert.AreEqual(ControlTypeID.Slew, level.Objects[0].ControlTypeID);
Assert.AreEqual(RenderTypeID.Polyobj, level.Objects[0].RenderTypeID);
Assert.AreEqual(new FixVector(0, -10, -70), level.Objects[0].Position);
// Point directly forward
var expectedOrientation = new FixMatrix(new FixVector(1, 0, 0), new FixVector(0, 1, 0), new FixVector(0, 0, 1));
Assert.AreEqual(expectedOrientation, level.Objects[0].Orientation);
Assert.IsTrue(level.Objects[0].RenderType is PolymodelRenderType);
Assert.AreEqual(43, ((PolymodelRenderType)level.Objects[0].RenderType).ModelNum);
Assert.AreEqual(0, level.Objects[0].Segnum);
// Powerup
Assert.AreEqual(ObjectType.Powerup, level.Objects[1].Type);
Assert.AreEqual(5, level.Objects[1].SubtypeID); // red key
Assert.AreEqual(MovementTypeID.None, level.Objects[1].MoveTypeID);
Assert.AreEqual(ControlTypeID.Powerup, level.Objects[1].ControlTypeID);
Assert.AreEqual(RenderTypeID.Powerup, level.Objects[1].RenderTypeID);
Assert.AreEqual(new FixVector(-80, -10, 10), level.Objects[1].Position);
Assert.AreEqual(expectedOrientation, level.Objects[1].Orientation);
Assert.AreEqual(11, level.Objects[1].Segnum);
// Reactor
Assert.AreEqual(ObjectType.ControlCenter, level.Objects[2].Type);
Assert.AreEqual(0, level.Objects[2].SubtypeID);
Assert.AreEqual(MovementTypeID.None, level.Objects[2].MoveTypeID);
Assert.AreEqual(ControlTypeID.ControlCenter, level.Objects[2].ControlTypeID);
Assert.AreEqual(RenderTypeID.Polyobj, level.Objects[2].RenderTypeID);
Assert.AreEqual(new FixVector(40, -10, 50), level.Objects[2].Position);
Assert.AreEqual(expectedOrientation, level.Objects[2].Orientation);
Assert.IsTrue(level.Objects[2].RenderType is PolymodelRenderType);
Assert.AreEqual(39, ((PolymodelRenderType)level.Objects[2].RenderType).ModelNum);
Assert.AreEqual(14, level.Objects[2].Segnum);
// Hostage
Assert.AreEqual(ObjectType.Hostage, level.Objects[3].Type);
Assert.AreEqual(0, level.Objects[3].SubtypeID);
Assert.AreEqual(MovementTypeID.None, level.Objects[3].MoveTypeID);
Assert.AreEqual(ControlTypeID.Powerup, level.Objects[3].ControlTypeID);
Assert.AreEqual(RenderTypeID.Hostage, level.Objects[3].RenderTypeID);
Assert.AreEqual(new FixVector(80, -15, 10), level.Objects[3].Position);
Assert.AreEqual(expectedOrientation, level.Objects[3].Orientation);
Assert.IsTrue(level.Objects[3].RenderType is HostageRenderType);
Assert.AreEqual(33, ((HostageRenderType)level.Objects[3].RenderType).VClipNum);
Assert.AreEqual(15, level.Objects[3].Segnum);
// Robot
Assert.AreEqual(ObjectType.Robot, level.Objects[4].Type);
Assert.AreEqual(0, level.Objects[4].SubtypeID); // medium hulk
Assert.AreEqual(MovementTypeID.Physics, level.Objects[4].MoveTypeID);
Assert.AreEqual(ControlTypeID.AI, level.Objects[4].ControlTypeID);
Assert.AreEqual(RenderTypeID.Polyobj, level.Objects[4].RenderTypeID);
Assert.AreEqual(new FixVector(40, -10, -30), level.Objects[4].Position);
Assert.AreEqual(expectedOrientation, level.Objects[4].Orientation);
// Physics info seems to be blank, probably initialized from HAM/HXM data
Assert.AreEqual((Fix)0, ((PhysicsMoveType)level.Objects[4].MoveType).Mass);
Assert.AreEqual((Fix)0, ((PhysicsMoveType)level.Objects[4].MoveType).Drag);
Assert.AreEqual((PhysicsFlags)0, ((PhysicsMoveType)level.Objects[4].MoveType).Flags);
Assert.AreEqual((Fix)100, level.Objects[4].Shields);
Assert.AreEqual((ObjectType)7, level.Objects[4].ContainsType); // powerup
Assert.AreEqual(1, level.Objects[4].ContainsCount);
Assert.AreEqual(11, level.Objects[4].ContainsId); // 4-pack conc
Assert.AreEqual(0, ((PolymodelRenderType)level.Objects[4].RenderType).ModelNum);
Assert.AreEqual(16, level.Objects[4].Segnum);
}
/// <summary>
/// Creates the transposed matrix.
/// </summary>
/// <param name="matrix">The matrix which should be transposed.</param>
/// <returns>The transposed JMatrix.</returns>
#region public static JMatrix Transpose(JMatrix matrix)
public static FixMatrix Transpose(FixMatrix matrix)
{
FixMatrix.Transpose(ref matrix, out FixMatrix result);
return(result);
}
/// <summary>
/// Gets the determinant of the matrix.
/// </summary>
/// <returns>The determinant of the matrix.</returns>
#region public Fix64 Determinant()
//public Fix64 Determinant()
//{
// return M11 * M22 * M33 -M11 * M23 * M32 -M12 * M21 * M33 +M12 * M23 * M31 + M13 * M21 * M32 - M13 * M22 * M31;
//}
#endregion
/// <summary>
/// Multiply two matrices. Notice: matrix multiplication is not commutative.
/// </summary>
/// <param name="matrix1">The first matrix.</param>
/// <param name="matrix2">The second matrix.</param>
/// <returns>The product of both matrices.</returns>
#region public static JMatrix Multiply(JMatrix matrix1, JMatrix matrix2)
public static FixMatrix Multiply(FixMatrix matrix1, FixMatrix matrix2)
{
FixMatrix.Multiply(ref matrix1, ref matrix2, out FixMatrix result);
return(result);
}
/// <summary>
/// Multiply a matrix by a scalefactor.
/// </summary>
/// <param name="matrix1">The matrix.</param>
/// <param name="scaleFactor">The scale factor.</param>
/// <returns>A JMatrix multiplied by the scale factor.</returns>
#region public static JMatrix Multiply(JMatrix matrix1, Fix64 scaleFactor)
public static FixMatrix Multiply(FixMatrix matrix1, Fix64 scaleFactor)
{
FixMatrix.Multiply(ref matrix1, scaleFactor, out FixMatrix result);
return(result);
}
public static FixQuaternion LookRotation(FixVector3 forward, FixVector3 upwards)
{
return(CreateFromMatrix(FixMatrix.LookAt(forward, upwards)));
}
/// <summary>
/// Creates a quaternion from a matrix.
/// </summary>
/// <param name="matrix">A matrix representing an orientation.</param>
/// <returns>JQuaternion representing an orientation.</returns>
#region public static JQuaternion CreateFromMatrix(JMatrix matrix)
public static FixQuaternion CreateFromMatrix(FixMatrix matrix)
{
FixQuaternion.CreateFromMatrix(ref matrix, out FixQuaternion result);
return(result);
}
/// <summary>
/// Matrices are added.
/// </summary>
/// <param name="matrix1">The first matrix.</param>
/// <param name="matrix2">The second matrix.</param>
/// <returns>The sum of both matrices.</returns>
#region public static JMatrix Add(JMatrix matrix1, JMatrix matrix2)
public static FixMatrix Add(FixMatrix matrix1, FixMatrix matrix2)
{
FixMatrix.Add(ref matrix1, ref matrix2, out FixMatrix result);
return(result);
}
public void TestObjects()
{
Assert.AreEqual(28, level.Objects.Count);
// Object 0 - player
Assert.AreEqual(ObjectType.Player, level.Objects[0].Type);
Assert.AreEqual(0, level.Objects[0].SubtypeID);
Assert.AreEqual(MovementTypeID.Physics, level.Objects[0].MoveTypeID);
Assert.AreEqual(ControlTypeID.Slew, level.Objects[0].ControlTypeID);
Assert.AreEqual(RenderTypeID.Polyobj, level.Objects[0].RenderTypeID);
Assert.AreEqual(new FixVector(0, 0, 0), level.Objects[0].Position);
var expectedOrientation = new FixMatrix(new FixVector(1, 0, 0), new FixVector(0, 1, 0), new FixVector(0, 0, 1));
Assert.AreEqual(expectedOrientation, level.Objects[0].Orientation);
Assert.AreEqual(108, ((PolymodelRenderType)level.Objects[0].RenderType).ModelNum);
Assert.AreEqual(0, level.Objects[0].Segnum);
// Object 1 - reactor
Assert.AreEqual(ObjectType.ControlCenter, level.Objects[1].Type);
Assert.AreEqual(2, level.Objects[1].SubtypeID);
Assert.AreEqual(MovementTypeID.None, level.Objects[1].MoveTypeID);
Assert.AreEqual(ControlTypeID.ControlCenter, level.Objects[1].ControlTypeID);
Assert.AreEqual(RenderTypeID.Polyobj, level.Objects[1].RenderTypeID);
Assert.AreEqual(new FixVector(50, -20, -95), level.Objects[1].Position);
Assert.AreEqual(expectedOrientation, level.Objects[1].Orientation);
Assert.AreEqual(97, ((PolymodelRenderType)level.Objects[1].RenderType).ModelNum);
Assert.AreEqual(74, level.Objects[1].Segnum);
// Object 3 - hostage
Assert.AreEqual(ObjectType.Hostage, level.Objects[3].Type);
Assert.AreEqual(0, level.Objects[3].SubtypeID);
Assert.AreEqual(MovementTypeID.None, level.Objects[3].MoveTypeID);
Assert.AreEqual(ControlTypeID.Powerup, level.Objects[3].ControlTypeID);
Assert.AreEqual(RenderTypeID.Hostage, level.Objects[3].RenderTypeID);
Assert.AreEqual(new FixVector(45, -65, 30), level.Objects[3].Position);
Assert.AreEqual(expectedOrientation, level.Objects[3].Orientation);
Assert.AreEqual(33, ((HostageRenderType)level.Objects[3].RenderType).VClipNum);
Assert.AreEqual(39, level.Objects[3].Segnum);
// Object 6 - co-op player
Assert.AreEqual(ObjectType.Coop, level.Objects[6].Type);
Assert.AreEqual(8, level.Objects[6].SubtypeID);
Assert.AreEqual(MovementTypeID.Physics, level.Objects[6].MoveTypeID);
Assert.AreEqual(ControlTypeID.None, level.Objects[6].ControlTypeID);
Assert.AreEqual(RenderTypeID.Polyobj, level.Objects[6].RenderTypeID);
Assert.AreEqual(new FixVector(20, 0, 40), level.Objects[6].Position);
expectedOrientation = new FixMatrix(new FixVector(0, 0, 1), new FixVector(0, 1, 0), new FixVector(-1, 0, 0));
Assert.AreEqual(expectedOrientation, level.Objects[6].Orientation);
Assert.AreEqual(108, ((PolymodelRenderType)level.Objects[6].RenderType).ModelNum);
Assert.AreEqual(5, level.Objects[6].Segnum);
// Object 9 - Guide-bot
Assert.AreEqual(ObjectType.Robot, level.Objects[9].Type);
Assert.AreEqual(33, level.Objects[9].SubtypeID);
Assert.AreEqual(MovementTypeID.Physics, level.Objects[9].MoveTypeID);
Assert.AreEqual(ControlTypeID.AI, level.Objects[9].ControlTypeID);
Assert.AreEqual(RenderTypeID.Polyobj, level.Objects[9].RenderTypeID);
Assert.AreEqual(new FixVector(0, 30, 120), level.Objects[9].Position);
expectedOrientation = new FixMatrix(new FixVector(1, 0, 0), new FixVector(0, 1, 0), new FixVector(0, 0, 1));
Assert.AreEqual(expectedOrientation, level.Objects[9].Orientation);
Assert.AreEqual(51, ((PolymodelRenderType)level.Objects[9].RenderType).ModelNum);
Assert.AreEqual(15, level.Objects[9].Segnum);
// Object 21 - robot (Sidearm) with contained robots
Assert.AreEqual(ObjectType.Robot, level.Objects[21].Type);
Assert.AreEqual(30, level.Objects[21].SubtypeID);
Assert.AreEqual(MovementTypeID.Physics, level.Objects[21].MoveTypeID);
Assert.AreEqual(ControlTypeID.AI, level.Objects[21].ControlTypeID);
Assert.AreEqual(RenderTypeID.Polyobj, level.Objects[21].RenderTypeID);
Assert.AreEqual(new FixVector(120, -20, -105), level.Objects[21].Position);
Assert.AreEqual(expectedOrientation, level.Objects[21].Orientation);
Assert.AreEqual((Fix)120, level.Objects[21].Shields);
Assert.AreEqual((ObjectType)2, level.Objects[21].ContainsType); // robot
Assert.AreEqual(4, level.Objects[21].ContainsCount);
Assert.AreEqual(50, level.Objects[21].ContainsId); // sidearm modula
Assert.AreEqual(47, ((PolymodelRenderType)level.Objects[21].RenderType).ModelNum);
Assert.AreEqual(61, level.Objects[21].Segnum);
// Object 25 - blue flag
Assert.AreEqual(ObjectType.Powerup, level.Objects[25].Type);
Assert.AreEqual(46, level.Objects[25].SubtypeID);
Assert.AreEqual(MovementTypeID.None, level.Objects[25].MoveTypeID);
Assert.AreEqual(ControlTypeID.Powerup, level.Objects[25].ControlTypeID);
Assert.AreEqual(RenderTypeID.Powerup, level.Objects[25].RenderTypeID);
Assert.AreEqual(new FixVector(120, -20, 10), level.Objects[25].Position);
Assert.AreEqual(expectedOrientation, level.Objects[25].Orientation);
Assert.AreEqual(42, level.Objects[25].Segnum);
}
/// <summary>
/// Transforms a vector by the given matrix.
/// </summary>
/// <param name="position">The vector to transform.</param>
/// <param name="matrix">The transform matrix.</param>
/// <returns>The transformed vector.</returns>
#region public static JVector Transform(JVector position, JMatrix matrix)
public static FixVector3 Transform(FixVector3 position, FixMatrix matrix)
{
FixVector3.Transform(ref position, ref matrix, out FixVector3 result);
return(result);
}
