haiku.git

#ifndef _MATRIX_H
#define _MATRIX_H

// Standard Includes -----------------------------------------------------------


// System Includes -------------------------------------------------------------

#include <Point.h>

// Project Includes ------------------------------------------------------------


// Local Includes --------------------------------------------------------------


// Local Defines ---------------------------------------------------------------


// Globals ---------------------------------------------------------------------


// BMatrix class ---------------------------------------------------------------

class BMatrix {

public:
				BMatrix();

		void	Translate(float tx, float ty);
		void	Rotate(float angle);
		void	Scale(float scaleFactorX, float scaleFactorY);
		void	SkewX(float angle);
		void	SkewY(float angle);

		void	Transform(BPoint *point);
		BPoint	Transform(BPoint point);
		void	Transform(BShape &shape);

		BMatrix &operator*=(const BMatrix &matrix);

		float a, b, c, d, e, f;
};
// BTransformIterator class ----------------------------------------------------

class BTransformIterator : public BShapeIterator {

public:
						BTransformIterator(BMatrix *matrix);

virtual	status_t		IterateMoveTo(BPoint *point);
virtual	status_t		IterateLineTo(int32 lineCount, BPoint *linePts);
virtual	status_t		IterateBezierTo(int32 bezierCount, BPoint *bezierPts);
virtual	status_t		IterateClose();

private:

		BMatrix			*fMatrix;
};
//------------------------------------------------------------------------------

inline BMatrix::BMatrix()
{
	a = d = 1.0f;
	b = c = e = f = 0.0f;
}
//------------------------------------------------------------------------------

inline void BMatrix::Translate(float tx, float ty)
{
	e += a * tx + c * ty;
	f += b * tx + d * ty;
}
//------------------------------------------------------------------------------

inline void BMatrix::Rotate(float angle)
{
	BMatrix m;
	angle = (float)(angle * 3.1415926535897932384626433832795 / 180.0);
	float ca = (float)cos(angle), sa = (float)sin(angle);

	m.a = a * ca + c * sa;
	m.b = b * ca + d * sa;
	m.c = - a * sa + c * ca;
	m.d = - b * sa + d * ca;
	m.e = e;
	m.f = f;

	*this = m;
}
//------------------------------------------------------------------------------

inline void BMatrix::Scale(float scaleFactorX, float scaleFactorY)
{
	BMatrix m;

	m.a = a * scaleFactorX;
	m.b = b * scaleFactorX;
	m.c = c * scaleFactorY;
	m.d = d * scaleFactorY;
	m.e = e;
	m.f = f;

	*this = m;
}
//------------------------------------------------------------------------------

inline void BMatrix::SkewX(float angle)
{
	BMatrix m;
	angle = (float)(angle * 3.1415926535897932384626433832795 / 180.0);
	float x = (float)tan(angle);

	m.a = a;
	m.b = b;
	m.c = a * x + c;
	m.d = b * x + d;
	m.e = e;
	m.f = f;

	*this = m;
}
//------------------------------------------------------------------------------

inline void BMatrix::SkewY(float angle)
{
	BMatrix m;
	angle = (float)(angle * 3.1415926535897932384626433832795 / 180.0);
	float y = (float)tan(angle);

	m.a = a + c * y;
	m.b = b + d * y;
	m.c = c;
	m.d = d;
	m.e = e;
	m.f = f;

	*this = m;
}
//------------------------------------------------------------------------------

inline void BMatrix::Transform(BPoint *point)
{
	float x = point->x;
	float y = point->y;

	point->x = x * a + y * c + e;
	point->y = x * b + y * d + f;
}
//------------------------------------------------------------------------------

inline BPoint BMatrix::Transform(BPoint point)
{
	Transform(&point);
	return point;
}
//------------------------------------------------------------------------------

inline void BMatrix::Transform(BShape &shape)
{
	BTransformIterator transform(this);
	transform.Iterate(&shape);
}
//------------------------------------------------------------------------------

inline BMatrix &BMatrix::operator*=(const BMatrix &matrix)
{
	BMatrix m;

	m.a = a * matrix.a + c * matrix.b;
	m.b = b * matrix.a + d * matrix.b;
	m.c = a * matrix.c + c * matrix.d;
	m.d = b * matrix.c + d * matrix.d;
	m.e = a * matrix.e + c * matrix.f + e;
	m.f = b * matrix.e + d * matrix.f + f;

	*this = m;

	return *this;
}
//------------------------------------------------------------------------------

inline BTransformIterator::BTransformIterator(BMatrix *matrix)
{
	fMatrix = matrix;
}
//------------------------------------------------------------------------------

inline status_t BTransformIterator::IterateMoveTo(BPoint *point)
{
	fMatrix->Transform(point);
	return B_OK;
}
//------------------------------------------------------------------------------

inline status_t BTransformIterator::IterateLineTo(int32 lineCount, BPoint *linePts)
{
	for (int32 i = 0; i < lineCount; i++)
		fMatrix->Transform(linePts++);
	return B_OK;
}
//------------------------------------------------------------------------------

inline status_t BTransformIterator::IterateBezierTo(int32 bezierCount,
											 BPoint *bezierPts)
{
	for (int32 i = 0; i < bezierCount * 3; i++)
		fMatrix->Transform(bezierPts++);
	return B_OK;
}
//------------------------------------------------------------------------------

inline status_t BTransformIterator::IterateClose()
{
	return B_OK;
}
//------------------------------------------------------------------------------


#endif // _MATRIX_H