asset_manager.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
namespace pulp::view {
 
// ── Asset Types ─────────────────────────────────────────────────────────────

struct ImageData {
    std::vector<uint8_t> pixels;
    uint32_t width = 0;
    uint32_t height = 0;
 
    bool valid() const { return !pixels.empty() && width > 0 && height > 0; }
    size_t byte_size() const { return pixels.size(); }
};

struct FontData {
    std::vector<uint8_t> data;       // Raw font file bytes
    std::string family_name;
    bool valid() const { return !data.empty(); }
    size_t byte_size() const { return data.size(); }
};

struct ShaderData {
    std::string source;
    std::string error;               // Non-empty if compilation failed
    bool valid() const { return error.empty() && !source.empty(); }
    size_t byte_size() const { return source.size(); }
};

struct BlobData {
    std::vector<uint8_t> data;
    bool valid() const { return !data.empty(); }
    size_t byte_size() const { return data.size(); }
};
 
// ── Asset Manager ───────────────────────────────────────────────────────────
// Centralized resource loading with LRU caching.
//
// Loading sources supported:
//   - File path
//   - Memory buffer
//   - Embedded resource (registered at startup via CMake pulp_add_binary_data)
//   - data: URI (for Three.js bridge compatibility)
//
// All load functions are synchronous. For async loading, use load_async()
// which accepts a completion callback.
 
class AssetManager {
public:
    AssetManager();
    ~AssetManager();

    static AssetManager& instance();
 
    // ── Embedded Resource Registration ──────────────────────────────────────

    void register_embedded(const std::string& name, const uint8_t* data, size_t size);

    bool has_embedded(const std::string& name) const;
 
    // ── Image Loading ───────────────────────────────────────────────────────

    ImageData load_image(const std::string& path);

    ImageData load_image_from_memory(const uint8_t* data, size_t size);

    ImageData load_image_embedded(const std::string& name);

    ImageData load_image_from_data_uri(const std::string& uri);

    static std::vector<uint8_t> decode_data_uri_bytes(std::string_view uri);
 
    // ── Font Loading ────────────────────────────────────────────────────────

    FontData load_font(const std::string& path);

    FontData load_font_embedded(const std::string& name);

    void register_font_family(const std::string& family, const std::string& path_or_name);

    FontData font_for_family(const std::string& family) const;

    void set_font_fallback(std::vector<std::string> families);
    const std::vector<std::string>& font_fallback() const { return font_fallback_; }
 
    // ── Shader Management ───────────────────────────────────────────────────

    ShaderData load_shader(const std::string& path);

    ShaderData load_shader_embedded(const std::string& name);

    void register_shader(const std::string& name, std::string source);

    ShaderData shader(const std::string& name) const;
 
    // ── Generic Blob Loading ────────────────────────────────────────────────

    BlobData load_blob(const std::string& path);

    static constexpr size_t kDefaultMaxFileBytes = size_t{256} * 1024 * 1024;
    void set_max_file_bytes(size_t bytes);
    size_t max_file_bytes() const {
        return max_file_bytes_;
    }

    BlobData load_blob_embedded(const std::string& name);
 
    // ── Async Loading ───────────────────────────────────────────────────────

    void load_image_async(const std::string& path, std::function<void(ImageData)> callback);
 
    // ── Cache Management ────────────────────────────────────────────────────

    void set_max_cache_size(size_t bytes);
    size_t max_cache_size() const { return max_cache_bytes_; }

    size_t cache_usage() const { return cache_bytes_; }

    size_t cache_count() const;

    void clear_cache();

    void evict_lru();
 
    // ── Resolution ──────────────────────────────────────────────────────────

    void set_display_scale(float scale) { display_scale_ = scale; }
    float display_scale() const { return display_scale_; }
 
private:
    struct EmbeddedEntry {
        const uint8_t* data;
        size_t size;
    };
    std::unordered_map<std::string, EmbeddedEntry> embedded_;
 
    // LRU cache: key → (data, byte_size, access_order)
    struct CacheEntry {
        enum class Type { image, font, shader, blob };
        Type type;
        ImageData image;
        FontData font;
        ShaderData shader_data;
        BlobData blob;
        size_t byte_size = 0;
        uint64_t access_time = 0;
    };
    mutable std::unordered_map<std::string, CacheEntry> cache_;
    mutable uint64_t access_counter_ = 0;
    size_t cache_bytes_ = 0;
    size_t max_cache_bytes_ = 64 * 1024 * 1024; // 64 MB
    size_t max_file_bytes_ = kDefaultMaxFileBytes;
    float display_scale_ = 1.0f;
 
    // Font system
    std::unordered_map<std::string, std::string> font_registry_; // family → path/name
    std::vector<std::string> font_fallback_;
 
    mutable std::mutex mutex_;
 
    void touch(CacheEntry& entry) const;
    void add_to_cache(const std::string& key, CacheEntry entry);
    CacheEntry* find_cached(const std::string& key) const;
    std::string resolve_path(const std::string& path) const;
 
    // PNG decoding (minimal — uses stb_image or platform API)
    static ImageData decode_png(const uint8_t* data, size_t size);
    BlobData read_file_bytes(const std::string& path) const;
};
 
} // namespace pulp::view