ScreenMetrics.h

Go to the documentation of this file.

#pragma once

#include <array>
#include <iostream>
#include <iomanip>
#include <tuple>
#include <SDL.h>
#include "Constants.h"
#include "Utilities.h"

namespace rose {

    class Size : public std::array<int, 2> {
    public:

        static const Size Zero;     

        constexpr explicit Size(std::array<int, 2> value) noexcept: std::array<int, 2>(value) {}

        constexpr explicit Size(int value = 0) noexcept: Size(std::array<int, 2>({value, value})) {}

        constexpr Size(int width, int height) noexcept: Size(std::array<int, 2>({width, height})) {}

        constexpr Size(const Size &) = default;

        constexpr Size(Size &&) = default;

        constexpr Size& operator=(const Size &) = default;

        constexpr Size& operator=(Size &&) = default;

        constexpr explicit Size(const std::tuple<int,int> &t) noexcept
                : Size(std::get<0>(t), std::get<1>(t)) {}

        constexpr Size& operator=(const std::tuple<int,int> t) noexcept {
            width() = std::get<0>(t);
            height() = std::get<1>(t);
            return *this;
        }

        constexpr int &width() { return operator[](0); }

        [[nodiscard]] constexpr int width() const noexcept { return operator[](0); }

        constexpr int &height() { return operator[](1); }

        [[nodiscard]] constexpr int height() const noexcept { return operator[](1); }

        int &primary(Orientation orientation) {
            switch (orientation) {
                case Orientation::Unset:
                case Orientation::Both:
                case Orientation::Horizontal:
                    break;
                case Orientation::Vertical:
                    return height();
            }
            return width();
        }

        [[nodiscard]] constexpr int primary(Orientation orientation) const noexcept {
            switch (orientation) {
                case Orientation::Unset:
                case Orientation::Both:
                case Orientation::Horizontal:
                    return width();
                case Orientation::Vertical:
                    return height();
            }
        }

        int &secondary(Orientation orientation) {
            switch (orientation) {
                case Orientation::Unset:
                case Orientation::Both:
                case Orientation::Horizontal:
                    return height();
                case Orientation::Vertical:
                    return width();
            }
            return height();
        }

        [[nodiscard]] constexpr int secondary(Orientation orientation) const noexcept {
            switch (orientation) {
                case Orientation::Unset:
                case Orientation::Both:
                case Orientation::Horizontal:
                    return height();
                case Orientation::Vertical:
                    return width();
            }
            return height();
        }

        constexpr Size operator+(const Size &size) const noexcept {
            return Size{width() + size.width(), height() + size.height()};
        }

        constexpr Size operator-(const Size &size) const noexcept {
            return Size{width() - size.width(), height() - size.height()};
        }
    };

    class Position : public std::array<int, 2> {
    public:

        static const Position Zero;     

        constexpr explicit Position(std::array<int, 2> value) noexcept: std::array<int, 2>(value) {}

        constexpr explicit Position(int value = 0) noexcept: Position(std::array<int, 2>({value, value})) {}

        constexpr Position(int x, int y) noexcept: Position(std::array<int, 2>({x, y})) {}

        constexpr Position(const Position &) = default;

        constexpr Position(Position &&) = default;

        constexpr Position& operator=(const Position &) = default;

        constexpr Position& operator=(Position &&) = default;

        constexpr int &x() { return operator[](0); }

        [[nodiscard]] constexpr int x() const noexcept { return operator[](0); }

        constexpr int &y() { return operator[](1); }

        [[nodiscard]] constexpr int y() const noexcept { return operator[](1); }

        int &primary(Orientation orientation) {
            switch (orientation) {
                case Orientation::Unset:
                case Orientation::Both:
                case Orientation::Horizontal:
                    return x();
                case Orientation::Vertical:
                    return y();
            }
            return x();
        }

        [[nodiscard]] constexpr int primary(Orientation orientation) const noexcept {
            switch (orientation) {
                case Orientation::Unset:
                case Orientation::Both:
                case Orientation::Horizontal:
                    return x();
                case Orientation::Vertical:
                    return y();
            }
        }

        int &secondary(Orientation orientation) {
            switch (orientation) {
                case Orientation::Unset:
                case Orientation::Both:
                case Orientation::Horizontal:
                    return y();
                case Orientation::Vertical:
                    return x();
            }
            return y();
        }

        [[nodiscard]] constexpr int secondary(Orientation orientation) const noexcept {
            switch (orientation) {
                case Orientation::Unset:
                case Orientation::Both:
                case Orientation::Horizontal:
                    return y();
                case Orientation::Vertical:
                    return x();
            }
            return y();
        }

        constexpr Position operator+(const Position &position) const noexcept {
            return Position{x() + position.x(), y() + position.y()};
        }

        constexpr Position operator-(const Position &position) const noexcept {
            return Position{x() - position.x(), y() - position.y()};
        }

        [[nodiscard]] constexpr int abs() const noexcept {
            return x() * x() + y() * y();
        }
    };

    class Rectangle : public std::array<int, 4> {
    public:
        static const Rectangle Zero;        

        constexpr explicit Rectangle(std::array<int, 4> value) noexcept: std::array<int, 4>(value) {}

        constexpr explicit Rectangle(int value = 0) noexcept: Rectangle(
                std::array<int, 4>({value, value, value, value})) {}

        constexpr Rectangle(int x, int y, int width, int height) noexcept: Rectangle(
                std::array<int, 4>({x, y, width, height})) {}

        constexpr Rectangle(const Rectangle &) = default;

        constexpr Rectangle(Rectangle &&) = default;

        constexpr Rectangle &operator=(const Rectangle &) = default;

        constexpr Rectangle &operator=(Rectangle &&) = default;

        constexpr Rectangle(const Position &pos, const Size &size) : Rectangle(pos.x(), pos.y(), size.width(),
                                                                               size.height()) {}

        constexpr Rectangle(const std::optional<Position> &pos, const std::optional<Size> &size) : Rectangle() {
            if (pos) {
                x() = pos->x();
                y() = pos->y();
            }
            if (size) {
                width() = size->width();
                height() = size->height();
            }
        }

        constexpr int &x() { return operator[](0); }

        [[nodiscard]] constexpr int x() const noexcept { return operator[](0); }

        constexpr int &y() { return operator[](1); }

        [[nodiscard]] constexpr int y() const noexcept { return operator[](1); }

        constexpr int &width() { return operator[](2); }

        [[nodiscard]] constexpr int width() const noexcept { return operator[](2); }

        constexpr int &height() { return operator[](3); }

        [[nodiscard]] constexpr int height() const noexcept { return operator[](3); }

        constexpr int &positionPrimary(Orientation orientation) {
            if (orientation == Orientation::Horizontal)
                return operator[](0);
            else
                return operator[](1);
        }

        constexpr int &positionSecondary(Orientation orientation) {
            if (orientation == Orientation::Horizontal)
                return operator[](1);
            else
                return operator[](0);
        }

        constexpr int &sizePrimary(Orientation orientation) {
            if (orientation == Orientation::Horizontal)
                return operator[](2);
            else
                return operator[](3);
        }

        constexpr int &sizeSecondary(Orientation orientation) {
            if (orientation == Orientation::Horizontal)
                return operator[](3);
            else
                return operator[](2);
        }

        [[nodiscard]] constexpr Size getSize() const noexcept {
            return Size{width(), height()};
        }

        [[nodiscard]] constexpr Position getPosition() const noexcept {
            return Position{x(), y()};
        }

        [[nodiscard]] constexpr SDL_Rect toSdlRect() const noexcept {
            SDL_Rect rect{};
            rect.x = x();
            rect.y = y();
            rect.w = width();
            rect.h = height();
            return rect;
        }

        constexpr Rectangle &operator=(const Size &size) {
            width() = size.width();
            height() = size.height();
            return *this;
        }

        constexpr Rectangle &operator=(const Position &position) {
            x() = position.x();
            y() = position.y();
            return *this;
        }

        constexpr Rectangle &operator+=(const Position &deltaPos) {
            x() += deltaPos.x();
            y() += deltaPos.y();
            return *this;
        }

        constexpr Rectangle operator+(const Position &deltaPos) {
            Rectangle r{*this};
            r.x() += deltaPos.x();
            r.y() += deltaPos.y();
            return r;
        }

        [[nodiscard]] constexpr Rectangle moveOrigin(const std::optional<Position> &deltaPos) const {
            Rectangle r{*this};
            if (deltaPos) {
                r += deltaPos.value();
                r.width() -= deltaPos->x();
                r.height() -= deltaPos->y();
            }
            return r;
        }

        [[nodiscard]] constexpr bool contains(Position pos) const noexcept {
            return pos.x() >= x() && pos.x() < x() + width() && pos.y() >= y() && pos.y() < y() + height();
        }

        [[nodiscard]] constexpr bool noOverlap(const Rectangle& o) const noexcept {
            return x() > o.x() + o.width() ||
                   o.x() > x() + width() ||
                   y() > o.y() + o.height() ||
                   o.y() > y() + height();
        }

        [[nodiscard]] constexpr bool overlap(const Rectangle& o) const noexcept {
            return !noOverlap(o);
        }

        [[nodiscard]] Rectangle intersection(const Rectangle &o) const {
            // gives bottom-left point
            // of intersection rectangle

            auto x5 = std::max(x(), o.x());
            auto y5 = std::max(y(), o.y());

            // gives top-right point
            // of intersection rectangle
            auto x6 = std::min(x()+width(), o.x()+o.width());
            auto y6 = std::min(y()+height(), o.y()+o.height());

            // no intersection
            if (x5 > x6 || y5 > y6) {
                return Rectangle{0,0,0,0};
            }

            return Rectangle{x5, y5, x6 - x5, y6 - y5};
        }
    };

    class Padding : public std::array<int,4> {
    public:
        static const Padding Zero;        

        constexpr explicit Padding(std::array<int, 4> value) noexcept: std::array<int, 4>(value) {}

        constexpr explicit Padding(int value = 0) noexcept: Padding(
                std::array<int, 4>({value, value, value, value})) {}

        constexpr Padding(int left, int top, int right, int bottom) noexcept: Padding(
                std::array<int, 4>({left, top, right, bottom})) {}


        [[nodiscard]] constexpr int left() const noexcept { return (*this)[0]; }      
        [[nodiscard]] constexpr int right() const noexcept { return (*this)[1]; }     
        [[nodiscard]] constexpr int top() const noexcept { return (*this)[2]; }       
        [[nodiscard]] constexpr int bottom() const noexcept { return (*this)[3]; }    
        [[nodiscard]] constexpr int width() const noexcept { return left() + right(); }    
        [[nodiscard]] constexpr int height() const noexcept { return top() + bottom(); }    

        [[nodiscard]] constexpr Size padSize() const noexcept { return Size{width(),height()}; }
        [[nodiscard]] constexpr Position padPos() const noexcept { return Position{left(), top()}; }

        int& left() noexcept { return (*this)[0]; }          
        int& right() noexcept { return (*this)[1]; }         
        int& top() noexcept { return (*this)[2]; }           
        int& bottom() noexcept { return (*this)[3]; }        

        Padding& operator=(const Padding& other) noexcept {
            std::copy(other.cbegin(), other.cend(), this->begin());
            return *this;
        }

        constexpr Padding& operator=(int value) noexcept {
            for (auto &v : *this) {
                v = value;
            }
            return *this;
        }
    };

    class Line {
    protected:
        Position    mPoint0;            
        Position    mPoint1;            

    public:
        constexpr Line() noexcept : mPoint0(), mPoint1() {}

        constexpr Line(const Position &p0, const Position &p1) : mPoint0(p0), mPoint1(p1) {}

        constexpr Line(const Line &) = default;

        constexpr Line(Line &&) = default;

        constexpr Line& operator=(const Line &) = default;

        constexpr Line &operator=(Line &&) = default;

    };
}

template<typename T, size_t N>
inline std::ostream &operator<<(std::ostream &strm, const std::array<T, N> &array) {
    return rose::util::printScreenMetric<T, N>(strm, array);
}

template<typename T>
inline std::ostream &operator<<(std::ostream &strm, const std::optional<T> &opt) {
    if (opt) {
        if constexpr (std::is_same_v<T, rose::Rectangle>)
            rose::util::printScreenMetric<int, 4>(strm, opt.value());
        if constexpr (std::is_same_v<T, rose::Position> || std::is_same_v<T, rose::Size>)
            rose::util::printScreenMetric<int,2>(strm, opt.value());
    } else
        strm << "(empty)";
    return strm;
}