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/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/panic/panic.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
// 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, palette::max_size> &palette,
    const Rgba32 &extrinsic_transparency)
{
    struct ColorCandidate {
        std::size_t index;
        int distance;
    };
 
    // A color index of 0 resolves to the extrinsic transparency color, not to the color stored in palette slot 0
    const Rgba32 current_color = (current_color_index == 0) ? extrinsic_transparency : 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 < palette::max_size; ++candidate_index) {
        if (candidate_index == current_color_index) {
            continue;
        }
 
        const Rgba32 candidate_color = palette.at(candidate_index);
        if (candidate_color.is_transparent(extrinsic_transparency)) {
            continue;
        }
 
        const int distance = color_distance_squared(current_color, candidate_color);
        if (distance == 0) {
            continue;
        }
 
        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, palette::max_size> &palette,
    const Rgba32 &extrinsic_transparency,
    const std::set<PixelTile<Rgba32>> &existing_canonical_rgba_tiles,
    const std::set<PixelTile<Rgba32>> &batch_canonical_rgba_tiles)
{
    const auto candidate_is_unique = [&](const PixelTile<IndexPixel> &candidate_tile) {
        const PixelTile<Rgba32> candidate_base =
            canonical_color_tile_from_index_tile(candidate_tile, palette, extrinsic_transparency);
        return !existing_canonical_rgba_tiles.contains(candidate_base) &&
               !batch_canonical_rgba_tiles.contains(candidate_base);
    };
 
    // 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, extrinsic_transparency);
 
        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);
 
            if (candidate_is_unique(candidate_tile)) {
                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, extrinsic_transparency);
 
        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, extrinsic_transparency);
 
            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);
 
                    if (candidate_is_unique(candidate_tile)) {
                        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, palette::max_size> *> &palettes,
    const Rgba32 &extrinsic_transparency,
    const std::vector<const std::set<PixelTile<Rgba32>> *> &existing_canonical_rgba_tiles) const
{
    if (palettes.size() != tiles.size()) {
        panic("palettes size " + std::to_string(palettes.size()) + " != tiles size " + std::to_string(tiles.size()));
    }
    if (existing_canonical_rgba_tiles.size() != tiles.size()) {
        panic(
            "existing_canonical_rgba_tiles size " + std::to_string(existing_canonical_rgba_tiles.size()) +
            " != tiles size " + std::to_string(tiles.size()));
    }
 
    MangleResult result;
    result.tiles = std::move(tiles);
 
    // Canonical resolved RGBA forms of the tiles processed so far in this batch. Together with the caller-provided
    // per-tile existing sets, this is the universe each tile must be unique against. Working on resolved colors means
    // tiles that reference different palette slots holding the same color are still treated as duplicates.
    std::set<PixelTile<Rgba32>> batch_canonical_rgba_tiles;
 
    // Map to track which canonical resolved tiles we've seen at which indices (for duplicate detection)
    std::map<PixelTile<Rgba32>, 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];
 
        // Canonical resolved form of the current tile for duplicate checking
        const PixelTile<Rgba32> current_base =
            canonical_color_tile_from_index_tile(current_tile, *palettes[i], extrinsic_transparency);
 
        // Check if this tile is a duplicate (either of the existing tiles or a previous tile in this batch)
        const bool is_duplicate_of_previous = canonical_first_occurrence.contains(current_base);
        const bool is_duplicate_of_existing =
            existing_canonical_rgba_tiles[i]->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],
                extrinsic_transparency,
                *existing_canonical_rgba_tiles[i],
                batch_canonical_rgba_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");
                err_msg.emplace_back("  - The palette does not contain enough distinct opaque colors");
                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 the trackers
        const PixelTile<Rgba32> final_base =
            canonical_color_tile_from_index_tile(current_tile, *palettes[i], extrinsic_transparency);
        canonical_first_occurrence.emplace(final_base, i);
        batch_canonical_rgba_tiles.insert(final_base);
    }
 
    return result;
}
 
} // namespace porytiles