406 lines
14 KiB
C
406 lines
14 KiB
C
#include "app.h"
|
|
#include "arena.h"
|
|
#include "string.h"
|
|
#include "scratch.h"
|
|
#include "sys.h"
|
|
#include "work.h"
|
|
#include "user.h"
|
|
#include "sim.h"
|
|
#include "sim.h"
|
|
#include "playback.h"
|
|
#include "log.h"
|
|
#include "resource.h"
|
|
#include "asset_cache.h"
|
|
#include "font.h"
|
|
#include "sprite.h"
|
|
#include "ttf.h"
|
|
#include "mixer.h"
|
|
#include "sound.h"
|
|
#include "util.h"
|
|
#include "settings.h"
|
|
#include "draw.h"
|
|
#include "math.h"
|
|
#include "gpu.h"
|
|
#include "phys.h"
|
|
#include "sock.h"
|
|
#include "host.h"
|
|
#include "bitbuff.h"
|
|
|
|
struct exit_callback {
|
|
app_exit_callback_func *func;
|
|
struct exit_callback *next;
|
|
struct sys_thread thread;
|
|
};
|
|
|
|
GLOBAL struct {
|
|
struct arena arena;
|
|
struct string write_path;
|
|
struct sync_flag exit_sf;
|
|
|
|
/* Exit callbacks */
|
|
struct sys_mutex exit_callbacks_mutex;
|
|
struct arena exit_callbacks_arena;
|
|
struct exit_callback *exit_callbacks_head;
|
|
} G = ZI, DEBUG_ALIAS(G, G_app);
|
|
|
|
/* ========================== *
|
|
* Write directory
|
|
* ========================== */
|
|
|
|
INTERNAL struct string initialize_write_directory(struct arena *arena, struct string write_dir)
|
|
{
|
|
struct temp_arena scratch = scratch_begin(arena);
|
|
|
|
/* Create write path */
|
|
struct string base_write_dir = sys_get_write_path(scratch.arena);
|
|
struct string write_path_fmt = base_write_dir.len > 0 ? LIT("%F/%F/") : LIT("%F%F/");
|
|
struct string write_path = string_format(
|
|
arena,
|
|
write_path_fmt,
|
|
FMT_STR(base_write_dir),
|
|
FMT_STR(write_dir)
|
|
);
|
|
|
|
/* Create write dir if not present */
|
|
if (!sys_is_dir(write_path)) {
|
|
sys_mkdir(write_path);
|
|
/* TODO: handle failure */
|
|
}
|
|
|
|
scratch_end(scratch);
|
|
|
|
return write_path;
|
|
}
|
|
|
|
struct string app_write_path_cat(struct arena *arena, struct string filename)
|
|
{
|
|
return string_cat(arena, G.write_path, filename);
|
|
}
|
|
|
|
/* ========================== *
|
|
* Default settings
|
|
* ========================== */
|
|
|
|
INTERNAL struct sys_window_settings default_window_settings(struct sys_window *window)
|
|
{
|
|
__prof;
|
|
|
|
struct v2 monitor_size = sys_window_get_monitor_size(window);
|
|
|
|
i32 width = 1280;
|
|
i32 height = math_round_to_int(width / (f32)(DEFAULT_CAMERA_WIDTH / DEFAULT_CAMERA_HEIGHT));
|
|
i32 x = math_round_to_int(monitor_size.x / 2.f - width / 2);
|
|
i32 y = math_round_to_int(monitor_size.y / 2.f - height / 2);
|
|
|
|
return (struct sys_window_settings) {
|
|
.title = WINDOW_TITLE,
|
|
.floating_x = x,
|
|
.floating_y = y,
|
|
.floating_width = width,
|
|
.floating_height = height
|
|
};
|
|
}
|
|
|
|
/* ========================== *
|
|
* Exit callbacks
|
|
* ========================== */
|
|
|
|
INTERNAL SYS_THREAD_ENTRY_POINT_FUNC_DEF(exit_callback_thread_entry_point, vcallback)
|
|
{
|
|
struct exit_callback *callback = (struct exit_callback *)vcallback;
|
|
callback->func();
|
|
}
|
|
|
|
void app_register_exit_callback(app_exit_callback_func *func)
|
|
{
|
|
struct sys_lock lock = sys_mutex_lock_e(&G.exit_callbacks_mutex);
|
|
struct exit_callback *callback = arena_push(&G.exit_callbacks_arena, struct exit_callback);
|
|
callback->func = func;
|
|
callback->next = G.exit_callbacks_head;
|
|
G.exit_callbacks_head = callback;
|
|
sys_mutex_unlock(&lock);
|
|
}
|
|
|
|
/* ========================== *
|
|
* Args
|
|
* ========================== */
|
|
|
|
struct app_arg {
|
|
struct string key;
|
|
struct string value;
|
|
struct app_arg *next;
|
|
};
|
|
|
|
struct app_arg_list {
|
|
struct app_arg *first;
|
|
struct app_arg *last;
|
|
u64 count;
|
|
};
|
|
|
|
/* TODO: Remove this and do real argument parsing */
|
|
INTERNAL struct app_arg_list parse_args(struct arena *arena, struct string args_str)
|
|
{
|
|
struct app_arg_list res = ZI;
|
|
i64 mode = 0;
|
|
i64 i = 0;
|
|
i64 key_start = -1;
|
|
i64 key_end = -1;
|
|
i64 value_start = -1;
|
|
i64 value_end = -1;
|
|
while (i < (i64)args_str.len) {
|
|
u8 c = args_str.text[i];
|
|
switch (mode) {
|
|
case 0:
|
|
{
|
|
if (c == '-') {
|
|
mode = 1;
|
|
key_start = i + 1;
|
|
}
|
|
++i;
|
|
} break;
|
|
|
|
case 1:
|
|
{
|
|
if (c == '=') {
|
|
key_end = i;
|
|
value_start = i + 1;
|
|
mode = 2;
|
|
}
|
|
++i;
|
|
} break;
|
|
|
|
case 2:
|
|
{
|
|
if (c == '-' || i == (i64)args_str.len - 1) {
|
|
if (c == '-') {
|
|
value_end = i;
|
|
} else {
|
|
value_end = i + 1;
|
|
}
|
|
if (key_start >= 0 && key_end > key_start && key_end <= (i64)args_str.len && value_start >= 0 && value_end > value_start && value_end <= (i64)args_str.len) {
|
|
struct string key = string_copy(arena, STRING(key_end - key_start, args_str.text + key_start));
|
|
struct string value = string_copy(arena, STRING(value_end - value_start, args_str.text + value_start));
|
|
struct app_arg *arg = arena_push(arena, struct app_arg);
|
|
arg->key = key;
|
|
arg->value = value;
|
|
if (res.last) {
|
|
res.last->next = arg;
|
|
} else {
|
|
res.first = arg;
|
|
}
|
|
res.last = arg;
|
|
++res.count;
|
|
}
|
|
key_start = i + 1;
|
|
mode = 1;
|
|
}
|
|
++i;
|
|
} break;
|
|
default: break;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
/* ========================== *
|
|
* Entry point
|
|
* ========================== */
|
|
|
|
void app_entry_point(struct string args_str)
|
|
{
|
|
struct temp_arena scratch = scratch_begin_no_conflict();
|
|
|
|
struct app_arg_list args = parse_args(scratch.arena, args_str);
|
|
struct string logfile_name = LIT("log.log");
|
|
struct string settings_file_name = LIT("settings.txt");
|
|
struct string connect_address = ZI;
|
|
for (struct app_arg *arg = args.first; arg; arg = arg->next) {
|
|
struct string key = arg->key;
|
|
struct string value = arg->value;
|
|
if (string_eq(key, LIT("log"))) {
|
|
logfile_name = value;
|
|
} else if (string_eq(key, LIT("settings"))) {
|
|
settings_file_name = value;
|
|
} else if (string_eq(key, LIT("connect"))) {
|
|
connect_address = value;
|
|
}
|
|
}
|
|
|
|
#if !RTC
|
|
/* Verify test modes aren't left on by accident in release mode */
|
|
CT_ASSERT(BITBUFF_DEBUG == 0);
|
|
CT_ASSERT(BITBUFF_TEST == 0);
|
|
#endif
|
|
|
|
#if BITBUFF_TEST
|
|
bitbuff_test();
|
|
#endif
|
|
|
|
G.exit_sf = sync_flag_alloc();
|
|
G.exit_callbacks_mutex = sys_mutex_alloc();
|
|
G.exit_callbacks_arena = arena_alloc(GIGABYTE(64));
|
|
G.arena = arena_alloc(GIGABYTE(64));
|
|
|
|
u32 worker_count = 4;
|
|
{
|
|
/* FIXME: Switch this on to utilize all cores. Only decreasing worker count for testing purposes. */
|
|
#if !PROFILING && !RTC
|
|
/* 1. User thread
|
|
* 2. Sim thread
|
|
* 3. Playback thread
|
|
*/
|
|
u32 num_reserved_cores = 3;
|
|
|
|
i32 min_worker_count = 2;
|
|
i32 max_worker_count = 512;
|
|
i32 target_worker_count = (i32)sys_num_logical_processors() - num_reserved_cores;
|
|
worker_count = (u32)clamp_i32(target_worker_count, min_worker_count, max_worker_count);
|
|
#endif
|
|
}
|
|
|
|
G.write_path = initialize_write_directory(&G.arena, LIT(WRITE_DIR));
|
|
|
|
/* Startup logging */
|
|
{
|
|
struct temp_arena temp = arena_temp_begin(scratch.arena);
|
|
|
|
struct string logfile_dir = string_cat(temp.arena, G.write_path, LIT("logs/"));
|
|
struct string logfile_path = string_cat(temp.arena, logfile_dir, logfile_name);
|
|
sys_mkdir(logfile_dir);
|
|
|
|
log_startup(logfile_path);
|
|
logf_info("Start of logs");
|
|
arena_temp_end(temp);
|
|
}
|
|
logf_info("App started with args \"%F\" (%F parsed)", FMT_STR(args_str), FMT_UINT(args.count));
|
|
for (struct app_arg *arg = args.first; arg; arg = arg->next) {
|
|
logf_info("Parsed arg: key = \"%F\", value = \"%F\"", FMT_STR(arg->key), FMT_STR(arg->value));
|
|
}
|
|
|
|
/* Create window */
|
|
struct sys_window window = sys_window_alloc();
|
|
|
|
/* Read window settings from file */
|
|
{
|
|
struct temp_arena temp = arena_temp_begin(scratch.arena);
|
|
|
|
struct sys_window_settings window_settings = ZI;
|
|
struct string settings_path = app_write_path_cat(temp.arena, settings_file_name);
|
|
logf_info("Looking for settings file \"%F\"", FMT_STR(settings_path));
|
|
if (sys_is_file(settings_path)) {
|
|
logf_info("Settings file found");
|
|
struct sys_file settings_file = sys_file_open_read(settings_path);
|
|
struct string file_data = sys_file_read_all(temp.arena, settings_file);
|
|
sys_file_close(settings_file);
|
|
logf_info("Deserializing settings file data: %F", FMT_STR(file_data));
|
|
struct string error = ZI;
|
|
struct sys_window_settings *res = settings_deserialize(temp.arena, file_data, &error);
|
|
if (error.len > 0) {
|
|
logf_info("Failed to load settings file with error - %F", FMT_STR(error));
|
|
struct string msg = string_format(temp.arena,
|
|
LIT(
|
|
"Failed to loading settings file \"%F\":\n"
|
|
"------------\n"
|
|
"%F\n"
|
|
"------------\n"
|
|
"To stop this error from appearing, either fix the issue above or delete the file from the system."
|
|
),
|
|
FMT_STR(settings_path),
|
|
FMT_STR(error));
|
|
sys_panic(msg);
|
|
}
|
|
logf_info("Settings file loaded successfully");
|
|
window_settings = *res;
|
|
} else {
|
|
logf_info("Settings file not found, loading default");
|
|
window_settings = default_window_settings(&window);
|
|
}
|
|
string_copy_to_string(STRING_FROM_ARRAY(window_settings.title), LIT(WINDOW_TITLE));
|
|
sys_window_update_settings(&window, &window_settings);
|
|
|
|
arena_temp_end(temp);
|
|
}
|
|
|
|
/* Startup systems */
|
|
struct sock_startup_receipt sock_sr = sock_startup();
|
|
struct host_startup_receipt host_sr = host_startup(&sock_sr);
|
|
struct resource_startup_receipt resource_sr = resource_startup();
|
|
struct gpu_startup_receipt gpu_sr = gpu_startup(&window);
|
|
struct work_startup_receipt work_sr = work_startup(worker_count);
|
|
struct asset_cache_startup_receipt asset_cache_sr = asset_cache_startup(&work_sr);
|
|
struct ttf_startup_receipt ttf_sr = ttf_startup();
|
|
struct font_startup_receipt font_sr = font_startup(&work_sr, &gpu_sr, &asset_cache_sr, &ttf_sr, &resource_sr);
|
|
struct sprite_startup_receipt sprite_sr = sprite_startup(&gpu_sr, &resource_sr);
|
|
struct mixer_startup_receipt mixer_sr = mixer_startup();
|
|
struct sound_startup_receipt sound_sr = sound_startup(&work_sr, &asset_cache_sr, &resource_sr);
|
|
struct draw_startup_receipt draw_sr = draw_startup(&gpu_sr, &font_sr);
|
|
struct sim_startup_receipt sim_sr = sim_startup();
|
|
struct user_startup_receipt user_sr = user_startup(&work_sr, &gpu_sr, &font_sr, &sprite_sr, &draw_sr, &asset_cache_sr, &sound_sr, &mixer_sr, &host_sr, &sim_sr, connect_address, &window);
|
|
struct playback_startup_receipt playback_sr = playback_startup(&mixer_sr);
|
|
|
|
(UNUSED)user_sr;
|
|
(UNUSED)playback_sr;
|
|
|
|
/* Show window */
|
|
sys_window_show(&window);
|
|
|
|
/* Wait for app_exit() */
|
|
sync_flag_wait(&G.exit_sf);
|
|
|
|
/* Call exit callbacks */
|
|
/* FIXME: Only wait on threads for a certain period of time before
|
|
* forcing process exit (to prevent process hanging in the background
|
|
* when a thread gets stuck) */
|
|
{
|
|
struct sys_lock lock = sys_mutex_lock_e(&G.exit_callbacks_mutex);
|
|
|
|
/* Start callback threads */
|
|
{
|
|
__profscope(app_start_exit_callbacks);
|
|
for (struct exit_callback *callback = G.exit_callbacks_head; callback; callback = callback->next) {
|
|
callback->thread = sys_thread_alloc(&exit_callback_thread_entry_point, callback, LIT("[P1] Exit callback thread"));
|
|
}
|
|
}
|
|
|
|
/* Wait on callback threads */
|
|
{
|
|
__profscope(app_wait_on_exit_callbacks);
|
|
for (struct exit_callback *callback = G.exit_callbacks_head; callback; callback = callback->next) {
|
|
sys_thread_wait_release(&callback->thread);
|
|
}
|
|
}
|
|
|
|
sys_mutex_unlock(&lock);
|
|
}
|
|
|
|
/* Write window settings to file */
|
|
{
|
|
__profscope(app_write_to_settings_file);
|
|
struct temp_arena temp = arena_temp_begin(scratch.arena);
|
|
|
|
struct string window_settings_path = app_write_path_cat(temp.arena, settings_file_name);
|
|
|
|
struct sys_window_settings settings = sys_window_get_settings(&window);
|
|
struct string str = settings_serialize(temp.arena, &settings);
|
|
logf_info("Serialized window settings: %F", FMT_STR(str));
|
|
|
|
logf_info("Writing settings file to path \"%F\"", FMT_STR(window_settings_path));
|
|
struct sys_file settings_file = sys_file_open_write(window_settings_path);
|
|
sys_file_write(settings_file, str);
|
|
sys_file_close(settings_file);
|
|
logf_info("Finished writing settings file");
|
|
|
|
arena_temp_end(temp);
|
|
}
|
|
|
|
sys_window_release(&window);
|
|
|
|
logf_info("Program exited normally");
|
|
scratch_end(scratch);
|
|
}
|
|
|
|
void app_exit(void)
|
|
{
|
|
sync_flag_set(&G.exit_sf);
|
|
}
|