anim_key_frame_mangler.cpp

Go to the documentation of this file.

#include "porytiles/domain/services/anim_key_frame_mangler.hpp"
 
#include <algorithm>
#include <array>
#include <cstdint>
#include <map>
#include <optional>
#include <set>
#include <string>
#include <vector>
 
#include "porytiles/domain/algorithms/tile_converters.hpp"
#include "porytiles/domain/models/canonical_pixel_tile.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/rgba32.hpp"
#include "porytiles/utilities/result/chainable_result.hpp"
#include "porytiles/utilities/result/error.hpp"
#include "porytiles/utilities/text/text_formatter.hpp"
 
namespace {
 
using namespace porytiles;
 
/*
 * Pixel priority order for mangling (least visually impactful first)
 * Corners: (0,0), (0,7), (7,0), (7,7) -> indices 0, 7, 56, 63
 * Corners: (0,0), (0,7), (7,0), (7,7) -> indices 0, 7, 56, 63
 * Top edge: 1-6
 * Left edge: 8, 16, 24, 32, 40, 48
 * Right edge: 15, 23, 31, 39, 47, 55
 * Bottom edge: 57-62
 * Interior: remaining pixels
 */
constexpr std::array<std::size_t, tile::size_pix> pixel_priority_order = {
    // Corners first (least visible)
    0,
    7,
    56,
    63,
    // Top edge
    1,
    2,
    3,
    4,
    5,
    6,
    // Left edge
    8,
    16,
    24,
    32,
    40,
    48,
    // Right edge
    15,
    23,
    31,
    39,
    47,
    55,
    // Bottom edge
    57,
    58,
    59,
    60,
    61,
    62,
    // Interior (most visible, last resort)
    9,
    10,
    11,
    12,
    13,
    14,
    17,
    18,
    19,
    20,
    21,
    22,
    25,
    26,
    27,
    28,
    29,
    30,
    33,
    34,
    35,
    36,
    37,
    38,
    41,
    42,
    43,
    44,
    45,
    46,
    49,
    50,
    51,
    52,
    53,
    54};
 
int color_distance_squared(const Rgba32 &a, const Rgba32 &b)
{
    const int dr = static_cast<int>(a.red()) - static_cast<int>(b.red());
    const int dg = static_cast<int>(a.green()) - static_cast<int>(b.green());
    const int db = static_cast<int>(a.blue()) - static_cast<int>(b.blue());
    return dr * dr + dg * dg + db * db;
}
 
[[nodiscard]] std::vector<std::size_t>
find_alternative_colors_sorted(std::size_t current_color_index, const Palette<Rgba32, pal::max_size> &palette)
{
    struct ColorCandidate {
        std::size_t index;
        int distance;
    };
 
    const Rgba32 current_color = palette.at(current_color_index);
    std::vector<ColorCandidate> candidates;
 
    // Search ALL palette colors (1-15), not just those in the tile
    for (std::size_t candidate_index = 1; candidate_index < pal::max_size; ++candidate_index) {
        if (candidate_index == current_color_index) {
            continue;
        }
 
        const Rgba32 candidate_color = palette.at(candidate_index);
        const int distance = color_distance_squared(current_color, candidate_color);
        candidates.push_back({candidate_index, distance});
    }
 
    std::ranges::sort(candidates, [](const ColorCandidate &a, const ColorCandidate &b) {
        if (a.distance != b.distance) {
            return a.distance < b.distance;
        }
        return a.index < b.index;
    });
 
    std::vector<std::size_t> result;
    result.reserve(candidates.size());
    for (const auto &c : candidates) {
        result.push_back(c.index);
    }
    return result;
}
 
[[nodiscard]] IndexPixel make_mangled_pixel(std::size_t original_palette_index, std::size_t alt_color)
{
    return IndexPixel{(original_palette_index << 4) | alt_color};
}
 
std::optional<std::pair<PixelTile<IndexPixel>, TileMangleRecord>> try_mangle_tile(
    const PixelTile<IndexPixel> &tile,
    std::size_t tile_index,
    const Palette<Rgba32, pal::max_size> &palette,
    const std::set<PixelTile<IndexPixel>> &all_existing_canonical_tiles)
{
    // Phase 1: single-pixel swaps (preferred, minimal visual impact)
    for (std::size_t pixel_index : pixel_priority_order) {
        const IndexPixel original_pixel = tile.at(pixel_index);
 
        const std::vector<std::size_t> alternatives =
            find_alternative_colors_sorted(original_pixel.color_index(), palette);
 
        for (const std::size_t alt_color : alternatives) {
            const IndexPixel mangled_pixel = make_mangled_pixel(original_pixel.palette_index(), alt_color);
 
            PixelTile<IndexPixel> candidate_tile = tile;
            candidate_tile.set(pixel_index, mangled_pixel);
 
            CanonicalPixelTile<IndexPixel> canonical_candidate{candidate_tile};
            const PixelTile<IndexPixel> &candidate_base = canonical_candidate;
            if (!all_existing_canonical_tiles.contains(candidate_base)) {
                TileMangleRecord record{
                    .tile_index = tile_index,
                    .pixel_changes = {PixelMangleChange{
                        .pixel_index = pixel_index, .original_pixel = original_pixel, .mangled_pixel = mangled_pixel}}};
                return std::make_pair(candidate_tile, record);
            }
        }
    }
 
    /*
     * Phase 2: two-pixel swaps (fallback for heavily saturated canonical tile sets).
     * Loop ordering: position pair (p1, p2) outermost, then color alternatives innermost. This ensures we prefer the
     * least visible pixel positions before trying more visible ones, consistent with the Phase 1 priority ordering.
     */
    for (std::size_t p1_idx = 0; p1_idx < pixel_priority_order.size(); ++p1_idx) {
        const std::size_t p1 = pixel_priority_order[p1_idx];
        const IndexPixel p1_original = tile.at(p1);
 
        const std::vector<std::size_t> p1_alternatives =
            find_alternative_colors_sorted(p1_original.color_index(), palette);
 
        for (std::size_t p2_idx = p1_idx + 1; p2_idx < pixel_priority_order.size(); ++p2_idx) {
            const std::size_t p2 = pixel_priority_order[p2_idx];
            const IndexPixel p2_original = tile.at(p2);
 
            const std::vector<std::size_t> p2_alternatives =
                find_alternative_colors_sorted(p2_original.color_index(), palette);
 
            for (const std::size_t p1_alt : p1_alternatives) {
                const IndexPixel p1_mangled = make_mangled_pixel(p1_original.palette_index(), p1_alt);
 
                for (const std::size_t p2_alt : p2_alternatives) {
                    const IndexPixel p2_mangled = make_mangled_pixel(p2_original.palette_index(), p2_alt);
 
                    PixelTile<IndexPixel> candidate_tile = tile;
                    candidate_tile.set(p1, p1_mangled);
                    candidate_tile.set(p2, p2_mangled);
 
                    CanonicalPixelTile<IndexPixel> canonical_candidate{candidate_tile};
                    const PixelTile<IndexPixel> &candidate_base = canonical_candidate;
                    if (!all_existing_canonical_tiles.contains(candidate_base)) {
                        TileMangleRecord record{
                            .tile_index = tile_index,
                            .pixel_changes = {
                                PixelMangleChange{
                                    .pixel_index = p1, .original_pixel = p1_original, .mangled_pixel = p1_mangled},
                                PixelMangleChange{
                                    .pixel_index = p2, .original_pixel = p2_original, .mangled_pixel = p2_mangled}}};
                        return std::make_pair(candidate_tile, record);
                    }
                }
            }
        }
    }
 
    // No valid mangle found
    return std::nullopt;
}
 
} // namespace
 
namespace porytiles {
 
AnimKeyFrameMangler::AnimKeyFrameMangler(
    gsl::not_null<const UserDiagnostics *> diag, gsl::not_null<const TilePrinter *> tile_printer)
    : diag_{diag}, tile_printer_{tile_printer}
{
}
 
ChainableResult<MangleResult> AnimKeyFrameMangler::mangle_duplicates(
    const std::string &anim_name,
    std::vector<PixelTile<IndexPixel>> tiles,
    const std::vector<const Palette<Rgba32, pal::max_size> *> &palettes,
    const Rgba32 &extrinsic_transparency,
    const std::set<PixelTile<IndexPixel>> &existing_canonical_tiles) const
{
    if (palettes.size() != tiles.size()) {
        panic("palettes size " + std::to_string(palettes.size()) + " != tiles size " + std::to_string(tiles.size()));
    }
 
    MangleResult result;
    result.tiles = std::move(tiles);
 
    /*
     * Build a set of all canonical tiles we need to be unique against. This includes the input existing_canonical_tiles
     * plus tiles we've already processed. Using canonical forms ensures tiles that are flip-equivalent are treated as
     * duplicates.
     */
    std::set<PixelTile<IndexPixel>> all_canonical_tiles = existing_canonical_tiles;
 
    // Map to track which canonical tiles we've seen at which indices (for duplicate detection)
    std::map<PixelTile<IndexPixel>, std::size_t> canonical_first_occurrence;
 
    /*
     * Each tile index is visited exactly once. A tile is mangled at most once, producing at most one TileMangleRecord.
     * This guarantees that mangle_records contains non-overlapping entries (no two records share the same tile_index),
     * so they can be applied independently in any order.
     */
    for (std::size_t i = 0; i < result.tiles.size(); ++i) {
        PixelTile<IndexPixel> &current_tile = result.tiles[i];
 
        // Canonicalize the current tile for duplicate checking
        CanonicalPixelTile canonical_current{current_tile};
        const PixelTile<IndexPixel> &current_base = canonical_current;
 
        // Check if this tile is a duplicate (either of existing_canonical_tiles or a previous tile in this batch)
        auto it = canonical_first_occurrence.find(current_base);
        const bool is_duplicate_of_previous = it != canonical_first_occurrence.end();
        const bool is_duplicate_of_existing =
            existing_canonical_tiles.contains(current_base) && !is_duplicate_of_previous;
 
        if (is_duplicate_of_previous || is_duplicate_of_existing) {
            // Need to mangle this tile
            const PixelTile<IndexPixel> original_tile = current_tile;
            const std::optional<std::pair<PixelTile<IndexPixel>, TileMangleRecord>> mangle_result =
                try_mangle_tile(current_tile, i, *palettes[i], all_canonical_tiles);
 
            if (!mangle_result.has_value()) {
                // Could not mangle the tile - this is an error
                std::vector<std::string> err_msg;
                err_msg.push_back(diag_->formatter().format(
                    "Failed to mangle duplicate key frame tile {} in animation '{}'.",
                    FormatParam{i, Style::bold},
                    FormatParam{anim_name, Style::bold}));
                err_msg.emplace_back();
                err_msg.emplace_back("The tile could not be modified to be unique. This may occur if:");
                err_msg.emplace_back("  - All possible pixel swaps still produce duplicate tiles");
                return FormattableError{err_msg};
            }
 
            // Apply the mangle
            current_tile = mangle_result->first;
            result.mangle_records.insert(mangle_result->second);
 
            // Emit a remark about the mangle
            std::vector<std::string> remark_lines;
            for (const auto &change : mangle_result->second.pixel_changes) {
                const auto [pixel_row, pixel_col] = tile::index_to_row_col(change.pixel_index);
                remark_lines.push_back(diag_->formatter().format(
                    "Mangled tile {} in animation '{}': pixel ({},{}) changed from index {} to {}.",
                    FormatParam{i, Style::bold},
                    FormatParam{anim_name, Style::bold},
                    FormatParam{pixel_row},
                    FormatParam{pixel_col},
                    FormatParam{change.original_pixel.index()},
                    FormatParam{change.mangled_pixel.index()}));
            }
 
            const PixelTile<Rgba32> original_rgba =
                color_tile_from_index_tile(original_tile, *palettes[i], extrinsic_transparency);
            const PixelTile<Rgba32> mangled_rgba =
                color_tile_from_index_tile(current_tile, *palettes[i], extrinsic_transparency);
 
            remark_lines.emplace_back("");
            remark_lines.emplace_back("Original tile:");
            remark_lines.append_range(tile_printer_->print_tile(original_rgba, extrinsic_transparency));
 
            remark_lines.emplace_back("Mangled tile:");
            remark_lines.append_range(tile_printer_->print_tile(mangled_rgba, extrinsic_transparency));
 
            diag_->remark("anim-key-frame-mangle", remark_lines);
        }
 
        // Re-canonicalize after potential mangle and add to tracking sets
        CanonicalPixelTile final_canonical{current_tile};
        const PixelTile<IndexPixel> &final_base = final_canonical;
        canonical_first_occurrence.emplace(final_base, i);
        all_canonical_tiles.insert(final_base);
    }
 
    return result;
}
 
} // namespace porytiles