tile_converters.hpp

Go to the documentation of this file.

#pragma once
 
#include <map>
 
#include "porytiles2/domain/models/color_index.hpp"
#include "porytiles2/domain/models/color_index_map.hpp"
#include "porytiles2/domain/models/pixel_tile.hpp"
#include "porytiles2/domain/models/shape_mask.hpp"
#include "porytiles2/domain/models/shape_tile.hpp"
#include "porytiles2/xcut/panic/panic.hpp"
 
namespace porytiles2 {
 
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;
}
 
} // 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;
}
 
} // namespace porytiles2