sprite_strip.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/runtime/crypto.hpp>
 
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>
 
namespace pulp::view {

class SpriteStrip {
public:
    enum class Orientation { vertical, horizontal };
    enum class Source { raw_pixels, image_file };
 
    SpriteStrip() = default;

    void load(const uint8_t* data, size_t data_size,
              int total_width, int total_height,
              int frame_count, Orientation orientation = Orientation::vertical) {
        data_.assign(data, data + data_size);
        // Hashed once here so every paint can draw through a content-keyed,
        // cached decode instead of decoding the whole strip per frame.
        data_key_ = data_.empty() ? std::string{} : runtime::sha256_hex(data_.data(), data_.size());
        decoded_size_known_ = false;
        decoded_width_ = decoded_height_ = 0;
        path_.clear();
        source_ = Source::raw_pixels;
        total_width_ = total_width;
        total_height_ = total_height;
        frame_count_ = frame_count;
        orientation_ = orientation;
        compute_frame_dimensions();
    }

    void load_from_file(std::string file_path,
                        int total_width, int total_height,
                        int frame_count,
                        Orientation orientation = Orientation::vertical) {
        path_ = std::move(file_path);
        data_.clear();
        data_key_.clear();
        source_ = Source::image_file;
        total_width_ = total_width;
        total_height_ = total_height;
        frame_count_ = frame_count;
        orientation_ = orientation;
        compute_frame_dimensions();
    }

    int frame_for_value(float value) const {
        if (frame_count_ <= 0) return 0;
        int idx = static_cast<int>(value * static_cast<float>(frame_count_ - 1) + 0.5f);
        return std::clamp(idx, 0, frame_count_ - 1);
    }

    void frame_offset(int frame, int& x, int& y) const {
        if (orientation_ == Orientation::vertical) {
            x = 0;
            y = frame * frame_height_;
        } else {
            x = frame * frame_width_;
            y = 0;
        }
    }
 
    bool loaded() const {
        if (frame_count_ <= 0) return false;
        return source_ == Source::raw_pixels ? !data_.empty() : !path_.empty();
    }
    Source source() const { return source_; }
    const std::string& path() const { return path_; }
    int frame_count() const { return frame_count_; }
    int frame_width() const { return frame_width_; }
    int frame_height() const { return frame_height_; }
    int total_width() const { return total_width_; }
    int total_height() const { return total_height_; }
    Orientation orientation() const { return orientation_; }
    const uint8_t* data() const { return data_.data(); }
    size_t data_size() const { return data_.size(); }
    const std::string& data_key() const {
        return data_key_;
    }

    void set_decoded_size(int width, int height) {
        decoded_width_ = width;
        decoded_height_ = height;
        decoded_size_known_ = true;
    }
    bool decoded_size_known() const {
        return decoded_size_known_;
    }
    int decoded_width() const {
        return decoded_width_;
    }
    int decoded_height() const {
        return decoded_height_;
    }

    void set_interpolate(bool v) { interpolate_ = v; }
    bool interpolate() const { return interpolate_; }
 
private:
    void compute_frame_dimensions() {
        if (orientation_ == Orientation::vertical) {
            frame_width_ = total_width_;
            frame_height_ = (frame_count_ > 0) ? total_height_ / frame_count_ : 0;
        } else {
            frame_width_ = (frame_count_ > 0) ? total_width_ / frame_count_ : 0;
            frame_height_ = total_height_;
        }
    }
 
    std::vector<uint8_t> data_;
    std::string data_key_;
    bool decoded_size_known_ = false;
    int decoded_width_ = 0;
    int decoded_height_ = 0;
    std::string path_;
    Source source_ = Source::raw_pixels;
    int total_width_ = 0;
    int total_height_ = 0;
    int frame_width_ = 0;
    int frame_height_ = 0;
    int frame_count_ = 0;
    Orientation orientation_ = Orientation::vertical;
    bool interpolate_ = false;
};
 
} // namespace pulp::view