159 lines
4.3 KiB
C++
159 lines
4.3 KiB
C++
#include "stdafx.h"
|
|
#include <cmath>
|
|
#include <string>
|
|
#include <iostream>
|
|
#include "EMatrix2x3.h"
|
|
|
|
|
|
Matrix2x3::Matrix2x3(Elite::Vector2 dirX, Elite::Vector2 dirY, Elite::Vector2 orig)
|
|
: dirX{ dirX }, dirY{ dirY }, orig{ orig }
|
|
{}
|
|
|
|
Matrix2x3::Matrix2x3(float e1X, float e1Y, float e2X, float e2Y, float oX, float oY)
|
|
: Matrix2x3{ Elite::Vector2{e1X, e1Y}, Elite::Vector2{e2X, e2Y}, Elite::Vector2{oX, oY} }
|
|
{}
|
|
|
|
Elite::Vector2 Matrix2x3::Transform(const Elite::Vector2& vector) const
|
|
{
|
|
return Elite::Vector2{ vector.x * dirX + vector.y * dirY } + orig;
|
|
}
|
|
|
|
float Matrix2x3::Determinant() const
|
|
{
|
|
return dirX.x * dirY.y - dirX.y * dirY.x;
|
|
}
|
|
|
|
Matrix2x3 Matrix2x3::Inverse() const
|
|
{
|
|
//Calculate Determinant
|
|
float det = Determinant();
|
|
|
|
//1)calculate matrix of minors
|
|
//2)Use the alternating law of signs to produce the matrix of cofactors
|
|
//3)Transpose
|
|
//4)the inverse matrix is 1/Determinant * the resulting matrix
|
|
return Matrix2x3{
|
|
Elite::Vector2(+dirY.y, -dirX.y) / det,
|
|
Elite::Vector2(-dirY.x, +dirX.x) / det,
|
|
Elite::Vector2(dirY.x * orig.y - dirY.y * orig.x, -(dirX.x * orig.y - dirX.y * orig.x)) / det
|
|
};
|
|
}
|
|
|
|
bool Matrix2x3::Equals(const Matrix2x3& other, float epsilon ) const
|
|
{
|
|
return (dirX == other.dirX) &&
|
|
(dirY == other.dirY) &&
|
|
(orig == other.orig);
|
|
}
|
|
|
|
std::string Matrix2x3::ToString() const
|
|
{
|
|
return std::string( "Matrix2x3( x( ") +
|
|
std::to_string(dirX.x) + ", " + std::to_string( dirX.y )
|
|
+ " ), y( " + std::to_string( dirY.x ) + ", " + std::to_string( dirY.y )
|
|
+ " ), orig( " + std::to_string( orig.x ) + ", " + std::to_string( orig.y ) + " ) )";
|
|
}
|
|
|
|
void Matrix2x3::SetAsIdentity()
|
|
{
|
|
dirX = Elite::Vector2{1, 0};
|
|
dirY = Elite::Vector2{0, 1};
|
|
orig = Elite::Vector2{0, 0};
|
|
}
|
|
|
|
void Matrix2x3::SetAsRotate(float degrees)
|
|
{
|
|
float radians = degrees * 3.1415926535f / 180;
|
|
dirX = Elite::Vector2{ cos( radians ), sin( radians ) };
|
|
dirY = Elite::Vector2{ -sin( radians ), cos( radians ) };
|
|
orig = Elite::Vector2{ 0, 0 };
|
|
}
|
|
void Matrix2x3::SetAsTranslate(float tx, float ty)
|
|
{
|
|
dirX = Elite::Vector2{ 1, 0 };
|
|
dirY = Elite::Vector2{ 0, 1 };
|
|
orig = Elite::Vector2{ tx, ty };
|
|
}
|
|
|
|
void Matrix2x3::SetAsTranslate(Elite::Vector2 pt)
|
|
{
|
|
dirX = Elite::Vector2{ 1, 0 };
|
|
dirY = Elite::Vector2{ 0, 1 };
|
|
orig = Elite::Vector2{ pt.x, pt.y };
|
|
}
|
|
|
|
void Matrix2x3::SetAsScale(float scaleX, float scaleY)
|
|
{
|
|
dirX = Elite::Vector2{ scaleX, 0 };
|
|
dirY = Elite::Vector2{ 0, scaleY };
|
|
orig = Elite::Vector2{ 0, 0 };
|
|
}
|
|
|
|
void Matrix2x3::SetAsScale(float scale)
|
|
{
|
|
SetAsScale(scale, scale);
|
|
}
|
|
|
|
Matrix2x3 Matrix2x3::CreateRotationMatrix(float degrees)
|
|
{
|
|
float radians = degrees * 3.1415926535f / 180;
|
|
return Matrix2x3( Elite::Vector2{ cos( radians ), sin( radians ) }, Elite::Vector2{ -sin(radians), cos( radians ) }, Elite::Vector2{} );
|
|
}
|
|
|
|
Matrix2x3 Matrix2x3::CreateIdentityMatrix()
|
|
{
|
|
return Matrix2x3( Elite::Vector2{ 1, 0 }, Elite::Vector2{ 0, 1 }, Elite::Vector2{} );
|
|
}
|
|
|
|
Matrix2x3 Matrix2x3::CreateScalingMatrix(float scale)
|
|
{
|
|
return CreateScalingMatrix(scale, scale);
|
|
}
|
|
|
|
Matrix2x3 Matrix2x3::CreateScalingMatrix(Elite::Vector2 scaleVector)
|
|
{
|
|
return CreateScalingMatrix(scaleVector.x, scaleVector.y);
|
|
}
|
|
|
|
Matrix2x3 Matrix2x3::CreateScalingMatrix(float scaleX, float scaleY)
|
|
{
|
|
return Matrix2x3( Elite::Vector2{ scaleX, 0 }, Elite::Vector2{ 0, scaleY }, Elite::Vector2{} );
|
|
}
|
|
|
|
Matrix2x3 Matrix2x3::CreateTranslationMatrix(Elite::Vector2 origin)
|
|
{
|
|
return Matrix2x3( Elite::Vector2{ 1, 0 }, Elite::Vector2{ 0, 1 }, origin );
|
|
}
|
|
|
|
Matrix2x3 Matrix2x3::CreateTranslationMatrix(float tx, float ty)
|
|
{
|
|
return CreateTranslationMatrix( Elite::Vector2{ tx, ty } );
|
|
}
|
|
|
|
// Operator overloading functionality
|
|
bool operator==(const Matrix2x3& lhs, const Matrix2x3& rhs)
|
|
{
|
|
return lhs.Equals(rhs);
|
|
}
|
|
|
|
bool operator!=(const Matrix2x3& lhs, const Matrix2x3& rhs)
|
|
{
|
|
return !(lhs == rhs);
|
|
}
|
|
|
|
Matrix2x3 operator*(const Matrix2x3& lhs, const Matrix2x3& rhs)
|
|
{
|
|
return Matrix2x3{
|
|
Elite::Vector2{ rhs.dirX.x * lhs.dirX.x + rhs.dirX.y * lhs.dirY.x, rhs.dirX.x * lhs.dirX.y + rhs.dirX.y * lhs.dirY.y },
|
|
Elite::Vector2{ rhs.dirY.x * lhs.dirX.x + rhs.dirY.y * lhs.dirY.x, rhs.dirY.x * lhs.dirX.y + rhs.dirY.y * lhs.dirY.y },
|
|
Elite::Vector2{ rhs.orig.x * lhs.dirX.x + rhs.orig.y * lhs.dirY.x + lhs.orig.x, rhs.orig.x * lhs.dirX.y + rhs.orig.y * lhs.dirY.y + lhs.orig.y }
|
|
};
|
|
}
|
|
|
|
std::ostream& operator<<(std::ostream& os, const Matrix2x3& matrix )
|
|
{
|
|
os << matrix.ToString( );
|
|
return os;
|
|
}
|
|
|