SpriteAtlas.hpp

Go to the documentation of this file.

#ifndef DONUT_GRAPHICS_SPRITE_ATLAS_HPP
#define DONUT_GRAPHICS_SPRITE_ATLAS_HPP
 
#include <donut/AtlasPacker.hpp>
#include <donut/Color.hpp>
#include <donut/graphics/Image.hpp>
#include <donut/graphics/Texture.hpp>
#include <donut/math.hpp>
 
#include <cassert> // assert
#include <cstddef> // std::size_t
#include <cstdint> // std::uint8_t
#include <vector>  // std::vector
 
namespace donut::graphics {
 
class Renderer; // Forward declaration, to avoid including Renderer.hpp.
 
struct SpriteAtlasOptions {
    bool useLinearFiltering = false;
};
 
class SpriteAtlas {
public:
    using Flip = std::uint8_t;
 
    enum FlipAxis : Flip {
        NO_FLIP = 0,                
        FLIP_HORIZONTALLY = 1 << 0, 
        FLIP_VERTICALLY = 1 << 1,   
    };
 
    struct SpriteId {
    private:
        friend SpriteAtlas;
 
        constexpr explicit SpriteId(std::size_t index) noexcept
            : index(index) {}
 
        std::size_t index;
    };
 
    struct Sprite {
        vec2 position{};     
        vec2 size{};         
        Flip flip = NO_FLIP; 
    };
 
    SpriteAtlas() = default;
 
    explicit SpriteAtlas(const SpriteAtlasOptions& options)
        : options(options) {}
 
    [[nodiscard]] SpriteId insert(Renderer& renderer, const ImageView& image, Flip flip = NO_FLIP) {
        const auto [x, y, resized] = atlasPacker.insertRectangle(image.getWidth(), image.getHeight());
        prepareAtlasTexture(renderer, resized);
 
        atlasTexture.pasteImage2D(image, x, y);
 
        const vec2 position{static_cast<float>(x), static_cast<float>(y)};
        const vec2 size{static_cast<float>(image.getWidth()), static_cast<float>(image.getHeight())};
 
        const std::size_t index = sprites.size();
        sprites.push_back(Sprite{.position = position, .size = size, .flip = flip});
        return SpriteId{index};
    }
 
    [[nodiscard]] SpriteId createSubSprite(SpriteId baseSpriteId, std::size_t offsetX, std::size_t offsetY, std::size_t width, std::size_t height, Flip flip = NO_FLIP) {
        const Sprite& baseSprite = getSprite(baseSpriteId);
        assert(static_cast<float>(offsetX) <= baseSprite.size.x);
        assert(static_cast<float>(offsetY) <= baseSprite.size.y);
        assert(static_cast<float>(width) <= baseSprite.size.x - static_cast<float>(offsetX));
        assert(static_cast<float>(height) <= baseSprite.size.y - static_cast<float>(offsetY));
 
        const vec2 position = baseSprite.position + vec2{static_cast<float>(offsetX), static_cast<float>(offsetY)};
        const vec2 size{static_cast<float>(width), static_cast<float>(height)};
 
        const std::size_t index = sprites.size();
        sprites.push_back(Sprite{.position = position, .size = size, .flip = flip});
        return SpriteId{index};
    }
 
    [[nodiscard]] const Sprite& getSprite(SpriteId id) const {
        assert(id.index < sprites.size());
        return sprites[id.index];
    }
 
    [[nodiscard]] const Texture& getAtlasTexture() const noexcept {
        return atlasTexture;
    }
 
private:
    static constexpr std::size_t INITIAL_RESOLUTION = 128;
    static constexpr std::size_t PADDING = 6;
 
    void prepareAtlasTexture(Renderer& renderer, bool resized) {
        if (atlasTexture) {
            if (resized) {
                atlasTexture.grow2D(renderer, atlasPacker.getResolution(), atlasPacker.getResolution(), Color::INVISIBLE);
            }
        } else {
            atlasTexture = {
                TextureFormat::R8G8B8A8_UNORM,
                atlasPacker.getResolution(),
                atlasPacker.getResolution(),
                {.repeat = false, .useLinearFiltering = options.useLinearFiltering, .useMipmap = false},
            };
            atlasTexture.fill2D(renderer, Color::INVISIBLE);
        }
    }
 
    AtlasPacker<INITIAL_RESOLUTION, PADDING> atlasPacker{};
    Texture atlasTexture{};
    std::vector<Sprite> sprites{};
    SpriteAtlasOptions options{};
};
 
} // namespace donut::graphics
 
#endif