image.hpp

Go to the documentation of this file.

#pragma once
 
#include <format>
#include <optional>
#include <vector>
 
#include "porytiles/domain/models/rgba32.hpp"
#include "porytiles/utilities/panic/panic.hpp"
 
namespace porytiles {
 
template <typename PixelType>
class Image {
  public:
    Image() : Image(0, 0) {}
 
    Image(std::size_t width, std::size_t height) : pixels_(width * height), width_{width}, height_{height} {}
 
    Image(std::size_t width, std::size_t height, std::vector<Rgba32> palette)
        : pixels_(width * height), palette_(std::move(palette)), width_{width}, height_{height}
    {
    }
 
    Image(std::size_t width, std::size_t height, PixelType fill_color)
        : pixels_(width * height, fill_color), width_{width}, height_{height}
    {
    }
 
    [[nodiscard]] PixelType at(std::size_t i) const
    {
        if (const auto s = size(); i >= s) {
            panic(std::format("index {} out of bounds for image size {}", i, s));
        }
        return pixels_[i];
    }
 
    [[nodiscard]] PixelType at(std::size_t row, std::size_t col) const
    {
        if (col >= width_) {
            panic(std::format("col {} out of bounds for image width {}", col, width_));
        }
        if (row >= height_) {
            panic(std::format("row {} out of bounds for image height {}", row, height_));
        }
        return pixels_[row * width_ + col];
    }
 
    void set(std::size_t i, PixelType pixel)
    {
        if (const auto s = size(); i >= s) {
            panic(std::format("index {} out of bounds for image size {}", i, s));
        }
        pixels_[i] = pixel;
    }
 
    void set(std::size_t row, std::size_t col, PixelType pixel)
    {
        if (col >= width_) {
            panic(std::format("col {} out of bounds for image width {}", col, width_));
        }
        if (row >= height_) {
            panic(std::format("row {} out of bounds for image height {}", row, height_));
        }
        pixels_[row * width_ + col] = pixel;
    }
 
    [[nodiscard]] std::size_t width() const
    {
        return width_;
    }
 
    [[nodiscard]] std::size_t height() const
    {
        return height_;
    }
 
    [[nodiscard]] std::size_t size() const
    {
        return pixels_.size();
    }
 
    [[nodiscard]] std::size_t size_in_tiles() const
    {
        if (width_ % 8 != 0) {
            panic(std::format("image width {} is not divisible by 8", width_));
        }
        if (height_ % 8 != 0) {
            panic(std::format("image height {} is not divisible by 8", height_));
        }
        return (width_ / 8) * (height_ / 8);
    }
 
    [[nodiscard]] const std::optional<std::vector<Rgba32>> &palette() const
    {
        return palette_;
    }
 
    void palette(std::vector<Rgba32> palette)
    {
        palette_ = std::move(palette);
    }
 
  private:
    std::vector<PixelType> pixels_;
    std::optional<std::vector<Rgba32>> palette_;
    std::size_t width_;
    std::size_t height_;
};
 
} // namespace porytiles