305 lines
10 KiB
C
305 lines
10 KiB
C
#include "app.h"
|
|
#include "arena.h"
|
|
#include "string.h"
|
|
#include "scratch.h"
|
|
#include "sys.h"
|
|
#include "work.h"
|
|
#include "user.h"
|
|
#include "game.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 "renderer.h"
|
|
#include "phys.h"
|
|
#include "rng.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 ? STR("%F/%F/") : STR("%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_zero(&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);
|
|
}
|
|
|
|
/* ========================== *
|
|
* Generate random number file
|
|
* (unused function)
|
|
* ========================== */
|
|
|
|
#if 0
|
|
#include "rng.h"
|
|
INTERNAL void gen_random_file(struct string path, u32 count)
|
|
{
|
|
{
|
|
/* Clear file */
|
|
struct sys_file f = sys_file_open_write(path);
|
|
sys_file_write(f, BUFFER(0, 0));
|
|
sys_file_close(f);
|
|
}
|
|
struct sys_file f = sys_file_open_append(path);
|
|
for (u32 i = 0; i < count; ++i) {
|
|
u64 rand = rng_rand_u64();
|
|
sys_file_write(f, BUFFER_FROM_STRUCT(&rand));
|
|
}
|
|
sys_file_close(f);
|
|
}
|
|
#endif
|
|
|
|
/* ========================== *
|
|
* Entry point
|
|
* ========================== */
|
|
|
|
void app_entry_point(void)
|
|
{
|
|
struct temp_arena scratch = scratch_begin_no_conflict();
|
|
|
|
G.exit_sf = sync_flag_alloc();
|
|
G.exit_callbacks_mutex = sys_mutex_alloc();
|
|
G.exit_callbacks_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, Input thread
|
|
* 2. Game 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.arena = arena_alloc(GIGABYTE(64));
|
|
G.write_path = initialize_write_directory(&G.arena, STR(WRITE_DIR));
|
|
|
|
/* Startup logging */
|
|
{
|
|
struct temp_arena temp = arena_temp_begin(scratch.arena);
|
|
struct string logfile_path = app_write_path_cat(temp.arena, STR("log.txt"));
|
|
struct log_startup_receipt log_sr = log_startup(logfile_path);
|
|
(UNUSED)log_sr;
|
|
logf_info("Start of logs");
|
|
arena_temp_end(temp);
|
|
}
|
|
|
|
/* 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, STR(SETTINGS_FILENAME));
|
|
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 buffer file_data = sys_file_read_all(temp.arena, settings_file);
|
|
sys_file_close(settings_file);
|
|
logf_info("Deserializing settings file data: %F", FMT_STR(STRING_FROM_BUFFER(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,
|
|
STR(
|
|
"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_buff(BUFFER_FROM_ARRAY(window_settings.title), STR(WINDOW_TITLE));
|
|
sys_window_update_settings(&window, &window_settings);
|
|
|
|
arena_temp_end(temp);
|
|
}
|
|
|
|
/* Startup systems */
|
|
struct resource_startup_receipt resource_sr = resource_startup();
|
|
struct rng_startup_receipt rng_sr = rng_startup(&resource_sr);
|
|
struct renderer_startup_receipt renderer_sr = renderer_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, &renderer_sr, &asset_cache_sr, &ttf_sr, &resource_sr);
|
|
struct sprite_startup_receipt sprite_sr = sprite_startup(&renderer_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(&renderer_sr, &font_sr);
|
|
struct phys_startup_receipt phys_sr = phys_startup();
|
|
struct game_startup_receipt game_sr = game_startup(&mixer_sr, &sprite_sr, &sound_sr, &phys_sr);
|
|
struct user_startup_receipt user_sr = user_startup(&work_sr, &renderer_sr, &font_sr, &sprite_sr, &draw_sr, &game_sr, &asset_cache_sr, &mixer_sr, &window);
|
|
struct playback_startup_receipt playback_sr = playback_startup(&mixer_sr);
|
|
|
|
(UNUSED)user_sr;
|
|
(UNUSED)playback_sr;
|
|
(UNUSED)rng_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 */
|
|
for (struct exit_callback *callback = G.exit_callbacks_head; callback; callback = callback->next) {
|
|
callback->thread = sys_thread_alloc(&exit_callback_thread_entry_point, callback, STR("[P4] Exit callback thread"));
|
|
}
|
|
|
|
/* Wait on callback threads */
|
|
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 */
|
|
{
|
|
struct temp_arena temp = arena_temp_begin(scratch.arena);
|
|
|
|
struct string window_settings_path = app_write_path_cat(temp.arena, STR(SETTINGS_FILENAME));
|
|
|
|
struct sys_window_settings settings = sys_window_get_settings(&window);
|
|
struct buffer buff = settings_serialize(temp.arena, &settings);
|
|
logf_info("Serialized window settings: %F", FMT_STR(STRING_FROM_BUFFER(buff)));
|
|
|
|
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, buff);
|
|
sys_file_close(settings_file);
|
|
logf_info("Finished writing settings file");
|
|
|
|
arena_temp_end(temp);
|
|
}
|
|
|
|
logf_info("Program exited normally");
|
|
scratch_end(scratch);
|
|
}
|
|
|
|
void app_exit(void)
|
|
{
|
|
sync_flag_set(&G.exit_sf);
|
|
}
|