bool MouseGame(LPARAM lParam,WPARAM /*wParam*/)
{
double model[16],projection[16];
int viewport[4];
glGetIntegerv(GL_VIEWPORT,viewport);
glGetDoublev(GL_MODELVIEW_MATRIX,model);
glGetDoublev(GL_PROJECTION_MATRIX,projection);
double x0,y0,z0;
double x1,y1,z1;
gluUnProject(LOWORD(lParam),viewport[3] - HIWORD(lParam),0.0f,model,projection,viewport,&x0,&y0,&z0);
gluUnProject(LOWORD(lParam),viewport[3] - HIWORD(lParam),1.0f,model,projection,viewport,&x1,&y1,&z1);
x1 -= x0;
y1 -= y0;
z1 -= z0;
// Find the intersection with xOy
double k = -z0 / z1;
Vector2 hit(x0 + k * x1,y0 + k * y1);
//emitter.AddParticle(Vector2(0.01f,0.01f),hit);
#ifdef _DEBUG
for(unsigned long i = 0; i < gameMissles.GetSize(); ++i)
{
if((gameMissles[i]->m_position - hit).GetLength() < 0.4f)
{
if(gameMissles[i]->m_spring)
gameMissles[i]->m_spring = NULL;
else
gameMissles[i]->m_spring = &gameSpring1;
return true;
}
}
#endif
MisslePtr missle = new Missle;
missle->InitializeMissle(hit);
missle->m_position = gameShip.m_position + Matrix2(gameShip.m_orientation) * Vector2(0.0f,-0.25f);
missle->m_orientation = gameShip.m_orientation - M_PI_2;
missle->m_linearVelocity = gameShip.m_linearVelocity + Matrix2(gameShip.m_orientation) * Vector2(0.0f,-0.01f);
missle->m_angularVelocity = gameShip.m_angularVelocity;
gameMissles.InsertBack(missle);
return true;
}
//-----------------------------------------------------------------------------
T_Scalar getInverse(Matrix2& dest) const
{
if (&dest == this)
{
Matrix2 tmp;
T_Scalar det = getInverse(tmp);
dest = tmp;
return det;
}
else
{
const T_Scalar& a11 = e(0,0);
const T_Scalar& a12 = e(1,0);
const T_Scalar& a21 = e(0,1);
const T_Scalar& a22 = e(1,1);
dest.fill(0);
T_Scalar det = a11*a22-a12*a21;
if (det != 0)
dest = Matrix2(+a22, -a12, -a21, +a11) / det;
return det;
}
}
Ship::Ship()
{
position.x = 640;
position.y = 480;
rotation = 0;
turretMatrix = Matrix2();
reload = FIRE_RATE();
}
Point3D CartesianPlane::intersect_point3d(CartesianPlane another) {
Matrix2 matrix_ab = Matrix2(_a, _b, another._a, another._b);
Matrix2 matrix_ac = Matrix2(_a, _c, another._a, another._c);
Matrix2 matrix_bc = Matrix2(_b, _c, another._b, another._c);
double determinant_ab = matrix_ab.determinant();
double determinant_ac = matrix_ac.determinant();
double determinant_bc = matrix_bc.determinant();
Matrix2 matrix_ad = Matrix2(_a, - _d, another._a, - another._d);
Matrix2 matrix_bd = Matrix2(_b, - _d, another._b, - another._d);
Matrix2 matrix_dc = Matrix2(- _d, _c, - another._d, another._c);
Matrix2 matrix_db = Matrix2(- _d, _b, - another._d, another._b);
double x, y, z;
if ( fabs( determinant_ab ) > 1e-12 ) {
z = 0.0;
x = matrix_db.determinant() / determinant_ab;
y = matrix_ad.determinant() / determinant_ab;
}
else if ( fabs( determinant_ac ) > 1e-12 ) {
y = 0.0;
x = matrix_dc.determinant() / determinant_ac;
z = matrix_ad.determinant() / determinant_ac;
}
else if ( fabs( determinant_bc ) > 1e-12 ) {
x = 0.0;
y = matrix_dc.determinant() / determinant_bc;
z = matrix_bd.determinant() / determinant_bc;
}
return Point3D(x, y, z);
};
template<class T> const Math::Matrix2<T> Math::Matrix2<T>::operator*(const Math::Matrix2<T> &rhs ) const
{
return Matrix2(
m[0][0] * rhs.m[0][0] + m[0][1] * rhs.m[1][0],
m[0][0] * rhs.m[0][1] + m[0][1] * rhs.m[1][1],
m[1][0] * rhs.m[0][0] + m[1][1] * rhs.m[1][0],
m[1][0] * rhs.m[0][1] + m[1][1] * rhs.m[1][1]
);
}
Matrix2 Matrix2::inv()
{
float _det = det();
if(_det == 0.0f)
return Matrix2();
Matrix2 inv = co();
inv /=_det;
return inv;
}
Matrix2 Matrix2::Inverse()
{
float det = Determinant();
if(det)
{
return Matrix2(data[3] / det, -data[2] / det,
-data[1] / det, data[0] / det);
}
return *this;
}
Filtro::Filtro(cv::Mat pImagen, int pN, int pM) {
aN = pN; //filas
aM = pM; //columnas
cv::Mat Matrix1(pN,pM,CV_8UC1);
cv::Mat Matrix2(pN,pM,CV_8UC1);
cvtColor(pImagen,Matrix1,CV_RGB2GRAY);
aMatrix1 = Matrix1;
aMatrix2 = Matrix2;
aAPI = API();
}
Matrix2& Matrix2::operator*(const Matrix2 & otherMatrix)
{
Matrix2 temp = Matrix2();
temp.matrixData[0][0] = (matrixData[0][0] * otherMatrix.matrixData[0][0]) + (matrixData[1][0] * otherMatrix.matrixData[0][1]);
temp.matrixData[1][0] = (matrixData[0][0] * otherMatrix.matrixData[1][0]) + (matrixData[1][0] * otherMatrix.matrixData[1][1]);
temp.matrixData[0][1] = (matrixData[0][1] * otherMatrix.matrixData[0][0]) + (matrixData[1][1] * otherMatrix.matrixData[0][1]);
temp.matrixData[1][1] = (matrixData[0][1] * otherMatrix.matrixData[1][0]) + (matrixData[1][1] * otherMatrix.matrixData[1][1]);
return temp;
}
Matrix2 & Matrix2::transpose()
{
Matrix2 temp = Matrix2();
temp.matrixData[0][0] = matrixData[0][0];
temp.matrixData[0][1] = matrixData[1][0];
temp.matrixData[1][0] = matrixData[0][1];
temp.matrixData[1][1] = matrixData[1][1];
return temp;
}
Matrix2 MappedValues::getMatrix2(const string& name) const
{
try
{
return matrix2s.at(name);
}
catch (const std::exception&)
{
return Matrix2();
}
}
Matrix2 Matrix2::Inverse() const
{
float det = m00_ * m11_ -
m01_ * m10_;
float invDet = 1.0f / det;
return Matrix2(
m11_, -m01_,
-m10_, m00_
) * invDet;
}
Matrix2& operator*(const Matrix2 & firstMatrix, const Matrix2 & secondMatrix)
{
Matrix2 temp = Matrix2();
for (int i = 0; i < 2; ++i)
{
for (int ii = 0; ii < 2; ++ii)
{
for (int iii = 0; iii < 2; ++iii)
{
temp.matrixData[i][ii] += firstMatrix.matrixData[i][iii] * secondMatrix.matrixData[iii][ii];
}
}
}
return temp;
}
Matrix2 Matrix2::Adjugate()
{
return Matrix2(data[3], -data[2],
-data[1], data[0]);
}
etk::Matrix2 etk::mat2Scale(const vec2& _scale) {
return Matrix2(_scale.x(), 0.0, 0.0, _scale.y(), 0.0, 0.0);
};
Matrix2 Matrix2::Transpose()
{
return Matrix2(data[0],data[1],
data[2],data[3]);
}
Matrix2 operator*(const Matrix2& lhs, const Matrix2& rhs)
{
return Matrix2(lhs[0] * rhs[0] + lhs[2] * rhs[1], lhs[0] * rhs[2] + lhs[2] * rhs[3],
lhs[1] * rhs[0] + lhs[3] * rhs[1], lhs[1] * rhs[2] + lhs[3] * rhs[3]);
}
Matrix2 Matrix2::scale(float x, float y)
{
return Matrix2(
x, 0,
0, y);
}
etk::Matrix2 etk::mat2Scale(float _scale) {
return Matrix2(_scale, 0.0, 0.0, _scale, 0.0, 0.0);
};
etk::Matrix2 etk::mat2Translate(const vec2& _translate) {
return Matrix2(1.0, 0.0, 0.0, 1.0, _translate.x(), _translate.y());
};
/*
Constructs a matrix in the form:
| x^2 - y^2 | 2 * x * y |
| 2 * x * y | y^2 - x^2 |
A reflection matrix around (x, y)
*/
Matrix2 Matrix2::reflection(const Vector2& axis)
{
return Matrix2(
axis[0] * axis[0] - axis[1] * axis[1], 2 * axis[0] * axis[1],
2 * axis[0] * axis[1], axis[1] * axis[1] - axis[0] * axis[0]);
}
Matrix2 Matrix2::identity()
{
return Matrix2(
1, 0,
0, 1);
}
etk::Matrix2 etk::mat2Rotate(float _angleRad) {
return Matrix2(cos(_angleRad), sin(_angleRad), -sin(_angleRad), cos(_angleRad), 0.0, 0.0);
};
Matrix2 operator+(const Matrix2& lhs, const Matrix2& rhs)
{
return Matrix2(lhs) += rhs;
}
template<class T> Matrix2<T> Matrix2<T>::operator -(const Matrix2& m) const
{
return Matrix2( a11 - m.a11, a12 - m.a12,
a21 - m.a21, a22 - m.a22);
}
Matrix2 operator-(const Matrix2& lhs, const Matrix2& rhs)
{
return Matrix2(lhs) -= rhs;
}
Matrix2 Matrix2::rotation(float radialAmount)
{
return Matrix2(
cos(radialAmount), -sin(radialAmount),
sin(radialAmount), cos(radialAmount));
}
etk::Matrix2 etk::mat2Skew(const vec2& _skew) {
return Matrix2(1.0, tan(_skew.y()), tan(_skew.x()), 1.0, 0.0, 0.0);
};
Matrix2 Matrix4::upper2x2() const {
return Matrix2(elt[0][0], elt[0][1],
elt[1][0], elt[1][1]);
}
Matrix2 Matrix2::scale(float amount)
{
return Matrix2(
amount, 0,
0, amount);
}
