texture_mngr.hpp

// By Emil Ernerfeldt 2014-2016
// LICENSE:
//   This software is dual-licensed to the public domain and under the following
//   license: you are granted a perpetual, irrevocable license to copy, modify,
//   publish, and distribute this file as you see fit.
// HISTORY:
//   Created in 2012-10-07 for Ghostel
//   Cleaned up as separate library 2016-02

#pragma once

#include <functional>
#include <memory>
#include <string>
#include <unordered_map>

#include <emilib/gl_lib_fwd.hpp>

namespace emilib {

class DelayedDirWatcher;
using DelayedDirWatcher_UP = std::unique_ptr<DelayedDirWatcher>;

using ImageData = std::unique_ptr<void, std::function<void(void*)>>;

using ImageLoader = std::function<ImageData(const char* path, int* width, int* height, int* comp, int req_comp)>;

ImageData load_image_rgba(const ImageLoader& image_loader, const char* path, size_t* out_width, size_t* out_height);

class TextureMngr
{
public:
    using Recorder = std::function<void(const std::string& name)>;

    TextureMngr(const std::string& gfx_dir, ImageLoader image_loader);
    ~TextureMngr();

    void update();

    gl::Texture_SP prefetch_retain(const std::string& name, const gl::TexParams& params);
    gl::Texture_SP get_retain(const std::string& name, const gl::TexParams& params);
    gl::Texture_SP get_retain(const std::string& name) { return get_retain(name, default_params()); }

    gl::Texture* get(const std::string& name, const gl::TexParams& params);
    gl::Texture* get(const std::string& name) { return get(name, default_params()); }

    gl::Texture* prefetch(const std::string& name, const gl::TexParams& params);
    gl::Texture* prefetch(const std::string& name) { return prefetch(name, default_params()); }

    void prefetch_all(const std::string& sub_folder = "");

    void prepare_eviction();
    void finalize_eviction();

#if 0
    const Texture* store(Texture_UP&& tex);
#endif
    const gl::Texture* black() const;
    const gl::Texture* white() const;

    gl::TexParams default_params() const
    {
#if TARGET_OS_IPHONE
        return gl::TexParams::clamped_linear(); // No need for mipmaps
#else
        return gl::TexParams::clamped();
#endif
    }

    size_t memory_usage(unsigned* out_tex_count) const;

    void print_memory_usage(const char* prefix="") const;

    void start_recording(Recorder recorder);
    void stop_recording();

private:
    struct TexInfo
    {
        std::string    name;
        std::string    abs_path;
        gl::Texture_SP texture;
        bool           used = false;
    };

    void reload(const std::string& name);
    TexInfo* prefetch_tex_info(const std::string& name, const gl::TexParams& params);

private:
    using FileMap = std::unordered_map<std::string, TexInfo>;

    std::string          _gfx_dir;
    ImageLoader          _image_loader;
    DelayedDirWatcher_UP _dir_watcher;
    FileMap              _file_map;
    bool                 _is_evicting = false;
    Recorder             _recorder;
};

} // namespace emilib