metatile.hpp

Go to the documentation of this file.

#pragma once
 
#include <array>
 
#include "porytiles2/domain/models/pixel_tile.hpp"
#include "porytiles2/domain/models/supports_transparency.hpp"
#include "porytiles2/utilities/text/text_formatter.hpp"
 
namespace porytiles2 {
 
namespace metatile {
 
inline constexpr std::size_t tiles_per_side = 2;
inline constexpr std::size_t tiles_per_metatile_layer = tiles_per_side * tiles_per_side;
inline constexpr std::size_t tiles_per_metatile = tiles_per_metatile_layer * 3;
inline constexpr std::size_t side_length_pix = tiles_per_side * tile::side_length_pix;
inline constexpr std::size_t entries_per_metatile_dual = 8;
inline constexpr std::size_t entries_per_metatile_triple = 12;
 
enum class Layer : std::uint8_t { bottom = 0, middle = 1, top = 2 };
 
inline std::string to_string(Layer layer)
{
    switch (layer) {
    case Layer::bottom:
        return "bottom";
    case Layer::middle:
        return "middle";
    case Layer::top:
        return "top";
    }
    panic("unhandled Layer value");
}
 
enum class Subtile : std::uint8_t { northwest = 0, northeast = 1, southwest = 2, southeast = 3 };
 
inline std::string to_string(Subtile layer)
{
    switch (layer) {
    case Subtile::northwest:
        return "northwest(" + std::to_string(static_cast<std::uint8_t>(layer)) + ")";
    case Subtile::northeast:
        return "northeast(" + std::to_string(static_cast<std::uint8_t>(layer)) + ")";
    case Subtile::southwest:
        return "southwest(" + std::to_string(static_cast<std::uint8_t>(layer)) + ")";
    case Subtile::southeast:
        return "southeast(" + std::to_string(static_cast<std::uint8_t>(layer)) + ")";
    }
    panic("unhandled Subtile value");
}
 
[[nodiscard]] inline std::tuple<std::size_t, Layer, Subtile> from_tile_index(std::size_t tile_index)
{
    const std::size_t metatile_index = tile_index / tiles_per_metatile;
    const std::size_t local_index = tile_index % tiles_per_metatile;
    const auto layer = static_cast<Layer>(local_index / tiles_per_metatile_layer);
    const auto subtile = static_cast<Subtile>(local_index % tiles_per_metatile_layer);
 
    return {metatile_index, layer, subtile};
}
 
[[nodiscard]] inline std::string message_header(
    std::size_t index,
    Layer layer,
    Subtile subtile,
    std::size_t subtile_row,
    std::size_t subtile_col,
    const TextFormatter &format)
{
    return format.format(
        "{} {}|{}|{}|{},{}",
        FormatParam{"metatile", Style::bold},
        FormatParam{index, Style::bold},
        FormatParam{to_string(layer), Style::bold},
        FormatParam{to_string(subtile), Style::bold},
        FormatParam{std::to_string(subtile_row), Style::bold},
        FormatParam{std::to_string(subtile_col), Style::bold});
}
 
} // namespace metatile
 
template <SupportsTransparency PixelType>
class Metatile {
  public:
    Metatile() : id_{} {}
 
    bool operator==(const Metatile &) const = default;
 
    [[nodiscard]] bool is_transparent() const
        requires requires(const PixelType &p) { p.is_transparent(); }
    {
        const bool bottom_transparent =
            std::ranges::all_of(bottom(), [](const auto &tile) { return tile.is_transparent(); });
        const bool middle_transparent =
            std::ranges::all_of(middle(), [](const auto &tile) { return tile.is_transparent(); });
        const bool top_transparent = std::ranges::all_of(top(), [](const auto &tile) { return tile.is_transparent(); });
        return bottom_transparent && middle_transparent && top_transparent;
    }
 
    [[nodiscard]] bool is_transparent(const PixelType &extrinsic) const
        requires requires(const PixelType &p) { p.is_transparent(p); }
    {
        const bool bottom_transparent =
            std::ranges::all_of(bottom(), [=](const auto &tile) { return tile.is_transparent(extrinsic); });
        const bool middle_transparent =
            std::ranges::all_of(middle(), [=](const auto &tile) { return tile.is_transparent(extrinsic); });
        const bool top_transparent =
            std::ranges::all_of(top(), [=](const auto &tile) { return tile.is_transparent(extrinsic); });
        return bottom_transparent && middle_transparent && top_transparent;
    }
 
    [[nodiscard]] std::array<PixelTile<PixelType>, metatile::tiles_per_metatile> decompose() const
    {
        std::array<PixelTile<PixelType>, metatile::tiles_per_metatile> tiles{};
 
        auto out_it = tiles.begin();
        out_it = std::ranges::copy(bottom(), out_it).out;
        out_it = std::ranges::copy(middle(), out_it).out;
        std::ranges::copy(top(), out_it);
 
        return tiles;
    }
 
    [[nodiscard]] const PixelTile<PixelType> &bottom(std::size_t i) const
    {
        if (i > 3) {
            panic(fmt::format("index {} out of bounds: must be [0,3]", i));
        }
        return bottom_[i];
    }
 
    [[nodiscard]] const std::array<PixelTile<PixelType>, metatile::tiles_per_metatile_layer> &bottom() const
    {
        return bottom_;
    }
 
    void set_bottom(std::size_t i, PixelTile<PixelType> tile)
    {
        if (i > 3) {
            panic(fmt::format("index {} out of bounds: must be [0,3]", i));
        }
        bottom_[i] = std::move(tile);
    }
 
    [[nodiscard]] const PixelTile<PixelType> &middle(std::size_t i) const
    {
        if (i > 3) {
            panic(fmt::format("index {} out of bounds: must be [0,3]", i));
        }
        return middle_[i];
    }
 
    [[nodiscard]] const std::array<PixelTile<PixelType>, metatile::tiles_per_metatile_layer> &middle() const
    {
        return middle_;
    }
 
    void set_middle(std::size_t i, PixelTile<PixelType> tile)
    {
        if (i > 3) {
            panic(fmt::format("index {} out of bounds: must be [0,3]", i));
        }
        middle_[i] = std::move(tile);
    }
 
    [[nodiscard]] const PixelTile<PixelType> &top(std::size_t i) const
    {
        if (i > 3) {
            panic(fmt::format("index {} out of bounds: must be [0,3]", i));
        }
        return top_[i];
    }
 
    [[nodiscard]] const std::array<PixelTile<PixelType>, metatile::tiles_per_metatile_layer> &top() const
    {
        return top_;
    }
 
    void set_top(std::size_t i, PixelTile<PixelType> tile)
    {
        if (i > 3) {
            panic(fmt::format("index {} out of bounds: must be [0,3]", i));
        }
        top_[i] = std::move(tile);
    }
 
  private:
    std::array<PixelTile<PixelType>, metatile::tiles_per_metatile_layer> bottom_;
    std::array<PixelTile<PixelType>, metatile::tiles_per_metatile_layer> middle_;
    std::array<PixelTile<PixelType>, metatile::tiles_per_metatile_layer> top_;
    unsigned int id_;
};
 
namespace metatile {
 
template <typename T>
[[nodiscard]] std::vector<PixelTile<T>> decompose(const std::vector<Metatile<T>> &metatiles)
{
    std::vector<PixelTile<T>> tiles;
    tiles.reserve(metatiles.size() * tiles_per_metatile);
    for (const auto &mt : metatiles) {
        tiles.append_range(mt.decompose());
    }
    return tiles;
 
    // This is a less performant version that uses std::ranges
    //
    // auto tiles = metatiles
    //     | std::views::transform([](const auto& mt) { return mt.decompose(); })
    //     | std::views::join
    //     | std::ranges::to<std::vector>();
    //
    // This transforms each Metatile to a vector<Tile>, flattens (joins) all the vectors together, and collects into a
    // final vector<Tile>.
}
 
} // namespace metatile
 
} // namespace porytiles2