canonical_pixel_tile.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <array>
#include <vector>
 
#include "porytiles/domain/models/pixel_tile.hpp"
#include "porytiles/domain/models/supports_transparency.hpp"
 
namespace porytiles {
 
template <SupportsTransparency PixelType>
class CanonicalPixelTile : public PixelTile<PixelType> {
  public:
    explicit CanonicalPixelTile(const PixelTile<PixelType> &tile) : PixelTile<PixelType>{}
    {
        // Helper struct to store candidate tiles with their flip flags
        struct Candidate {
            PixelTile<PixelType> flipped_tile;
            bool h_flip;
            bool v_flip;
 
            auto operator<=>(const Candidate &other) const
            {
                return flipped_tile <=> other.flipped_tile;
            }
        };
 
        std::array flips = {
            std::pair{false, false}, std::pair{false, true}, std::pair{true, false}, std::pair{true, true}};
 
        std::vector<Candidate> candidates;
        candidates.reserve(4);
 
        for (const auto &[h, v] : flips) {
            candidates.push_back({tile.flip(h, v), h, v});
        }
 
        auto min_candidate = *std::min_element(candidates.begin(), candidates.end());
 
        // Assign the canonical tile data
        *static_cast<PixelTile<PixelType> *>(this) = min_candidate.flipped_tile;
        h_flip_ = min_candidate.h_flip;
        v_flip_ = min_candidate.v_flip;
    }
 
    CanonicalPixelTile(const PixelTile<PixelType> &tile, const PixelType &extrinsic_transparency)
        requires requires(const PixelType &p) { p.is_transparent(p); }
        : PixelTile<PixelType>{}
    {
        struct Candidate {
            PixelTile<PixelType> flipped_tile;
            bool h_flip;
            bool v_flip;
        };
 
        std::array flips = {
            std::pair{false, false}, std::pair{false, true}, std::pair{true, false}, std::pair{true, true}};
 
        std::vector<Candidate> candidates;
        candidates.reserve(4);
        for (const auto &[h, v] : flips) {
            candidates.push_back({tile.flip(h, v), h, v});
        }
 
        auto min_it = std::min_element(
            candidates.begin(), candidates.end(), [&extrinsic_transparency](const Candidate &a, const Candidate &b) {
                return PixelTile<PixelType>::cross_et_compare(
                           a.flipped_tile, extrinsic_transparency, b.flipped_tile, extrinsic_transparency) < 0;
            });
 
        *static_cast<PixelTile<PixelType> *>(this) = min_it->flipped_tile;
        h_flip_ = min_it->h_flip;
        v_flip_ = min_it->v_flip;
    }
 
    auto operator<=>(const CanonicalPixelTile &other) const = default;
 
    [[nodiscard]] bool h_flip() const
    {
        return h_flip_;
    }
 
    [[nodiscard]] bool v_flip() const
    {
        return v_flip_;
    }
 
  private:
    bool h_flip_;
    bool v_flip_;
};
 
} // namespace porytiles