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