Simplify math codebase
This commit is contained in:
Wojtek Figat
@@ -40,9 +40,7 @@ float Matrix::GetDeterminant() const
|
||||
const float temp4 = M31 * M44 - M34 * M41;
|
||||
const float temp5 = M31 * M43 - M33 * M41;
|
||||
const float temp6 = M31 * M42 - M32 * M41;
|
||||
return M11 * (M22 * temp1 - M23 * temp2 + M24 * temp3) - M12 * (M21 * temp1 -
|
||||
M23 * temp4 + M24 * temp5) + M13 * (M21 * temp2 - M22 * temp4 + M24 * temp6) -
|
||||
M14 * (M21 * temp3 - M22 * temp5 + M23 * temp6);
|
||||
return M11 * (M22 * temp1 - M23 * temp2 + M24 * temp3) - M12 * (M21 * temp1 -M23 * temp4 + M24 * temp5) + M13 * (M21 * temp2 - M22 * temp4 + M24 * temp6) - M14 * (M21 * temp3 - M22 * temp5 + M23 * temp6);
|
||||
}
|
||||
|
||||
float Matrix::RotDeterminant() const
|
||||
@@ -153,6 +151,179 @@ void Matrix::Decompose(Float3& scale, Matrix& rotation, Float3& translation) con
|
||||
rotation = Matrix(r);
|
||||
}
|
||||
|
||||
bool Matrix::operator==(const Matrix& other) const
|
||||
{
|
||||
for (int32 i = 0; i < 16; i++)
|
||||
{
|
||||
if (Math::NotNearEqual(other.Raw[i], Raw[i]))
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void Matrix::Add(const Matrix& left, const Matrix& right, Matrix& result)
|
||||
{
|
||||
result.M11 = left.M11 + right.M11;
|
||||
result.M12 = left.M12 + right.M12;
|
||||
result.M13 = left.M13 + right.M13;
|
||||
result.M14 = left.M14 + right.M14;
|
||||
result.M21 = left.M21 + right.M21;
|
||||
result.M22 = left.M22 + right.M22;
|
||||
result.M23 = left.M23 + right.M23;
|
||||
result.M24 = left.M24 + right.M24;
|
||||
result.M31 = left.M31 + right.M31;
|
||||
result.M32 = left.M32 + right.M32;
|
||||
result.M33 = left.M33 + right.M33;
|
||||
result.M34 = left.M34 + right.M34;
|
||||
result.M41 = left.M41 + right.M41;
|
||||
result.M42 = left.M42 + right.M42;
|
||||
result.M43 = left.M43 + right.M43;
|
||||
result.M44 = left.M44 + right.M44;
|
||||
}
|
||||
|
||||
void Matrix::Subtract(const Matrix& left, const Matrix& right, Matrix& result)
|
||||
{
|
||||
result.M11 = left.M11 - right.M11;
|
||||
result.M12 = left.M12 - right.M12;
|
||||
result.M13 = left.M13 - right.M13;
|
||||
result.M14 = left.M14 - right.M14;
|
||||
result.M21 = left.M21 - right.M21;
|
||||
result.M22 = left.M22 - right.M22;
|
||||
result.M23 = left.M23 - right.M23;
|
||||
result.M24 = left.M24 - right.M24;
|
||||
result.M31 = left.M31 - right.M31;
|
||||
result.M32 = left.M32 - right.M32;
|
||||
result.M33 = left.M33 - right.M33;
|
||||
result.M34 = left.M34 - right.M34;
|
||||
result.M41 = left.M41 - right.M41;
|
||||
result.M42 = left.M42 - right.M42;
|
||||
result.M43 = left.M43 - right.M43;
|
||||
result.M44 = left.M44 - right.M44;
|
||||
}
|
||||
|
||||
void Matrix::Multiply(const Matrix& left, float right, Matrix& result)
|
||||
{
|
||||
result.M11 = left.M11 * right;
|
||||
result.M12 = left.M12 * right;
|
||||
result.M13 = left.M13 * right;
|
||||
result.M14 = left.M14 * right;
|
||||
result.M21 = left.M21 * right;
|
||||
result.M22 = left.M22 * right;
|
||||
result.M23 = left.M23 * right;
|
||||
result.M24 = left.M24 * right;
|
||||
result.M31 = left.M31 * right;
|
||||
result.M32 = left.M32 * right;
|
||||
result.M33 = left.M33 * right;
|
||||
result.M34 = left.M34 * right;
|
||||
result.M41 = left.M41 * right;
|
||||
result.M42 = left.M42 * right;
|
||||
result.M43 = left.M43 * right;
|
||||
result.M44 = left.M44 * right;
|
||||
}
|
||||
|
||||
void Matrix::Multiply(const Matrix& left, const Matrix& right, Matrix& result)
|
||||
{
|
||||
result.M11 = left.M11 * right.M11 + left.M12 * right.M21 + left.M13 * right.M31 + left.M14 * right.M41;
|
||||
result.M12 = left.M11 * right.M12 + left.M12 * right.M22 + left.M13 * right.M32 + left.M14 * right.M42;
|
||||
result.M13 = left.M11 * right.M13 + left.M12 * right.M23 + left.M13 * right.M33 + left.M14 * right.M43;
|
||||
result.M14 = left.M11 * right.M14 + left.M12 * right.M24 + left.M13 * right.M34 + left.M14 * right.M44;
|
||||
result.M21 = left.M21 * right.M11 + left.M22 * right.M21 + left.M23 * right.M31 + left.M24 * right.M41;
|
||||
result.M22 = left.M21 * right.M12 + left.M22 * right.M22 + left.M23 * right.M32 + left.M24 * right.M42;
|
||||
result.M23 = left.M21 * right.M13 + left.M22 * right.M23 + left.M23 * right.M33 + left.M24 * right.M43;
|
||||
result.M24 = left.M21 * right.M14 + left.M22 * right.M24 + left.M23 * right.M34 + left.M24 * right.M44;
|
||||
result.M31 = left.M31 * right.M11 + left.M32 * right.M21 + left.M33 * right.M31 + left.M34 * right.M41;
|
||||
result.M32 = left.M31 * right.M12 + left.M32 * right.M22 + left.M33 * right.M32 + left.M34 * right.M42;
|
||||
result.M33 = left.M31 * right.M13 + left.M32 * right.M23 + left.M33 * right.M33 + left.M34 * right.M43;
|
||||
result.M34 = left.M31 * right.M14 + left.M32 * right.M24 + left.M33 * right.M34 + left.M34 * right.M44;
|
||||
result.M41 = left.M41 * right.M11 + left.M42 * right.M21 + left.M43 * right.M31 + left.M44 * right.M41;
|
||||
result.M42 = left.M41 * right.M12 + left.M42 * right.M22 + left.M43 * right.M32 + left.M44 * right.M42;
|
||||
result.M43 = left.M41 * right.M13 + left.M42 * right.M23 + left.M43 * right.M33 + left.M44 * right.M43;
|
||||
result.M44 = left.M41 * right.M14 + left.M42 * right.M24 + left.M43 * right.M34 + left.M44 * right.M44;
|
||||
}
|
||||
|
||||
void Matrix::Divide(const Matrix& left, float right, Matrix& result)
|
||||
{
|
||||
ASSERT(!Math::IsZero(right));
|
||||
const float inv = 1.0f / right;
|
||||
|
||||
result.M11 = left.M11 * inv;
|
||||
result.M12 = left.M12 * inv;
|
||||
result.M13 = left.M13 * inv;
|
||||
result.M14 = left.M14 * inv;
|
||||
result.M21 = left.M21 * inv;
|
||||
result.M22 = left.M22 * inv;
|
||||
result.M23 = left.M23 * inv;
|
||||
result.M24 = left.M24 * inv;
|
||||
result.M31 = left.M31 * inv;
|
||||
result.M32 = left.M32 * inv;
|
||||
result.M33 = left.M33 * inv;
|
||||
result.M34 = left.M34 * inv;
|
||||
result.M41 = left.M41 * inv;
|
||||
result.M42 = left.M42 * inv;
|
||||
result.M43 = left.M43 * inv;
|
||||
result.M44 = left.M44 * inv;
|
||||
}
|
||||
|
||||
void Matrix::Divide(const Matrix& left, const Matrix& right, Matrix& result)
|
||||
{
|
||||
result.M11 = left.M11 / right.M11;
|
||||
result.M12 = left.M12 / right.M12;
|
||||
result.M13 = left.M13 / right.M13;
|
||||
result.M14 = left.M14 / right.M14;
|
||||
result.M21 = left.M21 / right.M21;
|
||||
result.M22 = left.M22 / right.M22;
|
||||
result.M23 = left.M23 / right.M23;
|
||||
result.M24 = left.M24 / right.M24;
|
||||
result.M31 = left.M31 / right.M31;
|
||||
result.M32 = left.M32 / right.M32;
|
||||
result.M33 = left.M33 / right.M33;
|
||||
result.M34 = left.M34 / right.M34;
|
||||
result.M41 = left.M41 / right.M41;
|
||||
result.M42 = left.M42 / right.M42;
|
||||
result.M43 = left.M43 / right.M43;
|
||||
result.M44 = left.M44 / right.M44;
|
||||
}
|
||||
|
||||
void Matrix::Negate(const Matrix& value, Matrix& result)
|
||||
{
|
||||
result.M11 = -value.M11;
|
||||
result.M12 = -value.M12;
|
||||
result.M13 = -value.M13;
|
||||
result.M14 = -value.M14;
|
||||
result.M21 = -value.M21;
|
||||
result.M22 = -value.M22;
|
||||
result.M23 = -value.M23;
|
||||
result.M24 = -value.M24;
|
||||
result.M31 = -value.M31;
|
||||
result.M32 = -value.M32;
|
||||
result.M33 = -value.M33;
|
||||
result.M34 = -value.M34;
|
||||
result.M41 = -value.M41;
|
||||
result.M42 = -value.M42;
|
||||
result.M43 = -value.M43;
|
||||
result.M44 = -value.M44;
|
||||
}
|
||||
|
||||
void Matrix::Lerp(const Matrix& start, const Matrix& end, float amount, Matrix& result)
|
||||
{
|
||||
result.M11 = Math::Lerp(start.M11, end.M11, amount);
|
||||
result.M12 = Math::Lerp(start.M12, end.M12, amount);
|
||||
result.M13 = Math::Lerp(start.M13, end.M13, amount);
|
||||
result.M14 = Math::Lerp(start.M14, end.M14, amount);
|
||||
result.M21 = Math::Lerp(start.M21, end.M21, amount);
|
||||
result.M22 = Math::Lerp(start.M22, end.M22, amount);
|
||||
result.M23 = Math::Lerp(start.M23, end.M23, amount);
|
||||
result.M24 = Math::Lerp(start.M24, end.M24, amount);
|
||||
result.M31 = Math::Lerp(start.M31, end.M31, amount);
|
||||
result.M32 = Math::Lerp(start.M32, end.M32, amount);
|
||||
result.M33 = Math::Lerp(start.M33, end.M33, amount);
|
||||
result.M34 = Math::Lerp(start.M34, end.M34, amount);
|
||||
result.M41 = Math::Lerp(start.M41, end.M41, amount);
|
||||
result.M42 = Math::Lerp(start.M42, end.M42, amount);
|
||||
result.M43 = Math::Lerp(start.M43, end.M43, amount);
|
||||
result.M44 = Math::Lerp(start.M44, end.M44, amount);
|
||||
}
|
||||
|
||||
Matrix Matrix::Transpose(const Matrix& value)
|
||||
{
|
||||
Matrix result;
|
||||
@@ -688,6 +859,15 @@ void Matrix::CreateFromAxisAngle(const Float3& axis, float angle, Matrix& result
|
||||
result.M44 = 1.0f;
|
||||
}
|
||||
|
||||
Vector3 Matrix::TransformVector(const Matrix& m, const Vector3& v)
|
||||
{
|
||||
return Vector3(
|
||||
m.Values[0][0] * v.Raw[0] + m.Values[1][0] * v.Raw[1] + m.Values[2][0] * v.Raw[2],
|
||||
m.Values[0][1] * v.Raw[0] + m.Values[1][1] * v.Raw[1] + m.Values[2][1] * v.Raw[2],
|
||||
m.Values[0][2] * v.Raw[0] + m.Values[1][2] * v.Raw[1] + m.Values[2][2] * v.Raw[2]
|
||||
);
|
||||
}
|
||||
|
||||
Float4 Matrix::TransformPosition(const Matrix& m, const Float3& v)
|
||||
{
|
||||
return Float4(
|
||||
|
||||
@@ -523,24 +523,10 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool operator==(const Matrix& other) const
|
||||
{
|
||||
for (int32 i = 0; i < 16; i++)
|
||||
{
|
||||
if (Math::NotNearEqual(other.Raw[i], Raw[i]))
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool operator==(const Matrix& other) const;
|
||||
bool operator!=(const Matrix& other) const
|
||||
{
|
||||
for (int32 i = 0; i < 16; i++)
|
||||
{
|
||||
if (Math::NotNearEqual(other.Raw[i], Raw[i]))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
return !operator==(other);
|
||||
}
|
||||
|
||||
public:
|
||||
@@ -548,73 +534,19 @@ public:
|
||||
// @param left The first matrix to add.
|
||||
// @param right The second matrix to add.
|
||||
// @param result When the method completes, contains the sum of the two matrices.
|
||||
static void Add(const Matrix& left, const Matrix& right, Matrix& result)
|
||||
{
|
||||
result.M11 = left.M11 + right.M11;
|
||||
result.M12 = left.M12 + right.M12;
|
||||
result.M13 = left.M13 + right.M13;
|
||||
result.M14 = left.M14 + right.M14;
|
||||
result.M21 = left.M21 + right.M21;
|
||||
result.M22 = left.M22 + right.M22;
|
||||
result.M23 = left.M23 + right.M23;
|
||||
result.M24 = left.M24 + right.M24;
|
||||
result.M31 = left.M31 + right.M31;
|
||||
result.M32 = left.M32 + right.M32;
|
||||
result.M33 = left.M33 + right.M33;
|
||||
result.M34 = left.M34 + right.M34;
|
||||
result.M41 = left.M41 + right.M41;
|
||||
result.M42 = left.M42 + right.M42;
|
||||
result.M43 = left.M43 + right.M43;
|
||||
result.M44 = left.M44 + right.M44;
|
||||
}
|
||||
static void Add(const Matrix& left, const Matrix& right, Matrix& result);
|
||||
|
||||
// Calculates the difference between two matrices.
|
||||
// @param left The first matrix to subtract.
|
||||
// @param right The second matrix to subtract.
|
||||
// @param result When the method completes, contains the difference between the two matrices.
|
||||
static void Subtract(const Matrix& left, const Matrix& right, Matrix& result)
|
||||
{
|
||||
result.M11 = left.M11 - right.M11;
|
||||
result.M12 = left.M12 - right.M12;
|
||||
result.M13 = left.M13 - right.M13;
|
||||
result.M14 = left.M14 - right.M14;
|
||||
result.M21 = left.M21 - right.M21;
|
||||
result.M22 = left.M22 - right.M22;
|
||||
result.M23 = left.M23 - right.M23;
|
||||
result.M24 = left.M24 - right.M24;
|
||||
result.M31 = left.M31 - right.M31;
|
||||
result.M32 = left.M32 - right.M32;
|
||||
result.M33 = left.M33 - right.M33;
|
||||
result.M34 = left.M34 - right.M34;
|
||||
result.M41 = left.M41 - right.M41;
|
||||
result.M42 = left.M42 - right.M42;
|
||||
result.M43 = left.M43 - right.M43;
|
||||
result.M44 = left.M44 - right.M44;
|
||||
}
|
||||
static void Subtract(const Matrix& left, const Matrix& right, Matrix& result);
|
||||
|
||||
// Scales a matrix by the given value.
|
||||
// @param left The matrix to scale.
|
||||
// @param right The amount by which to scale.
|
||||
// @param result When the method completes, contains the scaled matrix.
|
||||
static void Multiply(const Matrix& left, float right, Matrix& result)
|
||||
{
|
||||
result.M11 = left.M11 * right;
|
||||
result.M12 = left.M12 * right;
|
||||
result.M13 = left.M13 * right;
|
||||
result.M14 = left.M14 * right;
|
||||
result.M21 = left.M21 * right;
|
||||
result.M22 = left.M22 * right;
|
||||
result.M23 = left.M23 * right;
|
||||
result.M24 = left.M24 * right;
|
||||
result.M31 = left.M31 * right;
|
||||
result.M32 = left.M32 * right;
|
||||
result.M33 = left.M33 * right;
|
||||
result.M34 = left.M34 * right;
|
||||
result.M41 = left.M41 * right;
|
||||
result.M42 = left.M42 * right;
|
||||
result.M43 = left.M43 * right;
|
||||
result.M44 = left.M44 * right;
|
||||
}
|
||||
static void Multiply(const Matrix& left, float right, Matrix& result);
|
||||
|
||||
// Calculates the product of two matrices.
|
||||
// @param left The first matrix to multiply.
|
||||
@@ -631,124 +563,31 @@ public:
|
||||
// @param left The first matrix to multiply.
|
||||
// @param right The second matrix to multiply.
|
||||
// @param result The product of the two matrices.
|
||||
static void Multiply(const Matrix& left, const Matrix& right, Matrix& result)
|
||||
{
|
||||
result.M11 = left.M11 * right.M11 + left.M12 * right.M21 + left.M13 * right.M31 + left.M14 * right.M41;
|
||||
result.M12 = left.M11 * right.M12 + left.M12 * right.M22 + left.M13 * right.M32 + left.M14 * right.M42;
|
||||
result.M13 = left.M11 * right.M13 + left.M12 * right.M23 + left.M13 * right.M33 + left.M14 * right.M43;
|
||||
result.M14 = left.M11 * right.M14 + left.M12 * right.M24 + left.M13 * right.M34 + left.M14 * right.M44;
|
||||
result.M21 = left.M21 * right.M11 + left.M22 * right.M21 + left.M23 * right.M31 + left.M24 * right.M41;
|
||||
result.M22 = left.M21 * right.M12 + left.M22 * right.M22 + left.M23 * right.M32 + left.M24 * right.M42;
|
||||
result.M23 = left.M21 * right.M13 + left.M22 * right.M23 + left.M23 * right.M33 + left.M24 * right.M43;
|
||||
result.M24 = left.M21 * right.M14 + left.M22 * right.M24 + left.M23 * right.M34 + left.M24 * right.M44;
|
||||
result.M31 = left.M31 * right.M11 + left.M32 * right.M21 + left.M33 * right.M31 + left.M34 * right.M41;
|
||||
result.M32 = left.M31 * right.M12 + left.M32 * right.M22 + left.M33 * right.M32 + left.M34 * right.M42;
|
||||
result.M33 = left.M31 * right.M13 + left.M32 * right.M23 + left.M33 * right.M33 + left.M34 * right.M43;
|
||||
result.M34 = left.M31 * right.M14 + left.M32 * right.M24 + left.M33 * right.M34 + left.M34 * right.M44;
|
||||
result.M41 = left.M41 * right.M11 + left.M42 * right.M21 + left.M43 * right.M31 + left.M44 * right.M41;
|
||||
result.M42 = left.M41 * right.M12 + left.M42 * right.M22 + left.M43 * right.M32 + left.M44 * right.M42;
|
||||
result.M43 = left.M41 * right.M13 + left.M42 * right.M23 + left.M43 * right.M33 + left.M44 * right.M43;
|
||||
result.M44 = left.M41 * right.M14 + left.M42 * right.M24 + left.M43 * right.M34 + left.M44 * right.M44;
|
||||
}
|
||||
static void Multiply(const Matrix& left, const Matrix& right, Matrix& result);
|
||||
|
||||
// Scales a matrix by the given value.
|
||||
// @param left The matrix to scale.
|
||||
// @param right The amount by which to scale.
|
||||
// @param result When the method completes, contains the scaled matrix.
|
||||
static void Divide(const Matrix& left, float right, Matrix& result)
|
||||
{
|
||||
ASSERT(!Math::IsZero(right));
|
||||
const float inv = 1.0f / right;
|
||||
|
||||
result.M11 = left.M11 * inv;
|
||||
result.M12 = left.M12 * inv;
|
||||
result.M13 = left.M13 * inv;
|
||||
result.M14 = left.M14 * inv;
|
||||
result.M21 = left.M21 * inv;
|
||||
result.M22 = left.M22 * inv;
|
||||
result.M23 = left.M23 * inv;
|
||||
result.M24 = left.M24 * inv;
|
||||
result.M31 = left.M31 * inv;
|
||||
result.M32 = left.M32 * inv;
|
||||
result.M33 = left.M33 * inv;
|
||||
result.M34 = left.M34 * inv;
|
||||
result.M41 = left.M41 * inv;
|
||||
result.M42 = left.M42 * inv;
|
||||
result.M43 = left.M43 * inv;
|
||||
result.M44 = left.M44 * inv;
|
||||
}
|
||||
static void Divide(const Matrix& left, float right, Matrix& result);
|
||||
|
||||
// Calculates the quotient of two matrices.
|
||||
// @param left The first matrix to divide.
|
||||
// @param right The second matrix to divide.
|
||||
// @param result When the method completes, contains the quotient of the two matrices.
|
||||
static void Divide(const Matrix& left, const Matrix& right, Matrix& result)
|
||||
{
|
||||
result.M11 = left.M11 / right.M11;
|
||||
result.M12 = left.M12 / right.M12;
|
||||
result.M13 = left.M13 / right.M13;
|
||||
result.M14 = left.M14 / right.M14;
|
||||
result.M21 = left.M21 / right.M21;
|
||||
result.M22 = left.M22 / right.M22;
|
||||
result.M23 = left.M23 / right.M23;
|
||||
result.M24 = left.M24 / right.M24;
|
||||
result.M31 = left.M31 / right.M31;
|
||||
result.M32 = left.M32 / right.M32;
|
||||
result.M33 = left.M33 / right.M33;
|
||||
result.M34 = left.M34 / right.M34;
|
||||
result.M41 = left.M41 / right.M41;
|
||||
result.M42 = left.M42 / right.M42;
|
||||
result.M43 = left.M43 / right.M43;
|
||||
result.M44 = left.M44 / right.M44;
|
||||
}
|
||||
static void Divide(const Matrix& left, const Matrix& right, Matrix& result);
|
||||
|
||||
// Negates a matrix.
|
||||
// @param value The matrix to be negated.
|
||||
// @param result When the method completes, contains the negated matrix.
|
||||
static void Negate(const Matrix& value, Matrix& result)
|
||||
{
|
||||
result.M11 = -value.M11;
|
||||
result.M12 = -value.M12;
|
||||
result.M13 = -value.M13;
|
||||
result.M14 = -value.M14;
|
||||
result.M21 = -value.M21;
|
||||
result.M22 = -value.M22;
|
||||
result.M23 = -value.M23;
|
||||
result.M24 = -value.M24;
|
||||
result.M31 = -value.M31;
|
||||
result.M32 = -value.M32;
|
||||
result.M33 = -value.M33;
|
||||
result.M34 = -value.M34;
|
||||
result.M41 = -value.M41;
|
||||
result.M42 = -value.M42;
|
||||
result.M43 = -value.M43;
|
||||
result.M44 = -value.M44;
|
||||
}
|
||||
static void Negate(const Matrix& value, Matrix& result);
|
||||
|
||||
// Performs a linear interpolation between two matrices.
|
||||
// @param start Start matrix.
|
||||
// @param end End matrix.
|
||||
// @param amount Value between 0 and 1 indicating the weight of end.
|
||||
// @param result When the method completes, contains the linear interpolation of the two matrices.
|
||||
static void Lerp(const Matrix& start, const Matrix& end, float amount, Matrix& result)
|
||||
{
|
||||
result.M11 = Math::Lerp(start.M11, end.M11, amount);
|
||||
result.M12 = Math::Lerp(start.M12, end.M12, amount);
|
||||
result.M13 = Math::Lerp(start.M13, end.M13, amount);
|
||||
result.M14 = Math::Lerp(start.M14, end.M14, amount);
|
||||
result.M21 = Math::Lerp(start.M21, end.M21, amount);
|
||||
result.M22 = Math::Lerp(start.M22, end.M22, amount);
|
||||
result.M23 = Math::Lerp(start.M23, end.M23, amount);
|
||||
result.M24 = Math::Lerp(start.M24, end.M24, amount);
|
||||
result.M31 = Math::Lerp(start.M31, end.M31, amount);
|
||||
result.M32 = Math::Lerp(start.M32, end.M32, amount);
|
||||
result.M33 = Math::Lerp(start.M33, end.M33, amount);
|
||||
result.M34 = Math::Lerp(start.M34, end.M34, amount);
|
||||
result.M41 = Math::Lerp(start.M41, end.M41, amount);
|
||||
result.M42 = Math::Lerp(start.M42, end.M42, amount);
|
||||
result.M43 = Math::Lerp(start.M43, end.M43, amount);
|
||||
result.M44 = Math::Lerp(start.M44, end.M44, amount);
|
||||
}
|
||||
static void Lerp(const Matrix& start, const Matrix& end, float amount, Matrix& result);
|
||||
|
||||
// Performs a cubic interpolation between two matrices.
|
||||
// @param start Start matrix.
|
||||
@@ -1131,6 +970,7 @@ public:
|
||||
static void CreateFromAxisAngle(const Float3& axis, float angle, Matrix& result);
|
||||
|
||||
public:
|
||||
static Vector3 TransformVector(const Matrix& m, const Vector3& v);
|
||||
static Float4 TransformPosition(const Matrix& m, const Float3& v);
|
||||
static Float4 TransformPosition(const Matrix& m, const Float4& v);
|
||||
};
|
||||
|
||||
@@ -23,6 +23,11 @@ String Matrix3x3::ToString() const
|
||||
return String::Format(TEXT("{}"), *this);
|
||||
}
|
||||
|
||||
float Matrix3x3::GetDeterminant() const
|
||||
{
|
||||
return M11 * M22 * M33 + M12 * M23 * M31 + M13 * M21 * M32 - M13 * M22 * M31 - M12 * M21 * M33 - M11 * M23 * M32;
|
||||
}
|
||||
|
||||
void Matrix3x3::NormalizeScale()
|
||||
{
|
||||
const float scaleX = 1.0f / Float3(M11, M21, M31).Length();
|
||||
|
||||
@@ -312,10 +312,7 @@ public:
|
||||
/// <summary>
|
||||
/// Calculates the determinant of the Matrix3x3.
|
||||
/// </summary>
|
||||
float GetDeterminant() const
|
||||
{
|
||||
return M11 * M22 * M33 + M12 * M23 * M31 + M13 * M21 * M32 - M13 * M22 * M31 - M12 * M21 * M33 - M11 * M23 * M32;
|
||||
}
|
||||
float GetDeterminant() const;
|
||||
|
||||
public:
|
||||
/// <summary>
|
||||
@@ -352,7 +349,7 @@ public:
|
||||
/// </summary>
|
||||
/// <param name="value">The Matrix3x3 whose inverse is to be calculated.</param>
|
||||
/// <returns>The inverse of the specified Matrix3x3.</returns>
|
||||
static Matrix3x3 Invert(Matrix3x3 value)
|
||||
static Matrix3x3 Invert(const Matrix3x3& value)
|
||||
{
|
||||
Matrix3x3 result;
|
||||
Invert(value, result);
|
||||
|
||||
@@ -18,6 +18,16 @@ String Transform::ToString() const
|
||||
return String::Format(TEXT("{}"), *this);
|
||||
}
|
||||
|
||||
bool Transform::IsIdentity() const
|
||||
{
|
||||
return Translation.IsZero() && Orientation.IsIdentity() && Scale.IsOne();
|
||||
}
|
||||
|
||||
bool Transform::IsNanOrInfinity() const
|
||||
{
|
||||
return Translation.IsNanOrInfinity() || Orientation.IsNanOrInfinity() || Scale.IsNanOrInfinity();
|
||||
}
|
||||
|
||||
Matrix Transform::GetRotation() const
|
||||
{
|
||||
Matrix result;
|
||||
@@ -188,6 +198,15 @@ void Transform::WorldToLocalVector(const Vector3& vector, Vector3& result) const
|
||||
result *= invScale;
|
||||
}
|
||||
|
||||
void Transform::WorldToLocal(const Quaternion& rotation, Quaternion& result) const
|
||||
{
|
||||
Quaternion orientation = Orientation;
|
||||
orientation.Conjugate();
|
||||
Quaternion::Multiply(orientation, rotation, orientation);
|
||||
orientation.Normalize();
|
||||
result = orientation;
|
||||
}
|
||||
|
||||
Float3 Transform::GetRight() const
|
||||
{
|
||||
return Float3::Transform(Float3::Right, Orientation);
|
||||
|
||||
@@ -90,18 +90,12 @@ public:
|
||||
/// <summary>
|
||||
/// Checks if transform is an identity transformation.
|
||||
/// </summary>
|
||||
bool IsIdentity() const
|
||||
{
|
||||
return Translation.IsZero() && Orientation.IsIdentity() && Scale.IsOne();
|
||||
}
|
||||
bool IsIdentity() const;
|
||||
|
||||
/// <summary>
|
||||
/// Returns true if transform has one or more components equal to +/- infinity or NaN.
|
||||
/// </summary>
|
||||
bool IsNanOrInfinity() const
|
||||
{
|
||||
return Translation.IsNanOrInfinity() || Orientation.IsNanOrInfinity() || Scale.IsNanOrInfinity();
|
||||
}
|
||||
bool IsNanOrInfinity() const;
|
||||
|
||||
/// <summary>
|
||||
/// Calculates the determinant of this transformation.
|
||||
@@ -278,6 +272,25 @@ public:
|
||||
return result;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Performs transformation of the given rotation in world space to the local space of this transform.
|
||||
/// </summary>
|
||||
/// <param name="rotation">The world space rotation.</param>
|
||||
/// <param name="result">The local space rotation.</param>
|
||||
void WorldToLocal(const Quaternion& rotation, Quaternion& result) const;
|
||||
|
||||
/// <summary>
|
||||
/// Performs transformation of the given rotation in world space to the local space of this transform.
|
||||
/// </summary>
|
||||
/// <param name="rotation">The world space rotation.</param>
|
||||
/// <returns>The local space rotation.</returns>
|
||||
Quaternion WorldToLocal(const Quaternion& rotation) const
|
||||
{
|
||||
Quaternion result;
|
||||
WorldToLocal(rotation, result);
|
||||
return result;
|
||||
}
|
||||
|
||||
public:
|
||||
FORCE_INLINE Transform operator*(const Transform& other) const
|
||||
{
|
||||
|
||||
@@ -319,13 +319,9 @@ void Actor::SetParent(Actor* value, bool worldPositionsStays, bool canBreakPrefa
|
||||
if (worldPositionsStays)
|
||||
{
|
||||
if (_parent)
|
||||
{
|
||||
_parent->GetTransform().WorldToLocal(prevTransform, _localTransform);
|
||||
}
|
||||
_parent->_transform.WorldToLocal(prevTransform, _localTransform);
|
||||
else
|
||||
{
|
||||
_localTransform = prevTransform;
|
||||
}
|
||||
}
|
||||
|
||||
// Fire events
|
||||
@@ -622,7 +618,7 @@ void Actor::SetTransform(const Transform& value)
|
||||
if (!(Vector3::NearEqual(_transform.Translation, value.Translation) && Quaternion::NearEqual(_transform.Orientation, value.Orientation, ACTOR_ORIENTATION_EPSILON) && Float3::NearEqual(_transform.Scale, value.Scale)))
|
||||
{
|
||||
if (_parent)
|
||||
_parent->GetTransform().WorldToLocal(value, _localTransform);
|
||||
_parent->_transform.WorldToLocal(value, _localTransform);
|
||||
else
|
||||
_localTransform = value;
|
||||
OnTransformChanged();
|
||||
@@ -635,7 +631,7 @@ void Actor::SetPosition(const Vector3& value)
|
||||
if (!Vector3::NearEqual(_transform.Translation, value))
|
||||
{
|
||||
if (_parent)
|
||||
_localTransform.Translation = _parent->GetTransform().WorldToLocal(value);
|
||||
_localTransform.Translation = _parent->_transform.WorldToLocal(value);
|
||||
else
|
||||
_localTransform.Translation = value;
|
||||
OnTransformChanged();
|
||||
@@ -648,16 +644,9 @@ void Actor::SetOrientation(const Quaternion& value)
|
||||
if (!Quaternion::NearEqual(_transform.Orientation, value, ACTOR_ORIENTATION_EPSILON))
|
||||
{
|
||||
if (_parent)
|
||||
{
|
||||
_localTransform.Orientation = _parent->GetOrientation();
|
||||
_localTransform.Orientation.Invert();
|
||||
Quaternion::Multiply(_localTransform.Orientation, value, _localTransform.Orientation);
|
||||
_localTransform.Orientation.Normalize();
|
||||
}
|
||||
_parent->_transform.WorldToLocal(value, _localTransform.Orientation);
|
||||
else
|
||||
{
|
||||
_localTransform.Orientation = value;
|
||||
}
|
||||
OnTransformChanged();
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user