pixel_tile.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <array>
#include <compare>
#include <set>
#include <string>
 
#include "porytiles/domain/models/supports_transparency.hpp"
#include "porytiles/utilities/panic/panic.hpp"
 
namespace porytiles {
 
namespace tile {
 
inline constexpr std::size_t side_length_pix = 8;
inline constexpr std::size_t size_pix = side_length_pix * side_length_pix;
 
[[nodiscard]] constexpr std::pair<std::size_t, std::size_t> index_to_row_col(std::size_t index)
{
    return {index / side_length_pix, index % side_length_pix};
}
 
[[nodiscard]] constexpr std::size_t row_col_to_index(std::size_t row, std::size_t col)
{
    return row * side_length_pix + col;
}
 
} // namespace tile
 
template <SupportsTransparency PixelType>
class PixelTile {
  public:
    virtual ~PixelTile() = default;
 
    PixelTile() : pix_{} {}
 
    explicit PixelTile(std::array<PixelType, tile::size_pix> pix) : pix_{std::move(pix)} {}
 
    explicit PixelTile(const PixelType &fill_value) : pix_{}
    {
        std::fill(pix_.begin(), pix_.end(), fill_value);
    }
 
    auto operator<=>(const PixelTile &) const = default;
 
    [[nodiscard]] bool is_transparent() const
        requires requires(const PixelType &p) { p.is_transparent(); }
    {
        return is_transparent_impl([](const PixelType &pixel) { return pixel.is_transparent(); });
    }
 
    [[nodiscard]] bool is_transparent(const PixelType &extrinsic) const
        requires requires(const PixelType &p) { p.is_transparent(p); }
    {
        return is_transparent_impl([&extrinsic](const PixelType &pixel) { return pixel.is_transparent(extrinsic); });
    }
 
    [[nodiscard]] bool equals_ignoring_transparency(const PixelTile &other) const
        requires requires(const PixelType &p) { p.is_transparent(); }
    {
        auto pred = [](const PixelType &pixel) { return pixel.is_transparent(); };
        return equals_ignoring_transparency_impl(other, pred, pred);
    }
 
    [[nodiscard]] bool equals_ignoring_transparency(const PixelTile &other, const PixelType &extrinsic) const
        requires requires(const PixelType &p) { p.is_transparent(p); }
    {
        auto pred = [&extrinsic](const PixelType &pixel) { return pixel.is_transparent(extrinsic); };
        return equals_ignoring_transparency_impl(other, pred, pred);
    }
 
    [[nodiscard]] bool equals_ignoring_transparency( // NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
        const PixelTile &other, const PixelType &extrinsic, const PixelType &other_extrinsic) const
        requires requires(const PixelType &p) { p.is_transparent(p); }
    {
        return equals_ignoring_transparency_impl(
            other,
            [&extrinsic](const PixelType &pixel) { return pixel.is_transparent(extrinsic); },
            [&other_extrinsic](const PixelType &pixel) { return pixel.is_transparent(other_extrinsic); });
    }
 
    [[nodiscard]] static std::weak_ordering cross_et_compare( // NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
        const PixelTile &a, const PixelType &a_et, const PixelTile &b, const PixelType &b_et)
        requires requires(const PixelType &p) { p.is_transparent(p); }
    {
        for (std::size_t i = 0; i < tile::size_pix; ++i) {
            const auto &pa = a.pix_.at(i);
            const auto &pb = b.pix_.at(i);
            const bool ta = pa.is_transparent(a_et);
            const bool tb = pb.is_transparent(b_et);
            if (ta && tb) {
                continue;
            }
            if (ta) {
                return std::weak_ordering::less;
            }
            if (tb) {
                return std::weak_ordering::greater;
            }
            if (const auto cmp = pa <=> pb; cmp != 0) {
                return cmp;
            }
        }
        return std::weak_ordering::equivalent;
    }
 
    [[nodiscard]] PixelType at(std::size_t i) const
    {
        if (i >= tile::size_pix) {
            panic("index out of bounds: " + std::to_string(i));
        }
        return pix_[i];
    }
 
    [[nodiscard]] PixelType at(std::size_t row, std::size_t col) const
    {
        if (row >= tile::side_length_pix) {
            panic("row index out of bounds: " + std::to_string(row));
        }
        if (col >= tile::side_length_pix) {
            panic("col index out of bounds: " + std::to_string(col));
        }
        return pix_[row * tile::side_length_pix + col];
    }
 
    void set(std::size_t i, const PixelType &p)
    {
        if (i >= tile::size_pix) {
            panic("index out of bounds: " + std::to_string(i));
        }
        pix_[i] = p;
    }
 
    void set(std::size_t row, std::size_t col, const PixelType &p)
    {
        if (row >= tile::side_length_pix) {
            panic("row index out of bounds: " + std::to_string(row));
        }
        if (col >= tile::side_length_pix) {
            panic("col index out of bounds: " + std::to_string(col));
        }
        pix_[row * tile::side_length_pix + col] = p;
    }
 
    [[nodiscard]] PixelTile flip(bool h_flip, bool v_flip) const
    {
        PixelTile flipped_tile{};
        for (std::size_t row = 0; row < tile::side_length_pix; ++row) {
            for (std::size_t col = 0; col < tile::side_length_pix; ++col) {
                const std::size_t src_row = v_flip ? (tile::side_length_pix - 1 - row) : row;
                const std::size_t src_col = h_flip ? (tile::side_length_pix - 1 - col) : col;
                flipped_tile.set(row, col, at(src_row, src_col));
            }
        }
        return flipped_tile;
    }
 
    [[nodiscard]] std::set<PixelType> unique_nontransparent_colors() const
        requires requires(const PixelType &p) { p.is_transparent(); }
    {
        return unique_nontransparent_colors_impl([](const PixelType &pixel) { return pixel.is_transparent(); });
    }
 
    [[nodiscard]] std::set<PixelType> unique_nontransparent_colors(const PixelType &extrinsic) const
        requires requires(const PixelType &p) { p.is_transparent(p); }
    {
        return unique_nontransparent_colors_impl(
            [&extrinsic](const PixelType &pixel) { return pixel.is_transparent(extrinsic); });
    }
 
    [[nodiscard]] const std::array<PixelType, tile::size_pix> &pix() const
    {
        return pix_;
    }
 
  private:
    template <typename TransparencyPredicate>
    [[nodiscard]] bool is_transparent_impl(TransparencyPredicate is_transparent_pred) const
    {
        return std::ranges::all_of(pix(), is_transparent_pred);
    }
 
    template <typename SelfTransparencyPredicate, typename OtherTransparencyPredicate>
    [[nodiscard]] bool equals_ignoring_transparency_impl(
        const PixelTile &other,
        SelfTransparencyPredicate self_is_transparent_pred,
        OtherTransparencyPredicate other_is_transparent_pred) const
    {
        for (std::size_t i = 0; i < tile::size_pix; ++i) {
            const auto &pixel1 = pix_.at(i);
            const auto &pixel2 = other.pix_.at(i);
 
            if (self_is_transparent_pred(pixel1) && other_is_transparent_pred(pixel2)) {
                continue; // Both transparent, consider equal
            }
            if (pixel1 != pixel2) {
                return false; // Different pixels
            }
        }
        return true;
    }
 
    template <typename TransparencyPredicate>
    [[nodiscard]] std::set<PixelType> unique_nontransparent_colors_impl(TransparencyPredicate is_transparent_pred) const
    {
        std::set<PixelType> colors;
        for (const auto &pixel : pix_) {
            if (!is_transparent_pred(pixel)) {
                colors.insert(pixel);
            }
        }
        return colors;
    }
 
    std::array<PixelType, tile::size_pix> pix_;
};
 
} // namespace porytiles