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); }