metatile.hpp

Go to the documentation of this file.

#pragma once
 
#include <array>
 
#include "porytiles/domain/models/layer.hpp"
#include "porytiles/domain/models/pixel_tile.hpp"
#include "porytiles/domain/models/supports_transparency.hpp"
#include "porytiles/utilities/panic/panic.hpp"
#include "porytiles/utilities/string_utils.hpp"
#include "porytiles/utilities/text/text_formatter.hpp"
 
namespace porytiles {
 
// Forward-declared to keep this widely-included header free of the Image header. metatile_count is a template, so the
// definition only needs a complete Image template at the call site.
template <typename PixelType>
class Image;
 
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;
inline constexpr std::size_t metatiles_per_row = 8;
 
template <typename PixelType>
[[nodiscard]] std::size_t metatile_count(const Image<PixelType> &layer)
{
    return (layer.width() / side_length_pix) * (layer.height() / side_length_pix);
}
 
enum class Layer : std::uint8_t { bottom = 0, middle = 1, top = 2 };
 
[[nodiscard]] 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");
}
 
inline std::ostream &operator<<(std::ostream &os, const Layer &layer)
{
    os << to_string(layer);
    return os;
}
 
[[nodiscard]] inline Layer dropped_layer_for(LayerType layer_type)
{
    switch (layer_type) {
    case LayerType::normal:
        return Layer::bottom;
    case LayerType::covered:
        return Layer::top;
    case LayerType::split:
        return Layer::middle;
    }
    panic("unhandled LayerType value in dropped_layer_for");
}
 
enum class Subtile : std::uint8_t { northwest = 0, northeast = 1, southwest = 2, southeast = 3 };
 
[[nodiscard]] inline Subtile subtile_from_index(std::size_t i)
{
    return static_cast<Subtile>(i);
}
 
[[nodiscard]] 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");
}
 
inline std::ostream &operator<<(std::ostream &os, const Subtile &subtile)
{
    os << to_string(subtile);
    return os;
}
 
[[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::tuple<Layer, Subtile> from_internal_tile_index(std::size_t tile_index)
{
    if (tile_index >= tiles_per_metatile) {
        panic("tile_index (" + std::to_string(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 {layer, subtile};
}
 
[[nodiscard]] inline std::string message_header(
    const TextFormatter &format,
    std::size_t index,
    Layer layer,
    Subtile subtile,
    std::size_t subtile_row,
    std::size_t subtile_col)
{
    return format.format(
        "{} {}({})|{}|{}|{},{}",
        FormatParam{"metatile"},
        FormatParam{int_to_hex_str(index)},
        FormatParam{index},
        FormatParam{to_string(layer)},
        FormatParam{to_string(subtile)},
        FormatParam{std::to_string(subtile_row)},
        FormatParam{std::to_string(subtile_col)});
}
 
[[nodiscard]] inline std::string
message_header(const TextFormatter &format, std::size_t index, Layer layer, Subtile subtile)
{
    return format.format(
        "{} {}({})|{}|{}",
        FormatParam{"metatile"},
        FormatParam{int_to_hex_str(index)},
        FormatParam{index},
        FormatParam{to_string(layer)},
        FormatParam{to_string(subtile)});
}
 
[[nodiscard]] inline std::string message_header(const TextFormatter &format, std::size_t index, Subtile subtile)
{
    return format.format(
        "{} {}({})|{}",
        FormatParam{"metatile"},
        FormatParam{int_to_hex_str(index)},
        FormatParam{index},
        FormatParam{to_string(subtile)});
}
 
} // 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]] LayerMode infer_layer_mode() const
        requires requires(const PixelType &p) { p.is_transparent(); }
    {
        return infer_layer_mode_impl([](const PixelType &pixel) { return pixel.is_transparent(); });
    }
 
    [[nodiscard]] LayerMode infer_layer_mode(const PixelType &extrinsic) const
        requires requires(const PixelType &p) { p.is_transparent(p); }
    {
        return infer_layer_mode_impl([&extrinsic](const PixelType &pixel) { return pixel.is_transparent(extrinsic); });
    }
 
    [[nodiscard]] LayerType infer_layer_type() const
        requires requires(const PixelType &p) { p.is_transparent(); }
    {
        return infer_layer_type_impl([](const PixelType &pixel) { return pixel.is_transparent(); });
    }
 
    [[nodiscard]] LayerType infer_layer_type(const PixelType &extrinsic) const
        requires requires(const PixelType &p) { p.is_transparent(p); }
    {
        return infer_layer_type_impl([&extrinsic](const PixelType &pixel) { return pixel.is_transparent(extrinsic); });
    }
 
    [[nodiscard]] const PixelTile<PixelType> &bottom(std::size_t i) const
    {
        if (i > 3) {
            panic(std::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(std::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(std::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(std::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(std::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(std::format("index {} out of bounds: must be [0,3]", i));
        }
        top_[i] = std::move(tile);
    }
 
  private:
    template <typename TransparencyPredicate>
    [[nodiscard]] bool layer_has_content(
        const std::array<PixelTile<PixelType>, metatile::tiles_per_metatile_layer> &layer,
        TransparencyPredicate is_transparent_pred) const
    {
        return std::ranges::any_of(layer, [&is_transparent_pred](const auto &tile) {
            return std::ranges::any_of(
                tile.pix(), [&is_transparent_pred](const auto &pixel) { return !is_transparent_pred(pixel); });
        });
    }
 
    template <typename TransparencyPredicate>
    [[nodiscard]] LayerMode infer_layer_mode_impl(TransparencyPredicate is_transparent_pred) const
    {
        const bool bottom_has_content = layer_has_content(bottom_, is_transparent_pred);
        const bool middle_has_content = layer_has_content(middle_, is_transparent_pred);
        const bool top_has_content = layer_has_content(top_, is_transparent_pred);
 
        if (bottom_has_content && middle_has_content && top_has_content) {
            return LayerMode::triple;
        }
        return LayerMode::dual;
    }
 
    template <typename TransparencyPredicate>
    [[nodiscard]] LayerType infer_layer_type_impl(TransparencyPredicate is_transparent_pred) const
    {
        // If triple-layer mode, always return normal
        const LayerMode mode = infer_layer_mode_impl(is_transparent_pred);
        if (mode == LayerMode::triple) {
            return LayerType::normal;
        }
 
        // For dual-layer mode, determine which layers have content
        const bool bottom_has_content = layer_has_content(bottom_, is_transparent_pred);
        const bool middle_has_content = layer_has_content(middle_, is_transparent_pred);
        const bool top_has_content = layer_has_content(top_, is_transparent_pred);
 
        // Apply the case logic
        if (bottom_has_content && !middle_has_content && top_has_content) {
            // Case 6: bottom/top content -> split
            return LayerType::split;
        }
        if (bottom_has_content && (middle_has_content || !top_has_content)) {
            // Case 1: bottom only -> covered
            // Case 5: bottom/middle content -> covered
            return LayerType::covered;
        }
        // All other cases (including no content) -> normal
        // Case 0: completely transparent -> normal
        // Case 2: middle only -> normal
        // Case 3: top only -> normal
        // Case 4: middle/top content -> normal
        return LayerType::normal;
    }
 
    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_;
    std::size_t 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 porytiles