Rect.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2018 Julien Bernard
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 *
 * Part of this file comes from SFML, with the same license:
 * Copyright (C) 2007-2015 Laurent Gomila (laurent@sfml-dev.org)
 */
#ifndef GF_RECT_H
#define GF_RECT_H

#include <cstddef>
#include <algorithm>

#include "Portability.h"
#include "Vector.h"

namespace gf {
#ifndef DOXYGEN_SHOULD_SKIP_THIS
inline namespace v1 {
#endif

  template<typename T>
  struct Rect {
    T left; 
    T top; 
    T width; 
    T height; 

    constexpr Rect() noexcept
    : left{0}, top{0}, width{0}, height{0}
    {

    }

    constexpr Rect(T rectLeft, T rectTop, T rectWidth, T rectHeight) noexcept
    : left{rectLeft}, top{rectTop}, width{rectWidth}, height{rectHeight}
    {

    }

    Rect(const Vector<T, 2>& position, const Vector<T, 2>& size) noexcept
    : left(position.x), top(position.y), width(size.width), height(size.height)
    {

    }

    Rect(const Rect&) = default;

    Rect& operator=(const Rect&) = default;

    constexpr Vector<T, 2> getPosition() const noexcept {
      return { left, top };
    }

    constexpr void setPosition(Vector<T, 2> position) noexcept {
      left = position.x;
      top = position.y;
    }

    constexpr Vector<T, 2> getSize() const noexcept {
      return { width, height };
    }

    constexpr void setSize(Vector<T, 2> size) noexcept {
      width = size.width;
      height = size.height;
    }

    constexpr bool isEmpty() const noexcept {
      return width == 0 || height == 0;
    }

    constexpr Vector<T, 2> getCenter() const noexcept {
      return { left + width / 2, top + height / 2 };
    }

    constexpr Vector<T, 2> getTopLeft() const noexcept {
      return { left, top };
    }

    constexpr Vector<T, 2> getTopRight() const noexcept {
      return { left + width, top };
    }

    constexpr Vector<T, 2> getBottomLeft() const noexcept {
      return { left, top + height };
    }

    constexpr Vector<T, 2> getBottomRight() const noexcept {
      return { left + width, top + height };
    }


    constexpr bool contains(const Vector<T, 2>& point) const noexcept {
      return left <= point.x && point.x < left + width && top <= point.y && point.y < top + height;
    }

    constexpr bool contains(const Rect<T>& other) const noexcept {
      return left <= other.left && other.left + other.width <= left + width
          && top <= other.top && other.top + other.height <= top + height;
    }

    constexpr bool intersects(const Rect<T>& other) const noexcept {
      return left + width > other.left && left < other.left + other.width
          && top + height > other.top && top < other.top + other.height;
    }

    bool intersects(const Rect<T>& other, Rect<T>& result) const noexcept {
      if (!intersects(other)) {
        result = Rect<T>();
        return false;
      }

      T resultLeft = std::max(left, other.left);
      T resultTop = std::max(top, other.top);
      T resultRight = std::min(left + width, other.left + other.width);
      T resultBottom = std::min(top + height, other.top + other.height);

      result = Rect<T>(resultLeft, resultTop, resultRight - resultLeft, resultBottom - resultTop);
      return true;
    }

    constexpr Rect<T> grow(T value) const noexcept {
      return Rect<T>(left - value, top - value, width + 2 * value, height + 2 * value);
    }

    constexpr Rect<T> shrink(T value) const noexcept {
      return Rect<T>(left + value, top + value, width - 2 * value, height - 2 * value);
    }
  };

  using RectF = Rect<float>;

  using RectI = Rect<int>;

  using RectU = Rect<unsigned>;

  using RectZ = Rect<std::size_t>;

// MSVC does not like extern template
#ifndef _MSC_VER
  extern template struct Rect<float>;
  extern template struct Rect<int>;
  extern template struct Rect<unsigned>;
#endif

  template<typename T>
  inline
  bool operator==(const Rect<T>& lhs, const Rect<T>& rhs) {
    return lhs.left == rhs.left && lhs.top == rhs.top && lhs.width == rhs.width && lhs.height == rhs.height;
  }

  template<typename T>
  inline
  bool operator!=(const Rect<T>& lhs, const Rect<T>& rhs) {
    return !(lhs == rhs);
  }

#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif
}

#endif // GF_RECT_H