h1-mod/src/client/component/scheduler.cpp

200 lines
4.2 KiB
C++
Raw Normal View History

2022-02-03 14:05:24 -05:00
#include <std_include.hpp>
#include "loader/component_loader.hpp"
#include "scheduler.hpp"
#include "game/game.hpp"
#include <utils/hook.hpp>
#include <utils/concurrency.hpp>
#include <utils/string.hpp>
2022-02-17 00:11:35 -05:00
#include <utils/thread.hpp>
2022-02-03 14:05:24 -05:00
namespace scheduler
{
namespace
{
struct task
{
std::function<bool()> handler{};
std::chrono::milliseconds interval{};
std::chrono::high_resolution_clock::time_point last_call{};
};
using task_list = std::vector<task>;
class task_pipeline
{
public:
void add(task&& task)
{
new_callbacks_.access([&task](task_list& tasks)
2022-02-23 15:23:00 -05:00
{
tasks.emplace_back(std::move(task));
});
2022-02-03 14:05:24 -05:00
}
void execute()
{
callbacks_.access([&](task_list& tasks)
{
this->merge_callbacks();
for (auto i = tasks.begin(); i != tasks.end();)
2022-02-03 14:05:24 -05:00
{
const auto now = std::chrono::high_resolution_clock::now();
const auto diff = now - i->last_call;
2022-02-03 14:05:24 -05:00
if (diff < i->interval)
2022-02-03 14:05:24 -05:00
{
++i;
continue;
2022-02-03 14:05:24 -05:00
}
i->last_call = now;
const auto res = i->handler();
if (res == cond_end)
{
i = tasks.erase(i);
}
else
{
++i;
}
}
});
2022-02-03 14:05:24 -05:00
}
private:
utils::concurrency::container<task_list> new_callbacks_;
utils::concurrency::container<task_list, std::recursive_mutex> callbacks_;
void merge_callbacks()
{
callbacks_.access([&](task_list& tasks)
2022-02-23 15:23:00 -05:00
{
new_callbacks_.access([&](task_list& new_tasks)
2022-02-03 14:05:24 -05:00
{
2022-02-23 15:23:00 -05:00
tasks.insert(tasks.end(), std::move_iterator<task_list::iterator>(new_tasks.begin()), std::move_iterator<task_list::iterator>(new_tasks.end()));
new_tasks = {};
2022-02-03 14:05:24 -05:00
});
2022-02-23 15:23:00 -05:00
});
2022-02-03 14:05:24 -05:00
}
};
volatile bool kill = false;
std::thread thread;
task_pipeline pipelines[pipeline::count];
utils::hook::detour r_end_frame_hook;
utils::hook::detour g_run_frame_hook;
utils::hook::detour main_frame_hook;
void execute(const pipeline type)
{
assert(type >= 0 && type < pipeline::count);
pipelines[type].execute();
}
void r_end_frame_stub()
{
execute(pipeline::renderer);
r_end_frame_hook.invoke<void>();
}
void server_frame_stub()
{
g_run_frame_hook.invoke<void>();
execute(pipeline::server);
}
void main_frame_stub()
{
main_frame_hook.invoke<void>();
execute(pipeline::main);
}
}
void schedule(const std::function<bool()>& callback, const pipeline type,
const std::chrono::milliseconds delay)
{
assert(type >= 0 && type < pipeline::count);
task task;
task.handler = callback;
task.interval = delay;
task.last_call = std::chrono::high_resolution_clock::now();
pipelines[type].add(std::move(task));
}
void loop(const std::function<void()>& callback, const pipeline type,
const std::chrono::milliseconds delay)
{
schedule([callback]()
2022-02-23 15:23:00 -05:00
{
callback();
return cond_continue;
}, type, delay);
2022-02-03 14:05:24 -05:00
}
void once(const std::function<void()>& callback, const pipeline type,
const std::chrono::milliseconds delay)
{
schedule([callback]()
2022-02-23 15:23:00 -05:00
{
callback();
return cond_end;
}, type, delay);
2022-02-03 14:05:24 -05:00
}
2022-02-17 00:11:35 -05:00
void on_game_initialized(const std::function<void()>& callback, const pipeline type,
const std::chrono::milliseconds delay)
{
schedule([=]()
2022-02-23 15:23:00 -05:00
{
2022-02-28 15:04:44 -05:00
const auto dw_init = game::environment::is_sp() ? true : game::Live_SyncOnlineDataFlags(0) == 0;
2022-02-23 15:23:00 -05:00
if (dw_init && game::Sys_IsDatabaseReady2())
2022-02-17 00:11:35 -05:00
{
2022-02-23 15:23:00 -05:00
once(callback, type, delay);
return cond_end;
}
2022-02-17 00:11:35 -05:00
2022-02-23 15:23:00 -05:00
return cond_continue;
}, pipeline::main);
2022-02-17 00:11:35 -05:00
}
2022-02-03 14:05:24 -05:00
class component final : public component_interface
{
public:
2022-02-17 00:11:35 -05:00
void post_start() override
{
thread = utils::thread::create_named_thread("Async Scheduler", []()
2022-02-23 15:23:00 -05:00
{
while (!kill)
2022-02-17 00:11:35 -05:00
{
2022-02-23 15:23:00 -05:00
execute(pipeline::async);
std::this_thread::sleep_for(10ms);
}
});
2022-02-17 00:11:35 -05:00
}
2022-02-03 14:05:24 -05:00
void post_unpack() override
{
2022-02-27 10:10:04 -05:00
r_end_frame_hook.create(SELECT_VALUE(0x1404F7310, 0x1405FE470), scheduler::r_end_frame_stub);
g_run_frame_hook.create(SELECT_VALUE(0x1402772D0, 0x14033A640), scheduler::server_frame_stub);
main_frame_hook.create(SELECT_VALUE(0x1401CE8D0, 0x1400D8310), scheduler::main_frame_stub);
2022-02-17 00:11:35 -05:00
}
void pre_destroy() override
{
kill = true;
if (thread.joinable())
{
thread.join();
}
2022-02-03 14:05:24 -05:00
}
};
}
2022-02-23 15:23:00 -05:00
REGISTER_COMPONENT(scheduler::component)