/// Matrix multiplication (m1 * m2)
gMatrix3 operator* (const gMatrix3& m1, const gMatrix3& m2)
{
return gMatrix3(
gVector3(m1[0] * m2.getColumn(0), m1[0] * m2.getColumn(1), m1[0] * m2.getColumn(2)),
gVector3(m1[1] * m2.getColumn(0), m1[1] * m2.getColumn(1), m1[1] * m2.getColumn(2)),
gVector3(m1[2] * m2.getColumn(0), m1[2] * m2.getColumn(1), m1[2] * m2.getColumn(2))
);//redo this with matrix * vector operator
}
///----------------------------------------------------------------------
/// Static Initializers
///----------------------------------------------------------------------
/// Creates a 3-D rotation matrix.
/// Takes an angle in degrees and outputs a 3x3 rotation matrix
gMatrix3 gMatrix3::rotation2D(float angle)
{
//change angle degrees to radians
//(degrees * PI) / 180
float radians = (angle * M_PI) / 180;
return gMatrix3( gVector3(cos(radians), -sin(radians), 0),
gVector3(sin(radians), cos(radians), 0),
gVector3( 0, 0, 1)
);
}
Poly::Poly() :Geometry()
{
//defaults a two vertex line segment
v.push_back(gVector3(-1, 0, 1));
v.push_back(gVector3(-0.5, -0.5, 1));
v.push_back(gVector3(0.5, -0.5, 1));
v.push_back(gVector3(1, 0, 1));
v.push_back(gVector3(0.5, 0.5, 1));
v.push_back(gVector3(-0.5, 0.5, 1));
shape = "poly";
}
/// Vector Addition (v1 + v2)
gVector3 operator+ (const gVector3& v1, const gVector3& v2)
{
return gVector3(v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2]);
}
/// Cross Product (v1 % v2)
gVector3 operator% (const gVector3& v1, const gVector3& v2)
{
return gVector3(+(v1[1] * v2[2] - v1[2] * v2[1]),
-(v1[0] * v2[2] - v1[2] * v2[0]),
+(v1[0] * v2[1] - v1[1] * v2[0]) );
}
/// Scalar Division (v/c)
gVector3 operator/ (const gVector3& v, float c)
{
return gVector3(v[0] / c, v[1] / c, v[2] / c);
}
/// Scalar Multiplication (c * v)
gVector3 operator* (float c, const gVector3& v)
{
return gVector3(c * v[0], c * v[1], c * v[2]);
}
Square::Square(gVector3& c):rPolygon(4,c){
points[0] = gVector3(50,50,1);
points[1] = gVector3(50,-50,1);
points[2] = gVector3(-50, -50,1);
points[3] = gVector3(-50,50,1);
}
/// Matrix/vector multiplication (m * v)
/// Assume v is a column vector (ie. a 3x1 matrix)
gVector3 operator* (const gMatrix3& m, const gVector3& v)
{
return gVector3(m[0] * v, m[1] * v, m[2] * v);
}
/// Takes an x and y scale and outputs a 3x3 scale matrix
gMatrix3 gMatrix3::scale2D(float x, float y)
{
return gMatrix3(gVector3(x, 0, 0),
gVector3(0, y, 0),
gVector3(0, 0, 1));
}
/// Takes an x and y displacement and outputs a 3x3 translation matrix
gMatrix3 gMatrix3::translation2D(float x, float y)
{
return gMatrix3( gVector3(1, 0, x),
gVector3(0, 1, y),
gVector3(0, 0, 1));
}
///----------------------------------------------------------------------
/// Constructors
///----------------------------------------------------------------------
/// Default Constructor. Initialize to matrix of all 0s.
gMatrix3::gMatrix3()
{
data[0] = gVector3(); data[1] = gVector3(); data[2] = gVector3();
}
/// Returns a column of the matrix
gVector3 gMatrix3::getColumn(unsigned int index) const
{
return gVector3(data[0][index],data[1][index],data[2][index]);
}
/// Vector/matrix multiplication (v * m)
/// Assume v is a row vector (ie. a 1x3 matrix)
gVector3 operator* (const gVector3& v, const gMatrix3& m)
{
return gVector3(v * m[0], v * m[1], v * m[2]);
}
/// Vector Subtraction (v1 - v2)
gVector3 operator- (const gVector3& v1, const gVector3& v2)
{
return gVector3(v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2]);
}
/// Scalar Multiplication (v * c)
gVector3 operator* (const gVector3& v, float c)
{
return gVector3(v[0] * c, v[1] * c, v[2] * c);
}
/// Generates a 3x3 identity matrix
gMatrix3 gMatrix3::identity()
{
return gMatrix3(gVector3(1, 0, 0),
gVector3(0, 1, 0),
gVector3(0, 0, 1));
}
