pixel_tile.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <array>
#include <set>
 
#include "porytiles2/domain/models/supports_transparency.hpp"
#include "porytiles2/xcut/panic/panic.hpp"
 
namespace porytiles2 {
 
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)} {}
 
    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(); }
    {
        return equals_ignoring_transparency_impl(other, [](const PixelType &pixel) { return pixel.is_transparent(); });
    }
 
    [[nodiscard]] bool equals_ignoring_transparency(const PixelTile &other, const PixelType &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); });
    }
 
    [[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 TransparencyPredicate>
    [[nodiscard]] bool
    equals_ignoring_transparency_impl(const PixelTile &other, TransparencyPredicate 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 (is_transparent_pred(pixel1) && 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 porytiles2