palette.hpp

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <cstddef>
#include <map>
#include <optional>
#include <string>
#include <type_traits>
#include <vector>
 
#include "porytiles/domain/models/palette_index.hpp"
#include "porytiles/domain/models/supports_transparency.hpp"
#include "porytiles/utilities/panic/panic.hpp"
 
namespace porytiles {
 
namespace palette {
 
inline constexpr std::size_t max_size = 16;
 
inline constexpr std::size_t num_palettes = 16;
 
} // namespace palette
 
template <SupportsTransparency ColorType, std::size_t N = 0>
class Palette {
  public:
    using StorageType =
        std::conditional_t<N == 0, std::vector<std::optional<ColorType>>, std::array<std::optional<ColorType>, N>>;
 
    Palette() = default;
 
    explicit Palette(std::vector<ColorType> colors)
        requires(N == 0)
    {
        for (auto &color : colors) {
            colors_.push_back(std::move(color));
        }
    }
 
    explicit Palette(std::array<ColorType, N> colors)
        requires(N > 0)
    {
        for (std::size_t i = 0; i < N; i++) {
            colors_[i] = std::move(colors[i]);
        }
    }
 
    explicit Palette(ColorType color)
    {
        if constexpr (N == 0) {
            for (std::size_t i = 0; i < palette::max_size; i++) {
                colors_.push_back(color);
            }
        }
        else {
            for (std::size_t i = 0; i < N; i++) {
                colors_[i] = color;
            }
        }
    }
 
    void add(ColorType color)
    {
        static_assert(N == 0, "add() is not available for fixed-size Palette");
        colors_.push_back(color);
    }
 
    void add_wildcard()
    {
        static_assert(N == 0, "add_wildcard() is not available for fixed-size Palette");
        colors_.push_back(std::nullopt);
    }
 
    void set(std::size_t index, ColorType color)
    {
        if (index >= size()) {
            panic("index " + std::to_string(index) + " >= size " + std::to_string(size()));
        }
        colors_.at(index) = color;
    }
 
    void set_wildcard(std::size_t index)
    {
        if (index >= size()) {
            panic("index " + std::to_string(index) + " >= size " + std::to_string(size()));
        }
        colors_.at(index) = std::nullopt;
    }
 
    [[nodiscard]] bool is_wildcard(std::size_t index) const
    {
        if (index >= size()) {
            panic("index " + std::to_string(index) + " >= size " + std::to_string(size()));
        }
        return !colors_.at(index).has_value();
    }
 
    [[nodiscard]] bool has_any_wildcards() const
    {
        for (std::size_t i = 0; i < size(); i++) {
            if (!colors_.at(i).has_value()) {
                return true;
            }
        }
        return false;
    }
 
    [[nodiscard]] std::size_t size() const
    {
        if constexpr (N == 0) {
            return colors_.size();
        }
        else {
            return N;
        }
    }
 
    [[nodiscard]] ColorType slot_zero_color() const
    {
        if (size() == 0) {
            panic("palette had zero size");
        }
        if (!colors_.at(0).has_value()) {
            panic("slot 0 is a wildcard");
        }
        return colors_.at(0).value();
    }
 
    [[nodiscard]] ColorType at(std::size_t index) const
    {
        if (index >= size()) {
            panic("index " + std::to_string(index) + " >= size " + std::to_string(size()));
        }
        if (!colors_.at(index).has_value()) {
            panic("slot " + std::to_string(index) + " is a wildcard");
        }
        return colors_.at(index).value();
    }
 
    [[nodiscard]] std::optional<ColorType> at_optional(std::size_t index) const
    {
        if (index >= size()) {
            panic("index " + std::to_string(index) + " >= size " + std::to_string(size()));
        }
        return colors_.at(index);
    }
 
    [[nodiscard]] std::map<ColorType, PaletteIndex> color_to_index_map() const
    {
        std::map<ColorType, PaletteIndex> result{};
        for (std::size_t i = 1; i < size(); i++) {
            if (colors_.at(i).has_value()) {
                result.emplace(colors_.at(i).value(), PaletteIndex{i});
            }
        }
        return result;
    }
 
    [[nodiscard]] std::map<PaletteIndex, ColorType> index_to_color_map() const
    {
        std::map<PaletteIndex, ColorType> result{};
        for (std::size_t i = 1; i < size(); i++) {
            if (colors_.at(i).has_value()) {
                result.emplace(PaletteIndex{i}, colors_.at(i).value());
            }
        }
        return result;
    }
 
  private:
    StorageType colors_{};
};
 
} // namespace porytiles