color_index_map.hpp

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <optional>
#include <set>
#include <vector>
 
#include "porytiles/domain/models/animation.hpp"
#include "porytiles/domain/models/color_index.hpp"
#include "porytiles/domain/models/palette.hpp"
#include "porytiles/domain/models/pixel_tile.hpp"
#include "porytiles/domain/models/supports_transparency.hpp"
 
namespace porytiles {
 
template <SupportsTransparency PixelType>
class ColorIndexMap {
  public:
    ColorIndexMap() = default;
 
    [[nodiscard]] std::size_t size() const
    {
        return index_map_.size();
    }
 
    [[nodiscard]] bool empty() const
    {
        return size() == 0;
    }
 
    void add_tile(const PixelTile<PixelType> &tile)
        requires requires(const PixelType &p) { p.is_transparent(); }
    {
        add_colors_impl(tile.unique_nontransparent_colors());
    }
 
    void add_tile(const PixelTile<PixelType> &tile, const PixelType &extrinsic)
        requires requires(const PixelType &p) { p.is_transparent(p); }
    {
        add_colors_impl(tile.unique_nontransparent_colors(extrinsic));
    }
 
    void add_pal(const Palette<PixelType, pal::max_size> &pal)
        requires requires(const PixelType &p) { p.is_transparent(); }
    {
        add_colors_from_pal_impl(pal, [](const PixelType &p) { return p.is_transparent(); });
    }
 
    void add_pal(const Palette<PixelType, pal::max_size> &pal, const PixelType &extrinsic)
        requires requires(const PixelType &p) { p.is_transparent(p); }
    {
        add_colors_from_pal_impl(pal, [&extrinsic](const PixelType &p) { return p.is_transparent(extrinsic); });
    }
 
    void add_pal(const Palette<PixelType> &pal)
        requires requires(const PixelType &p) { p.is_transparent(); }
    {
        add_colors_from_pal_impl(pal, [](const PixelType &p) { return p.is_transparent(); });
    }
 
    void add_pal(const Palette<PixelType> &pal, const PixelType &extrinsic)
        requires requires(const PixelType &p) { p.is_transparent(p); }
    {
        add_colors_from_pal_impl(pal, [&extrinsic](const PixelType &p) { return p.is_transparent(extrinsic); });
    }
 
    void add_anim(const Animation<PixelType> &anim)
        requires requires(const PixelType &p) { p.is_transparent(); }
    {
        if (anim.has_key_frame()) {
            for (const auto &tile : anim.key_frame().tiles()) {
                add_tile(tile);
            }
        }
        for (const auto &[name, frame] : anim.frames()) {
            for (const auto &tile : frame.tiles()) {
                add_tile(tile);
            }
        }
    }
 
    void add_anim(const Animation<PixelType> &anim, const PixelType &extrinsic)
        requires requires(const PixelType &p) { p.is_transparent(p); }
    {
        if (anim.has_key_frame()) {
            for (const auto &tile : anim.key_frame().tiles()) {
                add_tile(tile, extrinsic);
            }
        }
        for (const auto &[name, frame] : anim.frames()) {
            for (const auto &tile : frame.tiles()) {
                add_tile(tile, extrinsic);
            }
        }
    }
 
    [[nodiscard]] std::optional<PixelType> color_at_index(ColorIndex index) const
    {
        auto it = color_map_.find(index);
        if (it != color_map_.end()) {
            return it->second;
        }
        return std::nullopt;
    }
 
    [[nodiscard]] std::optional<ColorIndex> index_at_color(const PixelType &color) const
    {
        auto it = index_map_.find(color);
        if (it != index_map_.end()) {
            return it->second;
        }
        return std::nullopt;
    }
 
  private:
    void add_colors_impl(const std::set<PixelType> &colors)
    {
        auto color_index = size();
        for (const auto &pixel : colors) {
            if (index_map_.insert({pixel, ColorIndex{color_index}}).second) {
                color_map_.insert({ColorIndex{color_index}, pixel});
                ++color_index;
            }
        }
    }
 
    template <std::size_t N, typename TransparencyPredicate>
    void add_colors_from_pal_impl(const Palette<PixelType, N> &pal, TransparencyPredicate is_transparent_pred)
    {
        auto color_index = size();
        for (std::size_t i = 0; i < pal.size(); i++) {
            auto color_opt = pal.at_optional(i);
            if (!color_opt.has_value()) {
                continue; // Skip wildcards
            }
            const auto &color = color_opt.value();
            if (is_transparent_pred(color)) {
                continue; // Skip transparent colors
            }
            if (index_map_.insert({color, ColorIndex{color_index}}).second) {
                color_map_.insert({ColorIndex{color_index}, color});
                ++color_index;
            }
        }
    }
 
    std::map<PixelType, ColorIndex> index_map_;
    std::map<ColorIndex, PixelType> color_map_;
};
 
} // namespace porytiles