Rect.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2021 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 <limits>
#include <tuple>

#include "Anchor.h"
#include "CoreApi.h"
#include "Quarter.h"
#include "Vector.h"
#include "VectorOps.h"

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

  template<typename T>
  struct Rect {
    constexpr Rect() noexcept
    : min(gf::Zero)
    , max(gf::Zero)
    {
    }

    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));
    }

    static constexpr Rect<T> empty() noexcept {
      return Rect<T>(Vector<T, 2>(std::numeric_limits<T>::max()), Vector<T, 2>(std::numeric_limits<T>::lowest()));
    }

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

    constexpr Vector<T, 2> getSize() const noexcept {
      return max - min;
    }

    constexpr bool isEmpty() const noexcept {
      return min.x >= max.x || min.y >= max.y;
    }

    constexpr Vector<T, 2> getCenter() const noexcept {
      return min + (max - min) / 2;
    }

    constexpr bool contains(Vector<T, 2> point) const noexcept {
      return min.x <= point.x && point.x < max.x && min.y <= point.y && point.y < max.y;
    }

    constexpr bool contains(const Rect& other) const noexcept {
      return min.x <= other.min.x && other.max.x <= max.x && min.y <= other.min.y && other.max.y <= max.y;
    }

    constexpr bool intersects(const Rect& other) const noexcept {
      return min.x < other.max.x && other.min.x < max.x && min.y < other.max.y && other.min.y < max.y;
    }

    constexpr bool intersects(const Rect& other, Rect& result) const noexcept {
      if (!intersects(other)) {
        return false;
      }

      result = getIntersection(other);
      return true;
    }

    constexpr Rect getIntersection(const Rect& other) const noexcept {
      Rect res;

      res.min.x = std::max(min.x, other.min.x);
      res.min.y = std::max(min.y, other.min.y);
      res.max.x = std::min(max.x, other.max.x);
      res.max.y = std::min(max.y, other.max.y);

      return res;
    }

    constexpr T getIntersectionVolume(const Rect& other) const noexcept {
      auto xMin = std::max(min.x, other.min.x);
      auto xMax = std::min(max.x, other.max.x);

      if (xMin >= xMax) {
        return T(0);
      }

      auto yMin = std::max(min.y, other.min.y);
      auto yMax = std::min(max.y, other.max.y);

      if (yMin >= yMax) {
        return T(0);
      }

      return (xMax - xMin) * (yMax - yMin);
    }

    constexpr T getIntersectionExtentLength(const Rect& other) const noexcept {
      auto xMin = std::max(min.x, other.min.x);
      auto xMax = std::min(max.x, other.max.x);

      if (xMin >= xMax) {
        return T(0);
      }

      auto yMin = std::max(min.y, other.min.y);
      auto yMax = std::min(max.y, other.max.y);

      if (yMin >= yMax) {
        return T(0);
      }

      return (xMax - xMin) + (yMax - yMin);
    }

    constexpr void extend(const T (&point)[2]) noexcept {
      min.x = std::min(min.x, point[0]);
      min.y = std::min(min.y, point[1]);
      max.x = std::max(max.x, point[0]);
      max.y = std::max(max.y, point[1]);
    }

    constexpr void extend(Vector<T, 2> point) noexcept {
      min.x = std::min(min.x, point.x);
      min.y = std::min(min.y, point.y);
      max.x = std::max(max.x, point.x);
      max.y = std::max(max.y, point.y);
    }

    constexpr void extend(const Rect& other) noexcept {
      min.x = std::min(min.x, other.min.x);
      min.y = std::min(min.y, other.min.y);
      max.x = std::max(max.x, other.max.x);
      max.y = std::max(max.y, other.max.y);
    }

    constexpr Rect getExtended(const Rect& other) const noexcept {
      Rect res(*this);
      res.extend(other);
      return res;
    }

    constexpr T getVolume() const noexcept {
      return (max.x - min.x) * (max.y - min.y);
    }

    constexpr T getExtentLength() const noexcept {
      return (max.x - min.x) + (max.y - min.y);
    }

    constexpr T getMinimumEdge() const noexcept {
      return std::min(max.x - min.x, max.y - min.y);
    }

    constexpr Rect grow(T value) const noexcept {
      return Rect(min - value, max + value);
    }

    constexpr Rect shrink(T value) const noexcept {
      return Rect(min + value, max - value);
    }

    constexpr void normalize() noexcept {
      if (min.x > max.x) { std::swap(min.x, max.x); }
      if (min.y > max.y) { std::swap(min.y, max.y); }
    }

    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;
    }

    Vector<T, 2> min; 
    Vector<T, 2> max; 

  private:
    constexpr Rect(Vector<T, 2> min, Vector<T, 2> max) noexcept
    : min(min)
    , max(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_CORE_API Rect<float>;
  extern template struct GF_CORE_API Rect<double>;
  extern template struct GF_CORE_API Rect<int>;
  extern template struct GF_CORE_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 T>
  constexpr
  Rect<T> computeBoxQuarter(const Rect<T>& other, Quarter quarter) {
    Vector<T, 2> size = (other.max - other.min) / 2;

    switch (quarter) {
      case Quarter::UpperLeft:
        return Rect<T>::fromMinMax(other.min, other.max - size);
      case Quarter::UpperRight:
        return Rect<T>::fromMinMax({ other.min.x + size.width, other.min.y }, { other.max.x, other.max.y - size.height });
      case Quarter::LowerRight:
        return Rect<T>::fromMinMax(other.min + size, other.max);
      case Quarter::LowerLeft:
        return Rect<T>::fromMinMax({ other.min.x, other.min.y + size.height }, { other.max.x - size.width, other.max.y });
    }

    return other;
  }

  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