animation.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <optional>
#include <ranges>
#include <set>
#include <string>
#include <string_view>
#include <vector>
 
#include "porytiles/domain/models/anim_frame.hpp"
#include "porytiles/domain/models/anim_params.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 {
 
namespace anim {
 
constexpr std::string g_tileset_anims_prefix = "gTilesetAnims_";
constexpr std::string s_tileset_anims_prefix = "sTilesetAnims_";
constexpr std::string porytiles_managed_prefix = "PorytilesManaged_";
 
// "InitTilesetAnim_PorytilesManaged_": prefix of the init callback symbol Porytiles generates for a managed
// tileset (i.e. "InitTilesetAnim_" + porytiles_managed_prefix). Used for both constructing and detecting it.
constexpr std::string_view porytiles_managed_callback_prefix = "InitTilesetAnim_PorytilesManaged_";
 
// Builds the Porytiles-managed init-callback symbol name for a tileset, e.g.
// "gTileset_velvet_forest" -> "InitTilesetAnim_PorytilesManaged_VelvetForest".
[[nodiscard]] inline std::string managed_callback_name(const std::string &tileset_name)
{
    return std::string{porytiles_managed_callback_prefix} + extract_tileset_cased_name(tileset_name).to_pascal_case();
}
 
[[nodiscard]] inline std::string message_header(
    const TextFormatter &format,
    const std::string &anim_name,
    const std::string &frame_name,
    std::size_t internal_tile_index,
    std::size_t subtile_row,
    std::size_t subtile_col)
{
    return format.format(
        "{} '{}' | frame '{}' | subtile {} | pixel {},{}",
        FormatParam{"anim"},
        FormatParam{anim_name},
        FormatParam{frame_name},
        FormatParam{std::to_string(internal_tile_index)},
        FormatParam{std::to_string(subtile_row)},
        FormatParam{std::to_string(subtile_col)});
}
 
[[nodiscard]] inline std::string message_header(
    const TextFormatter &format,
    const std::string &anim_name,
    const std::string &frame_name,
    std::size_t internal_tile_index)
{
    return format.format(
        "{} '{}' | frame '{}' | subtile {}",
        FormatParam{"anim"},
        FormatParam{anim_name},
        FormatParam{frame_name},
        FormatParam{std::to_string(internal_tile_index)});
}
 
} // namespace anim
 
template <SupportsTransparency PixelType>
class Animation {
  public:
    Animation() = default;
 
    explicit Animation(std::string name) : name_{std::move(name)} {}
 
    Animation(std::string name, AnimParams params) : name_{std::move(name)}, params_{std::move(params)} {}
 
    [[nodiscard]] const std::string &name() const
    {
        return name_;
    }
 
    [[nodiscard]] const AnimParams &params() const
    {
        return params_;
    }
 
    void params(AnimParams params)
    {
        params_ = std::move(params);
    }
 
    [[nodiscard]] bool has_key_frame() const
    {
        return key_frame_.has_value();
    }
 
    [[nodiscard]] const AnimFrame<PixelType> &key_frame() const
    {
        if (!key_frame_.has_value()) {
            panic("key_frame() called on Animation with no key frame set");
        }
        return *key_frame_;
    }
 
    void key_frame(AnimFrame<PixelType> key_frame)
    {
        key_frame_ = std::move(key_frame);
    }
 
    [[nodiscard]] const std::map<std::string, AnimFrame<PixelType>> &frames() const
    {
        return frames_;
    }
 
    [[nodiscard]] std::map<std::string, AnimFrame<PixelType>> &frames()
    {
        return frames_;
    }
 
    [[nodiscard]] std::vector<AnimFrame<PixelType>> frames_values() const
    {
        return frames_ | std::views::values | std::ranges::to<std::vector>();
    }
 
    [[nodiscard]] bool has_frames() const
    {
        return !frames_.empty();
    }
 
    [[nodiscard]] std::size_t frame_count() const
    {
        return frames_.size();
    }
 
    bool has_frame(const std::string &frame_name)
    {
        return frames_.contains(frame_name);
    }
 
    [[nodiscard]] const AnimFrame<PixelType> &frame_for_name(const std::string &frame_name) const
    {
        if (!frames_.contains(frame_name)) {
            panic("anim '" + name_ + "' has no such frame '" + frame_name + "'");
        }
        return frames_.at(frame_name);
    }
 
    void put_frame(const std::string &name, AnimFrame<PixelType> frame)
    {
        frames_.emplace(name, std::move(frame));
    }
 
    [[nodiscard]] AnimFrame<PixelType> composite_frame(const PixelType &extrinsic_transparency) const
        requires requires(const PixelType &p) { p.is_transparent(p); }
    {
        // Note: this method currently only supports extrinsic transparency (Rgba32). If a future caller needs the same
        // logic for IndexPixel (intrinsic transparency), this would need to be extended — but no caller exists today,
        // so the function is constrained via the requires-clause to the Rgba32 case.
 
        // Determine tile count from key frame or first regular frame
        std::size_t tile_count = 0;
        if (has_key_frame()) {
            tile_count = key_frame().tile_count();
        }
        else if (has_frames()) {
            tile_count = frames_.begin()->second.tile_count();
        }
        else {
            panic("composite_frame() called on Animation with no key frame and no frames");
        }
 
        AnimFrame<PixelType> composite{"composite"};
 
        for (std::size_t tile_idx = 0; tile_idx < tile_count; ++tile_idx) {
            std::set<PixelType> all_colors;
 
            // Collect from key frame (if present)
            if (has_key_frame()) {
                auto key_colors = key_frame().tile_at(tile_idx).unique_nontransparent_colors(extrinsic_transparency);
                all_colors.merge(key_colors);
            }
 
            // Collect from regular frames
            for (const auto &[name, frame] : frames_) {
                auto colors = frame.tile_at(tile_idx).unique_nontransparent_colors(extrinsic_transparency);
                all_colors.merge(colors);
            }
 
            // Create composite tile with all colors packed arbitrarily, first pixel is guaranteed extrinsic_transparent
            PixelTile<PixelType> composite_tile{extrinsic_transparency};
            std::size_t pix_idx = 1;
            for (const auto &color : all_colors) {
                if (pix_idx >= tile::size_pix) {
                    panic("pix_idx exceeded tile size in pixels");
                }
                composite_tile.set(pix_idx++, color);
            }
 
            if (composite_tile.unique_nontransparent_colors(extrinsic_transparency).size() >= palette::max_size) {
                panic("composite tile had >= 16 colors");
            }
 
            composite.add_tile(std::move(composite_tile));
        }
 
        return composite;
    }
 
  private:
    std::string name_;
    AnimParams params_;
    std::optional<AnimFrame<PixelType>> key_frame_;
    std::map<std::string, AnimFrame<PixelType>> frames_;
};
 
} // namespace porytiles