Rect.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2019 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 "Anchor.h"
#include "Box.h"
#include "Portability.h"
#include "Vector.h"

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

  template<typename T>
  struct Rect : Box<T, 2> {
    constexpr Rect() noexcept
    : Box<T, 2>({ T(0), T(0) })
    {
    }

    constexpr Rect(const Box<T, 2>& box)
    : Box<T, 2>(box)
    {
    }

    static constexpr Rect<T> fromMinMax(Vector<T, 2> min, Vector<T, 2> max) noexcept {
      return Rect<T>(min, max);
    }

    static constexpr Rect<T> fromPositionSize(Vector<T, 2> position, Vector<T, 2> size) noexcept {
      return Rect<T>(position, position + size);
    }

    static constexpr Rect<T> fromCenterSize(Vector<T, 2> center, Vector<T, 2> size) noexcept {
      return Rect<T>(center - size / T(2), center + size / T(2));
    }

    constexpr Vector<T, 2> getPositionFromAnchor(Anchor anchor) const noexcept {
      switch (anchor) {
        case Anchor::TopLeft:
          return this->min;
        case Anchor::TopCenter:
          return { (this->min.x + this->max.x) / T(2), this->min.y };
        case Anchor::TopRight:
          return { this->max.x, this->min.y };
        case Anchor::CenterLeft:
          return { this->min.x, (this->min.y + this->max.y) / T(2) };
        case Anchor::Center:
          return this->getCenter();
        case Anchor::CenterRight:
          return { this->max.x, (this->min.y + this->max.y) / T(2) };
        case Anchor::BottomLeft:
          return { this->min.x, this->max.y };
        case Anchor::BottomCenter:
          return { (this->min.x + this->max.x) / T(2), this->max.y };
        case Anchor::BottomRight:
          return this->max;
      }

      return this->min;
    }

    constexpr Vector<T, 2> getTopLeft() const noexcept {
      return getPositionFromAnchor(Anchor::TopLeft);
    }

    constexpr Vector<T, 2> getTopRight() const noexcept {
      return getPositionFromAnchor(Anchor::TopRight);
    }

    constexpr Vector<T, 2> getBottomLeft() const noexcept {
      return getPositionFromAnchor(Anchor::BottomLeft);
    }

    constexpr Vector<T, 2> getBottomRight() const noexcept {
      return getPositionFromAnchor(Anchor::BottomRight);
    }

    constexpr T getWidth() const noexcept {
      return this->max.x - this->min.x;
    }

    constexpr T getHeight() const noexcept {
      return this->max.y - this->min.y;
    }

  private:
    constexpr Rect(Vector<T, 2> min, Vector<T, 2> max) noexcept
    : Box<T, 2>(min, max)
    {
    }
  };

  using RectF = Rect<float>;

  using RectD = Rect<double>;

  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 GF_API Rect<float>;
  extern template struct GF_API Rect<double>;
  extern template struct GF_API Rect<int>;
  extern template struct GF_API Rect<unsigned>;
#endif

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

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

  template<typename Archive, typename T>
  Archive& operator|(Archive& ar, Rect<T>& rect) {
    return ar | rect.min.x | rect.min.y | rect.max.x | rect.max.y;
  }


#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif
}

#endif // GF_RECT_H