rect.h

#ifndef RECT_H
#define RECT_H

#include <string>
#include <sstream>
#include <SDL.h>
#include "external/json/json.h"
#include "vectors.h"


template<class T>
class Rect {
public:
    Rect() : pos(0, 0), w(0), h(0) {
    }
    Rect(T pX, T pY, T pW, T pH) : pos(pX, pY), w(pW), h(pH) {
    }
    Rect(Vector2<T> pPos, T pW, T pH){
        Set(pPos, pW, pH);
    }
    Rect(Json::Value val){
        Load(val);
    }
    void Set(const Rect<T> &r){
        pos.x = r.pos.x;
        pos.y = r.pos.y;
        w = r.w;
        h = r.h;
    }
    void Set(T pX, T pY, T pW, T pH){
        pos.x = pX;
        pos.y = pY;
        w = pW;
        h = pH;
    }
    void Set(Vector2<T> pPos, T pW, T pH){
        pos = pPos;
        w = pW;
        h = pH;
    }
    void Set(T pX, T pY){
        pos.x = pX;
        pos.y = pY;
    }
    void Set(Vector2<T> pPos){
        pos = pPos;
    }
    Vector2<T> Pos() const{
        return pos;
    }
    T X() const{
        return pos.x;
    }
    T Y() const{
        return pos.y;
    }
    T W() const{
        return w;
    }
    T H() const{
        return h;
    }
    Json::Value Save() const {
        Json::Value val;
        val["x"] = pos.x;
        val["y"] = pos.y;
        val["w"] = w;
        val["h"] = h;
        return val;
    }
    void Load(Json::Value val){
        Set(val["x"].asInt(), val["y"].asInt(),
            val["w"].asInt(), val["h"].asInt());
    }
    bool operator == (Rect<T> r) const {
        return (pos.x == r.X() && pos.y == r.Y() 
                && w == r.w && h == r.h);
    }
    Rect<T>& operator += (Vector2f vec){
        this->pos += vec;
        return *this;
    }
    Rect<T> operator + (const Vector2f v) const{
        return Rect<T>(pos.x + v.x, pos.y + v.y, w, h);
    }
    Rect<T> operator - (const Vector2f v) const{
        return Rect<T>(pos.x - v.x, pos.y - v.y, w, h);
    }
    operator SDL_Rect() const{
        SDL_Rect rect;
        rect.x = pos.x;
        rect.y = pos.y;
        rect.w = w;
        rect.h = h;
        return rect;
    }
    operator Rect<float>() const {
        Rect<float> rect(pos, w, h);
        return rect;
    }
    operator Rect<int>() const {
        Rect<int> rect(pos, w, h);
        return rect;
    }
    operator std::string() const {
        std::stringstream s;
        s << "Rect: (" << (std::string)pos 
            << ", w: " << w << ", h: " << h << ")";
        return s.str();
    }

public:
    Vector2<T> pos;
    T w, h;
};

typedef Rect<int> Recti;
typedef Rect<float> Rectf;
typedef Rect<double> Rectd;

#endif