doom3/neo/ui/Rectangle.h

/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

Doom 3 Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Doom 3 Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/
#ifndef IDRECTANGLE_H_
#define IDRECTANGLE_H_
//
// simple rectangle
//
extern void RotateVector(idVec3 &v, idVec3 origin, float a, float c, float s);
class idRectangle {
public:
	float x;    // horiz position
	float y;    // vert position
	float w;    // width
	float h;    // height;
	idRectangle() { x = y = w= h = 0.0; }
	idRectangle(float ix, float iy, float iw, float ih) { x = ix; y = iy; w = iw; h = ih; }
	float Bottom() const { return y + h; }
	float Right() const { return x + w; }
	void Offset (float x, float y) { 
		this->x += x;
		this->y += y;
	}
	bool Contains(float xt, float yt) {
		if (w == 0.0 && h == 0.0) {
			return false;
		}
		if (xt >= x && xt <= Right() && yt >= y && yt <= Bottom()) {
			return true;
		}
		return false;
	}
	void Empty() { x = y = w = h = 0.0; };

	void ClipAgainst(idRectangle r, bool sizeOnly) {
		if (!sizeOnly) {
			if (x < r.x) {
				x = r.x;
			}
			if (y < r.y) {
				y = r.y;
			}
		}
		if (x + w > r.x + r.w) {
			w = (r.x + r.w) - x;
		}
		if (y + h > r.y + r.h) {
			h = (r.y + r.h) - y;
		}
	}



	void Rotate(float a, idRectangle &out) {
		idVec3 p1, p2, p3, p4, p5;
		float c, s;
		idVec3 center;
		center.Set((x + w) / 2.0, (y + h) / 2.0, 0);
		p1.Set(x, y, 0);
		p2.Set(Right(), y, 0);
		p4.Set(x, Bottom(), 0);
		if (a) {
			s = sin( DEG2RAD( a ) );
			c = cos( DEG2RAD( a ) );
		}
		else {
			s = c = 0;
		}
		RotateVector(p1, center, a, c, s);
		RotateVector(p2, center, a, c, s);
		RotateVector(p4, center, a, c, s);
		out.x = p1.x;
		out.y = p1.y;
		out.w = (p2 - p1).Length();
		out.h = (p4 - p1).Length();
	}

	idRectangle & operator+=( const idRectangle &a );
	idRectangle & operator-=( const idRectangle &a );
	idRectangle & operator/=( const idRectangle &a );
	idRectangle & operator/=( const float a );
	idRectangle & operator*=( const float a );
	idRectangle & operator=( const idVec4 v );
	int operator==(const idRectangle &a) const;
	float &	operator[]( const int index );
	char * String( void ) const;
	const idVec4& ToVec4() const;

};

ID_INLINE const idVec4 &idRectangle::ToVec4() const {
	return *reinterpret_cast<const idVec4 *>(&x);
}


ID_INLINE idRectangle &idRectangle::operator+=( const idRectangle &a ) {
	x += a.x;
	y += a.y;
	w += a.w;
	h += a.h;

	return *this;
}

ID_INLINE idRectangle &idRectangle::operator/=( const idRectangle &a ) {
	x /= a.x;
	y /= a.y;
	w /= a.w;
	h /= a.h;

	return *this;
}

ID_INLINE idRectangle &idRectangle::operator/=( const float a ) {
	float inva = 1.0f / a;
	x *= inva;
	y *= inva;
	w *= inva;
	h *= inva;

	return *this;
}

ID_INLINE idRectangle &idRectangle::operator-=( const idRectangle &a ) {
	x -= a.x;
	y -= a.y;
	w -= a.w;
	h -= a.h;

	return *this;
}

ID_INLINE idRectangle &idRectangle::operator*=( const float a ) {
	x *= a;
	y *= a;
	w *= a;
	h *= a;

	return *this;
}


ID_INLINE idRectangle &idRectangle::operator=( const idVec4 v ) {
	x = v.x;
	y = v.y;
	w = v.z;
	h = v.w;
	return *this;
}

ID_INLINE int idRectangle::operator==( const idRectangle &a ) const {
	return (x == a.x && y == a.y && w == a.w && a.h);
}

ID_INLINE float& idRectangle::operator[]( int index ) {
	return ( &x )[ index ];
}

class idRegion {
public:
	idRegion() { };

	void Empty() {
		rects.Clear();
	}

	bool Contains(float xt, float yt) {
		int c = rects.Num();
		for (int i = 0; i < c; i++) {
			if (rects[i].Contains(xt, yt)) {
				return true;
			}
		}
		return false;
	}

	void AddRect(float x, float y, float w, float h) {
		rects.Append(idRectangle(x, y, w, h));
	}

	int GetRectCount() {
		return rects.Num();
	}

	idRectangle *GetRect(int index) {
		if (index >= 0 && index < rects.Num()) {
			return &rects[index];
		}
		return NULL;
	}

protected:

	idList<idRectangle> rects;
};


#endif