geometry_type.hpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef GEOMETRY_TYPE_HPP
#define GEOMETRY_TYPE_HPP
 
#if defined(__APPLE__)
  /* Mac OS X already has both Rect and Point declared */
# define Rect OTTD_Rect
# define Point OTTD_Point
#endif /* __APPLE__ */

enum class AlignmentH : uint8_t {
  Start, 
  Centre, 
  End, 
  ForceLeft, 
  ForceRight, 
};

enum class AlignmentV : uint8_t {
  Top, 
  Middle, 
  Bottom, 
};

struct Alignment {
  AlignmentH h; 
  AlignmentV v; 

  constexpr Alignment(AlignmentH h, AlignmentV v) : h(h), v(v) {}

  constexpr Alignment(AlignmentH h) : Alignment(h, AlignmentV::Top) {}
 
  AlignmentH ResolveRTL() const;
};

inline int CentreBounds(int min, int max, int size)
{
  return (min + max - size + 1) / 2;
}

template <typename T>
struct Coord2D {
  T x = 0; 
  T y = 0; 
 
  constexpr Coord2D() = default;
  constexpr Coord2D(T x, T y) : x(x), y(y) {}

  constexpr auto operator<=>(const Coord2D<T> &) const = default;
};

template <typename T>
struct Coord3D {
  T x = 0; 
  T y = 0; 
  T z = 0; 
 
  constexpr Coord3D() = default;
  constexpr Coord3D(T x, T y, T z) : x(x), y(y), z(z) {}

  constexpr auto operator<=>(const Coord3D<T> &) const = default;
};

using Point = Coord2D<int>;

struct Dimension {
  uint width;
  uint height;
 
  constexpr Dimension() : width(0), height(0) {}
  constexpr Dimension(uint w, uint h) : width(w), height(h) {}
 
  bool operator< (const Dimension &other) const
  {
    int x = this->width - other.width;
    if (x != 0) return x < 0;
    return this->height < other.height;
  }
 
  bool operator== (const Dimension &other) const
  {
    return this->width == other.width && this->height == other.height;
  }
};

struct RectPadding {
  uint8_t left = 0;
  uint8_t top = 0;
  uint8_t right = 0;
  uint8_t bottom = 0;
 
  static const RectPadding zero;

  constexpr uint Horizontal() const { return this->left + this->right; }

  constexpr uint Vertical() const { return this->top + this->bottom; }
};
 
inline const RectPadding RectPadding::zero{};

struct Rect {
  int left = 0;
  int top = 0;
  int right = 0;
  int bottom = 0;

  inline int Width() const { return this->right - this->left + 1; }

  inline int Height() const { return this->bottom - this->top + 1; }

  [[nodiscard]] inline Rect Shrink(int s) const
  {
    return {this->left + s, this->top + s, this->right - s, this->bottom - s};
  }

  [[nodiscard]] inline Rect Shrink(int h, int v) const
  {
    return {this->left + h, this->top + v, this->right - h, this->bottom - v};
  }

  [[nodiscard]] inline Rect Shrink(int left, int top, int right, int bottom) const
  {
    return {this->left + left, this->top + top, this->right - right, this->bottom - bottom};
  }

  [[nodiscard]] inline Rect Shrink(const RectPadding &other) const
  {
    return {this->left + other.left, this->top + other.top, this->right - other.right, this->bottom - other.bottom};
  }

  [[nodiscard]] inline Rect Shrink(const RectPadding &horz, const RectPadding &vert) const
  {
    return {this->left + horz.left, this->top + vert.top, this->right - horz.right, this->bottom - vert.bottom};
  }

  [[nodiscard]] inline Rect Expand(int s) const
  {
    return this->Shrink(-s);
  }

  [[nodiscard]] inline Rect Expand(const RectPadding &other) const
  {
    return {this->left - other.left, this->top - other.top, this->right + other.right, this->bottom + other.bottom};
  }

  [[nodiscard]] inline Rect Translate(int x, int y) const
  {
    return {this->left + x, this->top + y, this->right + x, this->bottom + y};
  }

  [[nodiscard]] inline Rect WithWidth(int width, bool end) const
  {
    return end
      ? this->WithX(this->right - width + 1, this->right)
      : this->WithX(this->left, this->left + width - 1);
  }

  [[nodiscard]] inline Rect Indent(int indent, bool end) const
  {
    return end
      ? this->WithX(this->left, this->right - indent)
      : this->WithX(this->left + indent, this->right);
  }

  [[nodiscard]] inline Rect WithHeight(int height, bool end = false) const
  {
    return end
      ? this->WithY(this->bottom - height + 1, this->bottom)
      : this->WithY(this->top, this->top + height - 1);
  }

  inline bool Contains(const Point &pt) const
  {
    /* This is a local version of IsInsideMM, to avoid including math_func everywhere. */
    return (uint)(pt.x - this->left) <= (uint)(this->right - this->left) && (uint)(pt.y - this->top) <= (uint)(this->bottom - this->top);
  }

  [[nodiscard]] inline Rect CentreToHeight(int height) const
  {
    int new_top = CentreBounds(this->top, this->bottom, height);
    return {this->left, new_top, this->right, new_top + height - 1};
  }

  [[nodiscard]] inline Rect WithX(int new_left, int new_right) const { return {new_left, this->top, new_right, this->bottom}; }

  [[nodiscard]] inline Rect WithY(int new_top, int new_bottom) const { return {this->left, new_top, this->right, new_bottom}; }

  [[nodiscard]] inline Rect WithX(const Rect &other) const { return this->WithX(other.left, other.right); }

  [[nodiscard]] inline Rect WithY(const Rect &other) const { return this->WithY(other.top, other.bottom); }
};

struct PointDimension {
  int x = 0;
  int y = 0;
  int width = 0;
  int height = 0;
};
 
#endif /* GEOMETRY_TYPE_HPP */