rect.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
 
#ifndef __IRR_RECT_H_INCLUDED__
#define __IRR_RECT_H_INCLUDED__
 
#include <glm/vec2.hpp>
 
namespace saga
{
namespace core
{
 
 
  template <class T>
  class rect
  {
  public:
 
    rect() : UpperLeftCorner(0,0), LowerRightCorner(0,0) {}
 
    rect(T x, T y, T x2, T y2)
      : UpperLeftCorner(x,y), LowerRightCorner(x2,y2) {}
 
    rect(const glm::vec2& upperLeft, const glm::vec2& lowerRight)
      : UpperLeftCorner(upperLeft), LowerRightCorner(lowerRight) {}
 
    template <class U>
    rect(const glm::vec2& pos, const glm::vec2& size)
      : UpperLeftCorner(pos), LowerRightCorner(pos.x + size.x, pos.y + size.y) {}
 
    template <class U>
    explicit rect(const glm::vec2& size)
      : UpperLeftCorner(0,0), LowerRightCorner(size.x, size.y) {}
 
    rect<T> operator+(const glm::vec2& pos) const
    {
      rect<T> ret(*this);
      return ret+=pos;
    }
 
    rect<T>& operator+=(const glm::vec2& pos)
    {
      UpperLeftCorner += pos;
      LowerRightCorner += pos;
      return *this;
    }
 
    rect<T> operator-(const glm::vec2& pos) const
    {
      rect<T> ret(*this);
      return ret-=pos;
    }
 
    rect<T>& operator-=(const glm::vec2& pos)
    {
      UpperLeftCorner -= pos;
      LowerRightCorner -= pos;
      return *this;
    }
 
    bool operator==(const rect<T>& other) const
    {
      return (UpperLeftCorner == other.UpperLeftCorner &&
        LowerRightCorner == other.LowerRightCorner);
    }
 
    bool operator!=(const rect<T>& other) const
    {
      return (UpperLeftCorner != other.UpperLeftCorner ||
        LowerRightCorner != other.LowerRightCorner);
    }
 
    bool operator<(const rect<T>& other) const
    {
      return getArea() < other.getArea();
    }
 
    T getArea() const
    {
      return getWidth() * getHeight();
    }
 
 
    bool isPointInside(const glm::vec2& pos) const
    {
      return (UpperLeftCorner.x <= pos.x &&
        UpperLeftCorner.y <= pos.y &&
        LowerRightCorner.x >= pos.x &&
        LowerRightCorner.y >= pos.y);
    }
 
 
    bool isRectCollided(const rect<T>& other) const
    {
      return (LowerRightCorner.y > other.UpperLeftCorner.y &&
        UpperLeftCorner.y < other.LowerRightCorner.y &&
        LowerRightCorner.x > other.UpperLeftCorner.x &&
        UpperLeftCorner.x < other.LowerRightCorner.x);
    }
 
 
    void clipAgainst(const rect<T>& other)
    {
      if (other.LowerRightCorner.x < LowerRightCorner.x)
        LowerRightCorner.x = other.LowerRightCorner.x;
      if (other.LowerRightCorner.y < LowerRightCorner.y)
        LowerRightCorner.y = other.LowerRightCorner.y;
 
      if (other.UpperLeftCorner.x > UpperLeftCorner.x)
        UpperLeftCorner.x = other.UpperLeftCorner.x;
      if (other.UpperLeftCorner.y > UpperLeftCorner.y)
        UpperLeftCorner.y = other.UpperLeftCorner.y;
 
      // correct possible invalid rect resulting from clipping
      if (UpperLeftCorner.y > LowerRightCorner.y)
        UpperLeftCorner.y = LowerRightCorner.y;
      if (UpperLeftCorner.x > LowerRightCorner.x)
        UpperLeftCorner.x = LowerRightCorner.x;
    }
 
 
    bool constrainTo(const rect<T>& other)
    {
      if (other.getWidth() < getWidth() || other.getHeight() < getHeight())
        return false;
 
      T diff = other.LowerRightCorner.x - LowerRightCorner.x;
      if (diff < 0)
      {
        LowerRightCorner.x += diff;
        UpperLeftCorner.x  += diff;
      }
 
      diff = other.LowerRightCorner.y - LowerRightCorner.y;
      if (diff < 0)
      {
        LowerRightCorner.y += diff;
        UpperLeftCorner.y  += diff;
      }
 
      diff = UpperLeftCorner.x - other.UpperLeftCorner.x;
      if (diff < 0)
      {
        UpperLeftCorner.x  -= diff;
        LowerRightCorner.x -= diff;
      }
 
      diff = UpperLeftCorner.y - other.UpperLeftCorner.y;
      if (diff < 0)
      {
        UpperLeftCorner.y  -= diff;
        LowerRightCorner.y -= diff;
      }
 
      return true;
    }
 
    T getWidth() const
    {
      return LowerRightCorner.x - UpperLeftCorner.x;
    }
 
    T getHeight() const
    {
      return LowerRightCorner.y - UpperLeftCorner.y;
    }
 
    void repair()
    {
      if (LowerRightCorner.x < UpperLeftCorner.x)
      {
        T t = LowerRightCorner.x;
        LowerRightCorner.x = UpperLeftCorner.x;
        UpperLeftCorner.x = t;
      }
 
      if (LowerRightCorner.y < UpperLeftCorner.y)
      {
        T t = LowerRightCorner.y;
        LowerRightCorner.y = UpperLeftCorner.y;
        UpperLeftCorner.y = t;
      }
    }
 
 
    bool isValid() const
    {
      return ((LowerRightCorner.x >= UpperLeftCorner.x) &&
        (LowerRightCorner.y >= UpperLeftCorner.y));
    }
 
    glm::vec2 getCenter() const
    {
      return glm::vec2(
          (UpperLeftCorner.x + LowerRightCorner.x) / 2,
          (UpperLeftCorner.y + LowerRightCorner.y) / 2);
    }
 
    glm::vec2 getSize() const
    {
      return glm::vec2(getWidth(), getHeight());
    }
 
 
 
    void addInternalPoint(const glm::vec2& p)
    {
      addInternalPoint(p.x, p.y);
    }
 
 
    void addInternalPoint(T x, T y)
    {
      if (x>LowerRightCorner.x)
        LowerRightCorner.x = x;
      if (y>LowerRightCorner.y)
        LowerRightCorner.y = y;
 
      if (x<UpperLeftCorner.x)
        UpperLeftCorner.x = x;
      if (y<UpperLeftCorner.y)
        UpperLeftCorner.y = y;
    }
 
    glm::vec2 UpperLeftCorner;
    glm::vec2 LowerRightCorner;
  };
 
  typedef rect<float> rectf;
  typedef rect<std::int32_t> recti;
 
} // namespace core
} // namespace saga
 
#endif