Index: ps/trunk/source/ps/Overlay.h
===================================================================
--- ps/trunk/source/ps/Overlay.h	(revision 287)
+++ ps/trunk/source/ps/Overlay.h	(revision 288)
@@ -1,142 +1,302 @@
 /*
 COverlay
 by Rich Cross, rich@0ad.wildfiregames.com
 
 
 --Overview--
 
 	Class representing 2D screen overlays; includes functionality for overlay
 	position, color, texture and borders.
 */
 
 #ifndef COVERLAY_H
 #define COVERLAY_H
 
+#include "types.h"
+
 struct CColor
 {
-	CColor() {}
+	CColor() : r(-1.f), g(-1.f), b(-1.f), a(1.f) {}
 	CColor(float cr,float cg,float cb,float ca) : r(cr), g(cg), b(cb), a(ca) {}
 
+	bool operator == (const CColor &color) const
+	{
+		return r==color.r && 
+			   g==color.g &&
+			   b==color.b &&
+			   a==color.a;
+	}
+
+	bool operator != (const CColor &color) const
+	{
+		return !(*this==color);
+	}
+
 	float r, g, b, a;
 };
 
+class CPos;
+class CSize;
+
 // yuck - MFC already defines a CRect class...
 #define CRect PS_CRect
 
-struct CRect
+/**
+ * @author Gustav Larsson
+ *
+ * Rectangle class used for screen rectangles. It's very similiar to the MS
+ * CRect, but be aware it is not identical.
+ * Works with CPos.
+ * @see CSize
+ * @see CPos
+ */
+class CRect
 {
-	CRect() {}
-	CRect(int _l, int _t, int _r, int _b) :
-		left(_l),
-		top(_t),
-		right(_r),
-		bottom(_b) {}
-	int bottom, top, left, right;
+public:
+	CRect();
+	CRect(const CPos &pos);
+	CRect(const CSize &size);
+	CRect(const CPos &upperleft, const CPos &bottomright);
+	CRect(const CPos &pos, const CSize &size);
+	CRect(const int32 &_l, const int32 &_t, const int32 &_r, const int32 &_b);
+
+	// Operators
+	void				operator =  (const CRect& a);
+	bool				operator == (const CRect& a) const;
+	bool				operator != (const CRect& a) const;
+	CRect				operator -	(void) const;
+	CRect				operator +	(void) const;
+
+	CRect				operator +  (const CRect& a) const;
+	CRect				operator +  (const CPos& a) const;
+	CRect				operator +  (const CSize& a) const;
+	CRect				operator -  (const CRect& a) const;
+	CRect				operator -  (const CPos& a) const;
+	CRect				operator -  (const CSize& a) const;
+
+	void				operator += (const CRect& a);
+	void				operator += (const CPos& a);
+	void				operator += (const CSize& a);
+	void				operator -= (const CRect& a);
+	void				operator -= (const CPos& a);
+	void				operator -= (const CSize& a);
 
-	bool operator ==(const CRect &rect) const
-	{
-		return	(bottom==rect.bottom) &&
-				(top==rect.top) &&
-				(left==rect.left) &&
-				(right==rect.right);
-	}
+	/**
+	 * @return Width of Rectangle
+	 */
+	int32 GetWidth() const;
+	
+	/**
+	 * @return Height of Rectangle
+	 */
+	int32 GetHeight() const;
 
-	bool operator !=(const CRect &rect) const
-	{
-		return	!(*this==rect);
-	}
+	/**
+	 * Get Size
+	 */
+	CSize GetSize() const;
+
+	/**
+	 * Get Position equivalent to top/left corner
+	 */
+	CPos TopLeft() const;
+
+	/**
+	 * Get Position equivalent to bottom/right corner
+	 */
+	CPos BottomRight() const;
+	
+	/**
+	 * Get Position equivalent to the center of the rectangle
+	 */
+	CPos CenterPoint() const;
+
+	/**
+	 * Evalutates if point is within the rectangle
+	 * @param point CPos representing point
+	 * @return true if inside.
+	 */
+	bool PointInside(const CPos &point) const;
+
+	/**
+	 * Returning CPos representing each corner.
+	 */
+
+public:
+	/**
+	 * Dimensions
+	 */
+	int32 left, top, right, bottom;
+};
+
+/**
+ * @author Gustav Larsson
+ *
+ * Made to represent screen positions and delta values.
+ * @see CRect
+ * @see CSize
+ */
+class CPos
+{
+public:
+	CPos();
+	CPos(const int32 &_x, const int32 &_y);
+
+	// Operators
+	void				operator =  (const CPos& a);
+	bool				operator == (const CPos& a) const;
+	bool				operator != (const CPos& a) const;
+	CPos				operator -	(void) const;
+	CPos				operator +	(void) const;
+
+	CPos				operator +  (const CPos& a) const;
+	CPos				operator +  (const CSize& a) const;
+	CPos				operator -  (const CPos& a) const;
+	CPos				operator -  (const CSize& a) const;
+
+	void				operator += (const CPos& a);
+	void				operator += (const CSize& a);
+	void				operator -= (const CPos& a);
+	void				operator -= (const CSize& a);
+
+public:
+	/**
+	 * Position
+	 */
+	int32 x, y;
+};
+
+/**
+ * @author Gustav Larsson
+ *
+ * Made to represent a screen size, should in philosophy
+ * be made of unsigned ints, but for the sake of compatibility
+ * with CRect and CPos it's not.
+ * @see CRect
+ * @see CPos
+ */
+class CSize
+{
+public:
+	CSize();
+	CSize(const CRect &rect);
+	CSize(const CPos &pos);
+	CSize(const int32 &_cx, const int32 &_cy);
+
+	// Operators
+	void				operator =  (const CSize& a);
+	bool				operator == (const CSize& a) const;
+	bool				operator != (const CSize& a) const;
+	CSize				operator -	(void) const;
+	CSize				operator +	(void) const;
+
+	CSize				operator +  (const CSize& a) const;
+	CSize				operator -  (const CSize& a) const;
+	CSize				operator /  (const int &a) const;
+	CSize				operator *  (const int &a) const;
+
+	void				operator += (const CSize& a);
+	void				operator -= (const CSize& a);
+	void				operator /= (const int& a);
+	void				operator *= (const int& a);
+
+public:
+	/**
+	 * Size
+	 */
+	int32 cx, cy;
 };
 
 
 //--------------------------------------------------------
 //  Includes / Compiler directives
 //--------------------------------------------------------
 #include "terrain/Texture.h"
 
 
 //--------------------------------------------------------
 //  Macros
 //--------------------------------------------------------
 
 //--------------------------------------------------------
 //  Types
 //--------------------------------------------------------
 
 //--------------------------------------------------------
 //  Error declarations
 //--------------------------------------------------------
 
 //--------------------------------------------------------
 //  Declarations
 //--------------------------------------------------------
 
 /**
  * @author Rich Cross
  *
  * Overlay class definition.
  */
 class COverlay
 {
 public:
 	/**
 	 * Default constructor; creates an overlay that won't actually be renderable
 	 */
 	COverlay();
 	/**
 	 * Constructor with setup for more common parameters
 	 */
 	COverlay(const CRect& rect,int z,const CColor& color,const char* texturename="",bool hasBorder=false,
 		const CColor& bordercolor=CColor(0,0,0,0));
 	/**
 	 * Destructor 
 	 */	
 	~COverlay();
 
 	/**
 	 * Get coordinates
 	 */	
 	const CRect& GetRect() const { return m_Rect; }
 
 	/**
 	 * Get depth
 	 */	
 	int GetZ() const { return m_Z; }
 
 	/**
 	 * Get texture (not const as Renderer need to modify texture to store handle)
 	 */	
 	CTexture& GetTexture() { return m_Texture; }
 
 	/**
 	 * Get color
 	 */	
 	const CColor& GetColor() const { return m_Color; }
 
 	/**
 	 * Get border flag
 	 */	
 	bool HasBorder() const { return m_HasBorder; }
 
 	/**
 	 * Get border color
 	 */	
 	const CColor& GetBorderColor() const { return m_BorderColor; }
 
 
 private:
 	/// screen space coordinates of overlay
 	CRect m_Rect;
 	/// depth of overlay, for correctly overlapping overlays; higher z implies in-front-of behaviour
 	int m_Z;
 	/// texture to use in rendering overlay; can be a null texture
 	CTexture m_Texture;
 	/// overlay color
 	CColor m_Color;
 	// flag indicating whether to render overlay using a border
 	bool m_HasBorder;
 	/// border color
 	CColor m_BorderColor;
 };
 
 
 #endif
\ No newline at end of file
Index: ps/trunk/source/ps/Overlay.cpp
===================================================================
--- ps/trunk/source/ps/Overlay.cpp	(revision 287)
+++ ps/trunk/source/ps/Overlay.cpp	(revision 288)
@@ -1,23 +1,413 @@
 /*
 COverlay
 by Rich Cross
 rich@0ad.wildfiregames.com
 */
 
 #include "Overlay.h"
 
 COverlay::COverlay()
 	: m_Rect(CRect(0,0,0,0)), m_Z(0), m_Color(CColor(0,0,0,0)), m_Texture(""), m_HasBorder(false), m_BorderColor(CColor(0,0,0,0))
 {
 }
 
 
 COverlay::COverlay(const CRect& rect,int z,const CColor& color,const char* texturename,
 				   bool hasBorder,const CColor& bordercolor)
 	: m_Rect(rect), m_Z(z), m_Color(color), m_Texture(texturename), m_HasBorder(hasBorder), m_BorderColor(bordercolor)
 {
 }
 
 COverlay::~COverlay()
 {
-}
\ No newline at end of file
+}
+
+/*************************************************************************/
+
+CRect::CRect() : 
+	left(0), top(0), right(0), bottom(0) 
+{
+}
+
+CRect::CRect(const CPos &pos) :
+	left(pos.x), top(pos.y), right(pos.x), bottom(pos.y)
+{
+}
+
+CRect::CRect(const CSize &size) :
+	left(0), top(0), right(size.cx), bottom(size.cy)
+{
+}
+
+CRect::CRect(const CPos &upperleft, const CPos &bottomright) :
+	left(upperleft.x), top(upperleft.y), right(bottomright.x), bottom(bottomright.y)
+{
+}
+
+CRect::CRect(const CPos &pos, const CSize &size) :
+	left(pos.x), top(pos.y), right(pos.x+size.cx), bottom(pos.y+size.cy)
+{
+}
+
+CRect::CRect(const int32 &_l, const int32 &_t, const int32 &_r, const int32 &_b) : 
+	left(_l), top(_t), right(_r), bottom(_b) 
+{
+}
+
+// =
+void CRect::operator = (const CRect& a)
+{
+	left = a.left;
+	top = a.top;
+	right = a.right;
+	bottom = a.bottom;
+}
+
+// ==
+bool CRect::operator ==(const CRect &a) const
+{
+	return	(left==a.left &&
+			 top==a.top &&
+			 right==a.right &&
+			 bottom==a.bottom);
+}
+
+// !=
+bool CRect::operator != (const CRect& a) const
+{
+	return !(*this==a);
+}
+
+// - (the unary operator)
+CRect CRect::operator - (void) const
+{
+	return CRect(-left, -top, -right, -bottom);
+}
+
+// + (the unary operator)
+CRect CRect::operator + (void) const
+{
+	return *this;
+}
+
+// +
+CRect CRect::operator + (const CRect& a) const
+{
+	return CRect(left+a.left, top+a.top, right+a.right, bottom+a.bottom);
+}
+
+// +
+CRect CRect::operator + (const CPos& a) const
+{
+	return CRect(left+a.x, top+a.y, right+a.x, bottom+a.y);
+}
+
+// +
+CRect CRect::operator + (const CSize& a) const
+{
+	return CRect(left+a.cx, top+a.cy, right+a.cx, bottom+a.cy);
+}
+
+// -
+CRect CRect::operator - (const CRect& a) const
+{ 
+	return CRect(left-a.left, top-a.top, right-a.right, bottom-a.bottom);
+}
+
+// -
+CRect CRect::operator - (const CPos& a) const
+{ 
+	return CRect(left-a.x, top-a.y, right-a.x, bottom-a.y);
+}
+
+// -
+CRect CRect::operator - (const CSize& a) const
+{ 
+	return CRect(left-a.cx, top-a.cy, right-a.cx, bottom-a.cy);
+}
+
+// +=
+void CRect::operator +=(const CRect& a)
+{
+	left += a.left;
+	top += a.top;
+	right += a.right;
+	bottom += a.bottom;
+}
+
+// +=
+void CRect::operator +=(const CPos& a)
+{
+	left += a.x;
+	top += a.y;
+	right += a.x;
+	bottom += a.y;
+}
+
+// +=
+void CRect::operator +=(const CSize& a)
+{
+	left += a.cx;
+	top += a.cy;
+	right += a.cx;
+	bottom += a.cy;
+}
+
+// -=
+void CRect::operator -=(const CRect& a)
+{
+	left -= a.left;
+	top -= a.top;
+	right -= a.right;
+	bottom -= a.bottom;
+}
+
+// -=
+void CRect::operator -=(const CPos& a)
+{
+	left -= a.x;
+	top -= a.y;
+	right -= a.x;
+	bottom -= a.y;
+}
+
+// -=
+void CRect::operator -=(const CSize& a)
+{
+	left -= a.cx;
+	top -= a.cy;
+	right -= a.cx;
+	bottom -= a.cy;
+}
+
+int32 CRect::GetWidth() const 
+{
+	return right-left;
+}
+
+int32 CRect::GetHeight() const
+{
+	return bottom-top;
+}
+
+CSize CRect::GetSize() const
+{
+	return CSize(right-left, bottom-top);
+}
+
+CPos CRect::TopLeft() const
+{
+	return CPos(left, top);
+}
+
+CPos CRect::BottomRight() const
+{
+	return CPos(right, right);
+}
+
+CPos CRect::CenterPoint() const
+{
+	return CPos((left+right)/2, (top+bottom)/2);
+}
+
+bool CRect::PointInside(const CPos &point) const
+{
+	return (point.x >= left &&
+			point.x <= right &&
+			point.y >= top &&
+			point.y <= bottom);
+}
+
+/*************************************************************************/
+
+CPos::CPos() : x(0), y(0) 
+{
+}
+
+CPos::CPos(const int32 &_x, const int32 &_y) : x(_x), y(_y)
+{
+}
+
+// =
+void CPos::operator = (const CPos& a)
+{
+	x = a.x;
+	y = a.y;
+}
+
+// ==
+bool CPos::operator ==(const CPos &a) const
+{
+	return	(x==a.x && y==a.y);
+}
+
+// !=
+bool CPos::operator != (const CPos& a) const
+{
+	return !(*this==a);
+}
+
+// - (the unary operator)
+CPos CPos::operator - (void) const
+{
+	return CPos(-x, -y);
+}
+
+// + (the unary operator)
+CPos CPos::operator + (void) const
+{
+	return *this;
+}
+
+// +
+CPos CPos::operator + (const CPos& a) const
+{
+	return CPos(x+a.x, y+a.y);
+}
+
+// +
+CPos CPos::operator + (const CSize& a) const
+{
+	return CPos(x+a.cx, y+a.cy);
+}
+
+// -
+CPos CPos::operator - (const CPos& a) const
+{ 
+	return CPos(x-a.x, y-a.y);
+}
+
+// -
+CPos CPos::operator - (const CSize& a) const
+{ 
+	return CPos(x-a.cx, y-a.cy);
+}
+
+// +=
+void CPos::operator +=(const CPos& a)
+{
+	x += a.x;
+	y += a.y;
+}
+
+// +=
+void CPos::operator +=(const CSize& a)
+{
+	x += a.cx;
+	y += a.cy;
+}
+
+// -=
+void CPos::operator -=(const CPos& a)
+{
+	x -= a.x;
+	y -= a.y;
+}
+
+// -=
+void CPos::operator -=(const CSize& a)
+{
+	x -= a.cx;
+	y -= a.cy;
+}
+
+/*************************************************************************/
+
+CSize::CSize() : cx(0), cy(0) 
+{
+}
+
+CSize::CSize(const CRect &rect) : cx(rect.GetWidth()), cy(rect.GetHeight()) 
+{
+}
+
+CSize::CSize(const CPos &pos) : cx(pos.x), cy(pos.y) 
+{
+}
+
+CSize::CSize(const int32 &_cx, const int32 &_cy) : cx(_cx), cy(_cy)
+{
+}
+
+// =
+void CSize::operator = (const CSize& a)
+{
+	cx = a.cx;
+	cy = a.cy;
+}
+
+// ==
+bool CSize::operator ==(const CSize &a) const
+{
+	return	(cx==a.cx && cy==a.cy);
+}
+
+// !=
+bool CSize::operator != (const CSize& a) const
+{
+	return !(*this==a);
+}
+
+// - (the unary operator)
+CSize CSize::operator - (void) const
+{
+	return CSize(-cx, -cy);
+}
+
+// + (the unary operator)
+CSize CSize::operator + (void) const
+{
+	return *this;
+}
+
+// +
+CSize CSize::operator + (const CSize& a) const
+{
+	return CSize(cx+a.cx, cy+a.cy);
+}
+
+// -
+CSize CSize::operator - (const CSize& a) const
+{ 
+	return CSize(cx-a.cx, cy-a.cy);
+}
+
+// /
+CSize CSize::operator / (const int& a) const
+{
+	return CSize(cx/a, cy/a);
+}
+
+// *
+CSize CSize::operator * (const int& a) const
+{ 
+	return CSize(cx*a, cy*a);
+}
+
+// +=
+void CSize::operator +=(const CSize& a)
+{
+	cx += a.cx;
+	cy += a.cy;
+}
+
+// -=
+void CSize::operator -=(const CSize& a)
+{
+	cx -= a.cx;
+	cy -= a.cy;
+}
+
+// /=
+void CSize::operator /=(const int& a)
+{
+	cx /= a;
+	cy /= a;
+}
+
+// *=
+void CSize::operator *=(const int& a)
+{
+	cx *= a;
+	cy *= a;
+}