tile_converters.hpp

Go to the documentation of this file.

#pragma once
 
#include <map>
 
#include "porytiles/domain/models/canonical_pixel_tile.hpp"
#include "porytiles/domain/models/color_index.hpp"
#include "porytiles/domain/models/color_index_map.hpp"
#include "porytiles/domain/models/index_pixel.hpp"
#include "porytiles/domain/models/palette.hpp"
#include "porytiles/domain/models/pixel_tile.hpp"
#include "porytiles/domain/models/shape_mask.hpp"
#include "porytiles/domain/models/shape_tile.hpp"
#include "porytiles/utilities/panic/panic.hpp"
 
namespace porytiles {
 
namespace details {
 
template <SupportsTransparency PixelType, typename TransparencyPredicate>
[[nodiscard]] ShapeTile<ColorIndex> from_pixel_tile_impl(
    const PixelTile<PixelType> &pixel_tile,
    const ColorIndexMap<PixelType> &color_index_map,
    TransparencyPredicate is_transparent_pred)
{
    // Map from color index to ShapeMask
    std::map<ColorIndex, ShapeMask> index_to_mask;
 
    // Iterate through all pixels
    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 auto pixel = pixel_tile.at(row, col);
 
            // Skip transparent pixels
            if (is_transparent_pred(pixel)) {
                continue;
            }
 
            // Look up the color index
            auto index_opt = color_index_map.index_at_color(pixel);
            if (!index_opt) {
                panic("Pixel not found in ColorIndexMap");
            }
 
            const ColorIndex &index = *index_opt;
 
            // Create mask if it doesn't exist
            if (index_to_mask.find(index) == index_to_mask.end()) {
                index_to_mask[index] = ShapeMask{};
            }
 
            // Set the bit for this position
            index_to_mask[index].set(row, col);
        }
    }
 
    // Build the result ShapeTile
    ShapeTile<ColorIndex> result;
    for (const auto &[index, mask] : index_to_mask) {
        result.set(mask, index);
    }
 
    return result;
}
 
template <SupportsTransparency ColorType, std::size_t N = 0, typename TransparencyPredicate>
[[nodiscard]] PixelTile<IndexPixel> index_tile_from_color_tile_impl(
    const PixelTile<ColorType> &tile, const Palette<ColorType, N> &palette, TransparencyPredicate is_transparent_pred)
{
    // Build a color-to-index map for efficient lookup
    // Note: palette.color_to_index_map() returns PaletteIndex, convert to std::size_t
    std::map<ColorType, std::size_t> color_to_index;
    for (const auto &[color, palette_idx] : palette.color_to_index_map()) {
        color_to_index[color] = palette_idx.value();
    }
 
    // Convert each pixel
    std::array<IndexPixel, tile::size_pix> index_pixels;
 
    for (std::size_t i = 0; i < tile::size_pix; ++i) {
        const auto &pixel = tile.at(i);
 
        if (is_transparent_pred(pixel)) {
            // Transparent pixels map to index 0
            index_pixels[i] = IndexPixel{0};
        }
        else {
            // Non-transparent pixel requires a non-empty palette
            if (palette.size() == 0) {
                panic("non-transparent pixel found but palette is empty");
            }
 
            // Look up the color in the palette
            auto it = color_to_index.find(pixel);
            if (it != color_to_index.end()) {
                index_pixels[i] = IndexPixel{it->second};
            }
            else {
                panic("color not found in palette");
            }
        }
    }
 
    return PixelTile{index_pixels};
}
 
template <SupportsTransparency ColorType, std::size_t N = 0>
[[nodiscard]] PixelTile<ColorType> color_tile_from_index_tile_impl(
    const PixelTile<IndexPixel> &index_tile, const Palette<ColorType, N> &palette, const ColorType &transparent_color)
{
    if (palette.size() == 0) {
        panic("palette is empty");
    }
 
    const auto index_to_color = palette.index_to_color_map();
    std::array<ColorType, tile::size_pix> color_pixels;
 
    for (std::size_t i = 0; i < tile::size_pix; ++i) {
        const auto &index_pixel = index_tile.at(i);
        // Use color_index() to extract the lower 4 bits, which is the actual palette color index.
        // This is critical for true-color mode where the full 8-bit value encodes both palette index (upper 4 bits)
        // and color index (lower 4 bits). For standard 4-bit pixels, color_index() == index().
        const std::size_t color_index = index_pixel.color_index();
 
        if (color_index == 0) {
            // Color index 0 is the transparent slot
            color_pixels[i] = transparent_color;
        }
        else {
            // Look up in index-to-color map for non-zero indices
            auto it = index_to_color.find(PaletteIndex{color_index});
            if (it == index_to_color.end()) {
                panic(
                    "color_index " + std::to_string(color_index) + " out of palette bounds [0, " +
                    std::to_string(palette.size()) + ")");
            }
            color_pixels[i] = it->second;
        }
    }
 
    return PixelTile<ColorType>{color_pixels};
}
 
} // namespace details
 
template <SupportsTransparency PixelType>
[[nodiscard]] ShapeTile<ColorIndex>
from_pixel_tile(const PixelTile<PixelType> &pixel_tile, const ColorIndexMap<PixelType> &color_index_map)
    requires requires(const PixelType &p) { p.is_transparent(); }
{
    return details::from_pixel_tile_impl(
        pixel_tile, color_index_map, [](const PixelType &p) { return p.is_transparent(); });
}
 
template <SupportsTransparency PixelType>
[[nodiscard]] ShapeTile<ColorIndex> from_pixel_tile(
    const PixelTile<PixelType> &pixel_tile, const ColorIndexMap<PixelType> &color_index_map, const PixelType &extrinsic)
    requires requires(const PixelType &p) { p.is_transparent(p); }
{
    return details::from_pixel_tile_impl(
        pixel_tile, color_index_map, [&extrinsic](const PixelType &p) { return p.is_transparent(extrinsic); });
}
 
template <SupportsTransparency PixelType>
[[nodiscard]] PixelTile<PixelType>
from_shape_tile(const ShapeTile<ColorIndex> &shape_tile, const ColorIndexMap<PixelType> &color_index_map)
{
    // Start with a default (transparent) PixelTile
    PixelTile<PixelType> result;
 
    // Track which pixels have been set to detect overlaps
    std::array<bool, tile::size_pix> pixel_set{};
 
    // Iterate through each (ShapeMask, ColorIndex) pair
    for (const auto &[mask, index] : shape_tile.colors()) {
        // Look up the actual color from the ColorIndexMap
        auto color_opt = color_index_map.color_at_index(index);
        if (!color_opt) {
            panic("ColorIndex not found in ColorIndexMap");
        }
 
        const PixelType &color = *color_opt;
 
        // Set all pixels marked by this ShapeMask
        for (std::size_t row = 0; row < tile::side_length_pix; ++row) {
            for (std::size_t col = 0; col < tile::side_length_pix; ++col) {
                if (mask.get(row, col)) {
                    std::size_t pixel_index = row * tile::side_length_pix + col;
 
                    // Check for overlap
                    if (pixel_set[pixel_index]) {
                        panic("Overlapping masks detected in ShapeTile - programmer error");
                    }
 
                    result.set(row, col, color);
                    pixel_set[pixel_index] = true;
                }
            }
        }
    }
 
    return result;
}
 
template <SupportsTransparency PixelType>
[[nodiscard]] ShapeTile<PixelType>
shape_tile_to_pixel_colors(const ShapeTile<ColorIndex> &shape_tile, const ColorIndexMap<PixelType> &color_index_map)
{
    ShapeTile<PixelType> result;
 
    // Iterate through each (ShapeMask, ColorIndex) pair
    for (const auto &[mask, index] : shape_tile.colors()) {
        // Look up the actual color from the ColorIndexMap
        auto color_opt = color_index_map.color_at_index(index);
        if (!color_opt) {
            panic("ColorIndex not found in ColorIndexMap");
        }
 
        const PixelType &color = *color_opt;
 
        // Set the mask with the pixel color in the result
        result.set(mask, color);
    }
 
    return result;
}
 
template <SupportsTransparency ColorType, std::size_t N = 0>
[[nodiscard]] PixelTile<ColorType>
color_tile_from_index_tile(const PixelTile<IndexPixel> &index_tile, const Palette<ColorType, N> &palette)
    requires requires(const ColorType &c) { c.is_transparent(); }
{
    return details::color_tile_from_index_tile_impl(index_tile, palette, ColorType{});
}
 
template <SupportsTransparency ColorType, std::size_t N = 0>
[[nodiscard]] PixelTile<ColorType> color_tile_from_index_tile(
    const PixelTile<IndexPixel> &index_tile, const Palette<ColorType, N> &palette, const ColorType &extrinsic)
    requires requires(const ColorType &c) { c.is_transparent(c); }
{
    return details::color_tile_from_index_tile_impl(index_tile, palette, extrinsic);
}
 
template <SupportsTransparency ColorType, std::size_t N = 0>
[[nodiscard]] PixelTile<IndexPixel>
index_tile_from_color_tile(const PixelTile<ColorType> &tile, const Palette<ColorType, N> &palette)
    requires requires(const ColorType &c) { c.is_transparent(c); }
{
    return details::index_tile_from_color_tile_impl(
        tile, palette, [](const ColorType &c) { return c.is_transparent(); });
}
 
template <SupportsTransparency ColorType, std::size_t N = 0>
[[nodiscard]] PixelTile<IndexPixel> index_tile_from_color_tile(
    const PixelTile<ColorType> &tile, const Palette<ColorType, N> &palette, const ColorType &extrinsic)
    requires requires(const ColorType &c) { c.is_transparent(c); }
{
    return details::index_tile_from_color_tile_impl(
        tile, palette, [&extrinsic](const ColorType &c) { return c.is_transparent(extrinsic); });
}
 
template <SupportsTransparency ColorType, std::size_t N = 0>
[[nodiscard]] PixelTile<ColorType> canonical_color_tile_from_index_tile(
    const PixelTile<IndexPixel> &index_tile, const Palette<ColorType, N> &palette, const ColorType &extrinsic)
    requires requires(const ColorType &c) { c.is_transparent(c); }
{
    const CanonicalPixelTile<ColorType> canonical{color_tile_from_index_tile(index_tile, palette, extrinsic)};
    return static_cast<const PixelTile<ColorType> &>(canonical);
}
 
} // namespace porytiles