asset_watcher.cpp

Go to the documentation of this file.

#include "asset_watcher.h"
#include "engine/ui/ui_tree.h"
#include "filesystem/filesystem.h"
#include <engine/animation/animation.h>
#include <engine/assets/asset_manager.h>
#include <engine/assets/impl/asset_compiler.h>
#include <engine/assets/impl/asset_extensions.h>
#include <engine/assets/impl/asset_manifest.h>
#include <engine/audio/audio_clip.h>
#include <engine/ecs/ecs.h>
#include <engine/ecs/prefab.h>
#include <engine/events.h>
#include <engine/physics/physics_material.h>
#include <engine/rendering/font.h>
#include <engine/rendering/material.h>
#include <engine/rendering/mesh.h>
#include <engine/rendering/renderer.h>
#include <engine/scripting/ecs/systems/script_system.h>
#include <engine/scripting/script.h>
 
 
#include <engine/meta/assets/asset_database.hpp>
#include <engine/threading/threader.h>
 
#include <editor/editing/editing_manager.h>
#include <editor/editing/thumbnail_manager.h>
 
#include <filesystem/watcher.h>
#include <graphics/graphics.h>
#include <logging/logging.h>
 
#include <fstream>
#include <set>
 
namespace unravel
{
namespace
{
using namespace std::literals;
 
template<typename T>
auto get_job_name() -> std::string
{
    return fmt::format("Compiling {}", ex::get_type<T>());
}
 
template<typename T>
auto checking_dependencies_job_name() -> std::string
{
    return fmt::format("Checking dependencies of {}", ex::get_type<T>());
}
 
auto needs_recompilation(const fs::path& source_file_path, const fs::path& compiled_output_path) -> bool
{
    fs::error_code err;
 
    // If output doesn't exist, we need to compile
    if(!fs::exists(compiled_output_path, err) || err)
    {
        return true;
    }
 
    // Check if manifest exists
    auto manifest_path = asset_compiler::get_manifest_path(compiled_output_path);
    if(!fs::exists(manifest_path, err) || err)
    {
        // APPLOG_TRACE("Manifest missing for {}, cannot check if recompilation is needed",
        // compiled_output_path.string());
        return true;
    }
 
    // Load manifest and check if source has changed
    asset_compiler::asset_manifest manifest;
    if(!asset_compiler::load_manifest(manifest_path, manifest))
    {
        APPLOG_TRACE("Failed to load manifest for {}, recompilation needed", compiled_output_path.string());
        return true;
    }
 
    // Check if source file has changed
    if(asset_compiler::is_source_file_changed(source_file_path, manifest))
    {
        APPLOG_TRACE("Source file changed for {}, recompilation needed", compiled_output_path.string());
        return true;
    }
 
    // APPLOG_TRACE("Asset {} is up to date, skipping compilation", compiled_output_path.string());
    return false;
}
 
template<typename T>
void resolve_includes(const fs::path& file_path, std::set<fs::path>& processed_files)
{
}
 
template<>
void resolve_includes<gfx::shader>(const fs::path& file_path, std::set<fs::path>& processed_files)
{
    if(!processed_files.insert(file_path).second)
    {
        return; // Avoid processing the same file multiple times
    }
 
    std::ifstream file(file_path);
    if(!file.is_open())
    {
        // std::cerr << "Failed to open file: " << filePath << '\n';
        return;
    }
 
    const std::string include_keyword = "#include";
    const std::string bgfx_include_path = "/path/to/bgfx/include"; // Assuming bgfx include path is known
 
    std::string line;
    while(std::getline(file, line))
    {
        // Trim leading whitespace
        line.erase(0, line.find_first_not_of(" \t"));
 
        // Check for #include directive
        if(line.compare(0, include_keyword.length(), include_keyword) == 0)
        {
            // Find the start and end of the include path
            size_t start = line.find_first_of("\"<") + 1;
            size_t end = line.find_last_of("\">");
 
            if(start == std::string::npos || end == std::string::npos || start >= end)
            {
                // std::cerr << "Invalid include directive: " << line << '\n';
                continue;
            }
 
            std::string include_path = line.substr(start, end - start);
            fs::path resolved_path;
 
            if(line[start - 1] == '<' && line[end] == '>')
            {
                // Resolve system include path (e.g., bgfx_shader.sh)
                // resolvedPath = fs::path(bgfxIncludePath) / includePath;
                continue;
            }
            else
            {
                // Resolve local include path relative to the current file
                resolved_path = file_path.parent_path() / include_path;
            }
 
            resolved_path = fs::absolute(resolved_path);
            // std::cout << "Resolved include: " << resolvedPath << '\n';
 
            // Recurse into the included file
            resolve_includes<gfx::shader>(resolved_path, processed_files);
        }
    }
}
 
auto extract_href_from_link_tag(hpp::string_view link_tag) -> hpp::string_view
{
    size_t href_pos = link_tag.find("href=");
    if(href_pos == std::string::npos)
    {
        return {};
    }
 
    href_pos += 5; // Move past "href="
 
    // Find the quote character (either " or ')
    char quote_char = link_tag[href_pos];
    if(quote_char != '"' && quote_char != '\'')
    {
        return {};
    }
 
    href_pos++; // Move past the opening quote
    size_t href_end = link_tag.find(quote_char, href_pos);
    if(href_end == std::string::npos)
    {
        return {};
    }
 
    return link_tag.substr(href_pos, href_end - href_pos);
}
 
auto resolve_ui_tree_dependency_path(const fs::path& href_value, const fs::path& base_file_path) -> fs::path
{
    if(fs::has_known_protocol(href_value))
    {
        // Handle protocol paths like "engine:/data/ui/rml.rcss"
        return fs::resolve_protocol(href_value);
    }
 
    // Resolve relative path
    return fs::absolute(base_file_path.parent_path() / href_value);
}
 
template<>
void resolve_includes<ui_tree>(const fs::path& file_path, std::set<fs::path>& processed_files)
{
    if(!processed_files.insert(file_path).second)
    {
        return; // Avoid processing the same file multiple times
    }
 
    std::ifstream file(file_path);
    if(!file.is_open())
    {
        return;
    }
 
    std::string content_str((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
    hpp::string_view content(content_str);
    // Parse HTML/RML content to find <link> tags with href attributes
    size_t pos = 0;
    while((pos = content.find("<link", pos)) != std::string::npos)
    {
        // Find the end of the link tag
        size_t tag_end = content.find('>', pos);
        if(tag_end == std::string::npos)
        {
            break;
        }
 
        hpp::string_view link_tag = content.substr(pos, tag_end - pos + 1);
        hpp::string_view href_value = extract_href_from_link_tag(link_tag);
 
        if(!href_value.empty())
        {
            fs::path resolved_path = resolve_ui_tree_dependency_path(fs::path(href_value), file_path);
 
            // Recurse into the included file if it's a supported dependency format
            const auto& supported_deps = ex::get_suported_dependencies_formats<ui_tree>();
            auto extension = resolved_path.extension().string();
            if(std::find(supported_deps.begin(), supported_deps.end(), extension) != supported_deps.end())
            {
                resolve_includes<ui_tree>(resolved_path, processed_files);
            }
        }
 
        pos = tag_end + 1;
    }
}
 
template<typename T>
auto has_depencency(const fs::path& file, const fs::path& dep_to_check) -> bool
{
    std::set<fs::path> dependecies;
    resolve_includes<T>(file, dependecies);
 
    return dependecies.contains(dep_to_check);
}
 
auto remove_meta_tag(const fs::path& synced_path) -> fs::path
{
    return fs::replace(synced_path, ".meta", "");
}
 
auto remove_meta_tag(const std::vector<fs::path>& synced_paths) -> std::vector<fs::path>
{
    std::decay_t<decltype(synced_paths)> reduced;
    reduced.reserve(synced_paths.size());
    for(const auto& synced_path : synced_paths)
    {
        reduced.emplace_back(remove_meta_tag(synced_path));
    }
    return reduced;
}
 
void unwatch(std::vector<uint64_t>& watchers)
{
    for(const auto& id : watchers)
    {
        fs::watcher::unwatch(id);
    }
    watchers.clear();
}
 
auto get_asset_key(const fs::path& path) -> std::string
{
    auto p = fs::reduce_trailing_extensions(path);
    auto data_key = fs::convert_to_protocol(p);
    auto key =
        fs::replace(data_key.generic_string(), ex::get_compiled_directory(), ex::get_data_directory()).generic_string();
    return key;
}
 
auto get_meta_key(const fs::path& path) -> std::string
{
    auto p = fs::reduce_trailing_extensions(path);
    auto data_key = fs::convert_to_protocol(p);
    auto key =
        fs::replace(data_key.generic_string(), ex::get_compiled_directory(), ex::get_meta_directory()).generic_string();
    return key + ".meta";
}
 
auto check_files_integrity(const std::string& key, const fs::path& entry_path) -> bool
{
    fs::error_code ec;
    auto key_path = fs::resolve_protocol(key);
 
    if(!fs::exists(key_path, ec))
    {
        APPLOG_WARNING("{} does not exist. Cleaning up cached...", key);
        fs::remove(entry_path, ec);
 
        auto meta = get_meta_key(entry_path);
        auto meta_path = fs::resolve_protocol(meta);
        if(fs::exists(meta_path, ec))
        {
            APPLOG_WARNING("{} does not exist. Cleaning up meta...", key);
            fs::remove(meta_path, ec);
        }
 
        return false;
    }
 
    return true;
}
 
template<typename T>
auto watch_assets(rtti::context& ctx, const fs::path& dir, const fs::pattern_filter& filter, bool reload_async)
    -> uint64_t
{
    auto& am = ctx.get_cached<asset_manager>();
    auto& ts = ctx.get_cached<threader>();
    auto& tm = ctx.get_cached<thumbnail_manager>();
    auto& em = ctx.get_cached<editing_manager>();
 
    fs::path watch_dir = fs::path(dir).make_preferred();
 
    auto callback = [&am, &ts, &tm, &em](const auto& entries, bool is_initial_list)
    {
        std::set<hpp::uuid> changed;
        std::set<hpp::uuid> removed;
 
        for(const auto& entry : entries)
        {
            auto key = get_asset_key(entry.path);
 
            APPLOG_TRACE("{}", fs::to_string(entry));
 
            if(entry.type == fs::file_type::regular)
            {
                if(entry.status == fs::watcher::entry_status::removed)
                {
                    removed.emplace(am.get_asset<T>(key).uid());
                    am.unload_asset<T>(key);
 
                    if constexpr(std::is_same<T, script>::value)
                    {
                        script_system::set_needs_recompile(fs::extract_protocol(fs::convert_to_protocol(key)).string());
                    }
                }
                else if(entry.status == fs::watcher::entry_status::renamed)
                {
                    auto old_key = get_asset_key(entry.last_path);
                    am.rename_asset<T>(old_key, key);
 
                    if constexpr(std::is_same<T, script>::value)
                    {
                        script_system::set_needs_recompile(fs::extract_protocol(fs::convert_to_protocol(key)).string());
                    }
                }
                else // created or modified
                {
                    if(check_files_integrity(key, entry.path))
                    {
                        load_flags flags = is_initial_list ? load_flags::standard : load_flags::reload;
                        auto asset = am.get_asset<T>(key, flags);
 
                        changed.emplace(asset.uid());
                    }
 
                    if constexpr(std::is_same<T, script>::value)
                    {
                        script_system::set_needs_recompile(fs::extract_protocol(fs::convert_to_protocol(key)).string());
                    }
                }
            }
        }
 
        if(!changed.empty() || !removed.empty())
        {
            tpp::invoke(tpp::main_thread::get_id(),
                        [&tm, &em, &am, changed, removed]()
                        {
                            for(const auto& uid : removed)
                            {
                                tm.remove_thumbnail(uid);
                            }
 
                            for(const auto& uid : changed)
                            {
                                tm.regenerate_thumbnail(uid);
 
                                if constexpr(std::is_same<T, prefab>::value)
                                {
                                    auto asset = am.get_asset<T>(uid);
                                    em.on_prefab_updated(asset);
                                }
                            }
                        });
        }
    };
 
    return fs::watcher::watch(watch_dir, filter, true, true, 500ms, callback);
}
 
template<typename T>
auto watch_assets_depenencies(rtti::context& ctx, const fs::path& dir, const fs::pattern_filter& filter) -> uint64_t
{
    auto& am = ctx.get_cached<asset_manager>();
    auto& ts = ctx.get_cached<threader>();
 
    fs::path watch_dir = fs::path(dir).make_preferred();
 
    auto callback = [&am, &ts](const auto& entries, bool is_initial_list)
    {
        if(is_initial_list)
        {
            return;
        }
 
        for(const auto& entry : entries)
        {
            APPLOG_TRACE("{}", fs::to_string(entry));
 
            if(entry.type == fs::file_type::regular)
            {
                if(entry.status == fs::watcher::entry_status::removed)
                {
                }
                else if(entry.status == fs::watcher::entry_status::renamed)
                {
                }
                else // created or modified
                {
                    auto task = ts.pool->schedule(checking_dependencies_job_name<T>(),
                                                  [&am, entry]()
                                                  {
                                                      auto assets = am.get_assets<T>();
                                                      for(const auto& asset : assets)
                                                      {
                                                          auto meta = am.get_metadata(asset.uid());
                                                          auto absolute_path = fs::resolve_protocol(meta.location);
 
                                                          if(has_depencency<T>(absolute_path, entry.path))
                                                          {
                                                              fs::watcher::touch(absolute_path, false);
                                                          }
                                                      }
                                                  });
                }
            }
        }
    };
 
    return fs::watcher::watch(watch_dir, filter, true, true, 500ms, callback);
}
 
template<typename T>
static void add_to_syncer(rtti::context& ctx,
                          fs::syncer& syncer,
                          const fs::syncer::on_entry_removed_t& on_removed,
                          const fs::syncer::on_entry_renamed_t& on_renamed)
{
    auto& ts = ctx.get_cached<threader>();
    auto& am = ctx.get_cached<asset_manager>();
 
    auto on_modified =
        [&ts, &am](const std::string& ext, const auto& ref_path, const auto& synced_paths, bool is_initial_listing)
    {
        auto paths = remove_meta_tag(synced_paths);
 
        for(const auto& output : paths)
        {
            // Check if recompilation is needed based on manifest
            if(is_initial_listing && !needs_recompilation(ref_path, output))
            {
                continue;
            }
 
            auto key = get_asset_key(output);
            if(check_files_integrity(key, output))
            {
                auto task = ts.pool->schedule(get_job_name<T>(),
                                              [&am, ref_path, output]()
                                              {
                                                  asset_compiler::compile<T>(am, ref_path, output);
                                              });
            }
        }
    };
 
    for(const auto& type : ex::get_suported_formats<T>())
    {
        syncer.set_mapping(type + ".meta",
                           {".asset"},
                           on_modified,
                           on_modified,
                           on_removed,
                           on_renamed);
    }
}
 
template<typename T>
static void watch_synced(rtti::context& ctx, std::vector<uint64_t>& watchers, const fs::path& dir)
{
    for(const auto& type : ex::get_suported_formats<T>())
    {
        const auto watch_id = watch_assets<T>(ctx, dir, fs::pattern_filter("*" + type + ".asset"), true);
        watchers.push_back(watch_id);
    }
}
 
template<>
void add_to_syncer<gfx::shader>(rtti::context& ctx,
                                fs::syncer& syncer,
                                const fs::syncer::on_entry_removed_t& on_removed,
                                const fs::syncer::on_entry_renamed_t& on_renamed)
{
    auto& ts = ctx.get_cached<threader>();
    auto& am = ctx.get_cached<asset_manager>();
 
    auto on_modified =
        [&ts, &am](const std::string& ext, const auto& ref_path, const auto& synced_paths, bool is_initial_listing)
    {
        auto paths = remove_meta_tag(synced_paths);
        if(paths.empty())
        {
            return;
        }
        const auto& platform_supported = gfx::get_renderer_platform_supported_filename_extensions();
 
        for(const auto& output : paths)
        {
            auto it =
                std::find(std::begin(platform_supported), std::end(platform_supported), output.extension().string());
 
            if(it == std::end(platform_supported))
            {
                continue;
            }
 
            // Check if recompilation is needed based on manifest
            if(is_initial_listing && !needs_recompilation(ref_path, output))
            {
                continue;
            }
 
            auto key = get_asset_key(output);
            if(check_files_integrity(key, output))
            {
                auto task = ts.pool->schedule(get_job_name<gfx::shader>(),
                                              [&am, ref_path, output]()
                                              {
                                                  asset_compiler::compile<gfx::shader>(am, ref_path, output);
                                              });
            }
        }
    };
 
    for(const auto& type : ex::get_suported_formats<gfx::shader>())
    {
        syncer.set_mapping(type + ".meta",
                           {".asset.dx11",
                            ".asset.dx12",
                            ".asset.gl",
                            ".asset.spirv"},
                           on_modified,
                           on_modified,
                           on_removed,
                           on_renamed);
    }
}
 
template<>
void watch_synced<gfx::shader>(rtti::context& ctx, std::vector<uint64_t>& watchers, const fs::path& dir)
{
    const auto& renderer_extension = gfx::get_current_renderer_filename_extension();
    for(const auto& type : ex::get_suported_formats<gfx::shader>())
    {
        const auto watch_id =
            watch_assets<gfx::shader>(ctx, dir, fs::pattern_filter("*" + type + ".asset" + renderer_extension), true);
        watchers.push_back(watch_id);
    }
}
 
} // namespace
 
void asset_watcher::setup_directory(rtti::context& ctx, fs::syncer& syncer)
{
    const auto on_dir_modified =
        [](const std::string& ext, const auto& /*ref_path*/, const auto& /*synced_paths*/, bool /*is_initial_listing*/)
    {
 
    };
    const auto on_dir_removed = [](const std::string& ext, const auto& /*ref_path*/, const auto& synced_paths)
    {
        for(const auto& synced_path : synced_paths)
        {
            fs::error_code err;
            fs::remove_all(synced_path, err);
        }
    };
 
    const auto on_dir_renamed = [](const std::string& ext, const auto& /*ref_path*/, const auto& synced_paths)
    {
        for(const auto& synced_path : synced_paths)
        {
            fs::error_code err;
            fs::rename(synced_path.first, synced_path.second, err);
        }
    };
    syncer.set_directory_mapping(on_dir_modified, on_dir_modified, on_dir_removed, on_dir_renamed);
}
 
void asset_watcher::setup_meta_syncer(rtti::context& ctx,
                                      std::vector<uint64_t>& watchers,
                                      fs::syncer& syncer,
                                      const fs::path& data_dir,
                                      const fs::path& meta_dir,
                                      bool wait)
{
    setup_directory(ctx, syncer);
    auto& am = ctx.get_cached<asset_manager>();
 
    const auto on_file_removed = [&am](const std::string& ext, const auto& ref_path, const auto& synced_paths)
    {
        for(const auto& synced_path : synced_paths)
        {
            fs::error_code err;
            fs::remove_all(synced_path, err);
 
            am.remove_asset_info_for_path(ref_path);
        }
    };
 
    const auto on_file_renamed = [](const std::string& ext, const auto& /*ref_path*/, const auto& synced_paths)
    {
        for(const auto& synced_path : synced_paths)
        {
            fs::error_code err;
            fs::rename(synced_path.first, synced_path.second, err);
        }
    };
 
    const auto on_file_modified =
        [&am](const std::string& ext, const auto& ref_path, const auto& synced_paths, bool is_initial_listing)
    {
        for(const auto& synced_path : synced_paths)
        {
            asset_meta meta;
            fs::error_code err;
            if(fs::exists(synced_path, err))
            {
                load_from_file(synced_path.string(), meta);
            }
 
            if(meta.uid.is_nil())
            {
                auto key = fs::convert_to_protocol(ref_path).generic_string();
                meta = am.generate_metadata(key);
            }
            meta.uid = am.add_asset_info_for_path(ref_path, meta, true);
 
            save_to_file(synced_path.string(), meta);
        }
    };
 
    for(const auto& asset_set : ex::get_all_formats())
    {
        for(const auto& type : asset_set)
        {
            syncer.set_mapping(type, {".meta"}, on_file_modified, on_file_modified, on_file_removed, on_file_renamed);
        }
    }
 
    for(const auto& dep_ex : ex::get_suported_dependencies_formats<gfx::shader>())
    {
        auto id = watch_assets_depenencies<gfx::shader>(ctx, data_dir, fs::pattern_filter("*" + dep_ex));
        watchers.emplace_back(id);
    }
 
    for(const auto& dep_ex : ex::get_suported_dependencies_formats<ui_tree>())
    {
        auto id = watch_assets_depenencies<ui_tree>(ctx, data_dir, fs::pattern_filter("*" + dep_ex));
        watchers.emplace_back(id);
    }
 
    syncer.sync(data_dir, meta_dir);
 
    if(wait)
    {
        auto& ts = ctx.get_cached<threader>();
        ts.pool->wait_all();
    }
}
 
void asset_watcher::setup_cache_syncer(rtti::context& ctx,
                                       std::vector<uint64_t>& watchers,
                                       fs::syncer& syncer,
                                       const fs::path& meta_dir,
                                       const fs::path& cache_dir,
                                       bool wait)
{
    setup_directory(ctx, syncer);
 
    auto on_removed = [](const std::string& ext, const auto& /*ref_path*/, const auto& synced_paths)
    {
        for(const auto& synced_path : synced_paths)
        {
            auto synced_asset = remove_meta_tag(synced_path);
 
            auto manifest_path = asset_compiler::get_manifest_path(synced_asset);
            fs::error_code err;
            fs::remove_all(manifest_path, err);
            fs::remove_all(synced_asset, err);
        }
    };
 
    auto on_renamed = [](const std::string& ext, const auto& /*ref_path*/, const auto& synced_paths)
    {
        for(const auto& synced_path : synced_paths)
        {
            auto synced_old_asset = remove_meta_tag(synced_path.first);
            auto synced_new_asset = remove_meta_tag(synced_path.second);
            auto manifest_old_path = asset_compiler::get_manifest_path(synced_old_asset);
            auto manifest_new_path = asset_compiler::get_manifest_path(synced_new_asset);
            fs::error_code err;
            fs::rename(manifest_old_path, manifest_new_path, err);
            fs::rename(synced_old_asset, synced_new_asset, err);
        }
    };
 
    add_to_syncer<gfx::texture>(ctx, syncer, on_removed, on_renamed);
    add_to_syncer<gfx::shader>(ctx, syncer, on_removed, on_renamed);
    add_to_syncer<mesh>(ctx, syncer, on_removed, on_renamed);
    add_to_syncer<material>(ctx, syncer, on_removed, on_renamed);
    add_to_syncer<animation_clip>(ctx, syncer, on_removed, on_renamed);
    add_to_syncer<prefab>(ctx, syncer, on_removed, on_renamed);
    add_to_syncer<scene_prefab>(ctx, syncer, on_removed, on_renamed);
    add_to_syncer<physics_material>(ctx, syncer, on_removed, on_renamed);
    add_to_syncer<audio_clip>(ctx, syncer, on_removed, on_renamed);
    add_to_syncer<font>(ctx, syncer, on_removed, on_renamed);
    add_to_syncer<script>(ctx, syncer, on_removed, on_renamed);
    add_to_syncer<ui_tree>(ctx, syncer, on_removed, on_renamed);
    add_to_syncer<style_sheet>(ctx, syncer, on_removed, on_renamed);
 
    syncer.sync(meta_dir, cache_dir);
 
    if(wait)
    {
        auto& ts = ctx.get_cached<threader>();
        ts.pool->wait_all();
    }
 
    watch_synced<gfx::texture>(ctx, watchers, cache_dir);
    watch_synced<gfx::shader>(ctx, watchers, cache_dir);
    watch_synced<mesh>(ctx, watchers, cache_dir);
    watch_synced<material>(ctx, watchers, cache_dir);
    watch_synced<animation_clip>(ctx, watchers, cache_dir);
    watch_synced<prefab>(ctx, watchers, cache_dir);
    watch_synced<scene_prefab>(ctx, watchers, cache_dir);
    watch_synced<physics_material>(ctx, watchers, cache_dir);
    watch_synced<audio_clip>(ctx, watchers, cache_dir);
    watch_synced<font>(ctx, watchers, cache_dir);
    watch_synced<script>(ctx, watchers, cache_dir);
    watch_synced<ui_tree>(ctx, watchers, cache_dir);
    watch_synced<style_sheet>(ctx, watchers, cache_dir);
}
 
asset_watcher::asset_watcher()
{
}
 
asset_watcher::~asset_watcher()
{
}
 
void asset_watcher::on_os_event(rtti::context& ctx, os::event& e)
{
    if(e.type == os::events::window)
    {
        if(e.window.type == os::window_event_id::focus_lost)
        {
            if(!os::window::is_any_focused())
            {
                // APPLOG_TRACE("Application lost focus");
                fs::watcher::pause();
            }
        }
        if(e.window.type == os::window_event_id::focus_gained)
        {
            if(os::window::is_any_focused())
            {
                // APPLOG_TRACE("Application gained focus");
                fs::watcher::resume();
            }
        }
    }
}
 
auto asset_watcher::init(rtti::context& ctx) -> bool
{
    APPLOG_TRACE("{}::{}", hpp::type_name_str(*this), __func__);
 
    auto& ev = ctx.get_cached<events>();
    ev.on_os_event.connect(sentinel_, 1000, this, &asset_watcher::on_os_event);
 
    watch_assets(ctx, "engine:/", true);
 
    return true;
}
 
auto asset_watcher::deinit(rtti::context& ctx) -> bool
{
    APPLOG_TRACE("{}::{}", hpp::type_name_str(*this), __func__);
 
    unwatch_assets(ctx, "engine:/");
    return true;
}
 
void asset_watcher::watch_assets(rtti::context& ctx, const std::string& protocol, bool wait)
{
    auto& w = watched_protocols_[protocol];
 
    auto data_protocol = ex::get_data_directory_no_slash(protocol);
    auto meta_protocol = ex::get_meta_directory_no_slash(protocol);
    auto cache_protocol = ex::get_compiled_directory_no_slash(protocol);
 
    setup_meta_syncer(ctx,
                      w.watchers,
                      w.meta_syncer,
                      fs::resolve_protocol(data_protocol),
                      fs::resolve_protocol(meta_protocol),
                      wait);
 
    setup_cache_syncer(ctx,
                       w.watchers,
                       w.cache_syncer,
                       fs::resolve_protocol(meta_protocol),
                       fs::resolve_protocol(cache_protocol),
                       wait);
}
 
void asset_watcher::unwatch_assets(rtti::context& ctx, const std::string& protocol)
{
    auto& w = watched_protocols_[protocol];
 
    unwatch(w.watchers);
    w.meta_syncer.unsync();
    w.cache_syncer.unsync();
 
    watched_protocols_.erase(protocol);
 
    auto& am = ctx.get_cached<asset_manager>();
    am.unload_group(protocol);
}
 
} // namespace unravel