/*
* Copyright (C) 2023 Christopher J. Howard
*
* This file is part of Antkeeper source code.
*
* Antkeeper source code is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Antkeeper source code is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Antkeeper source code. If not, see .
*/
#include "game/game.hpp"
#include "game/commands/commands.hpp"
#include "game/control-profile.hpp"
#include "game/controls.hpp"
#include "game/fonts.hpp"
#include "game/graphics.hpp"
#include "game/menu.hpp"
#include "game/settings.hpp"
#include "game/states/main-menu-state.hpp"
#include "game/states/splash-state.hpp"
#include "game/strings.hpp"
#include "game/systems/astronomy-system.hpp"
#include "game/systems/atmosphere-system.hpp"
#include "game/systems/behavior-system.hpp"
#include "game/systems/blackbody-system.hpp"
#include "game/systems/camera-system.hpp"
#include "game/systems/collision-system.hpp"
#include "game/systems/constraint-system.hpp"
#include "game/systems/locomotion-system.hpp"
#include "game/systems/ik-system.hpp"
#include "game/systems/animation-system.hpp"
#include "game/systems/orbit-system.hpp"
#include "game/systems/render-system.hpp"
#include "game/systems/spatial-system.hpp"
#include "game/systems/steering-system.hpp"
#include "game/systems/physics-system.hpp"
#include "game/systems/subterrain-system.hpp"
#include "game/systems/terrain-system.hpp"
#include "game/systems/reproductive-system.hpp"
#include "game/systems/metabolic-system.hpp"
#include "game/systems/metamorphosis-system.hpp"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
// Prevent cxxopts from using RTTI
#define CXXOPTS_NO_RTTI
#include
using namespace hash::literals;
game::game(int argc, const char* const* argv)
{
// Boot process
debug::log::trace("Booting up...");
// Profile boot duration
#if !defined(NDEBUG)
auto boot_t0 = std::chrono::high_resolution_clock::now();
#endif
parse_options(argc, argv);
setup_resources();
load_settings();
setup_window();
setup_audio();
setup_input();
load_strings();
setup_rendering();
setup_scenes();
setup_animation();
setup_ui();
setup_rng();
setup_entities();
setup_systems();
setup_controls();
setup_debugging();
setup_timing();
active_ecoregion = nullptr;
closed = false;
// Profile boot duration
#if !defined(NDEBUG)
auto boot_t1 = std::chrono::high_resolution_clock::now();
#endif
debug::log::trace("Boot up complete");
// Print boot duration
#if !defined(NDEBUG)
debug::log::info("Boot duration: {}", std::chrono::duration_cast>(boot_t1 - boot_t0));
#endif
}
game::~game()
{
debug::log::trace("Booting down...");
// Exit all active game states
while (!state_machine.empty())
{
state_machine.pop();
}
// Update window settings
const auto& windowed_position = window->get_windowed_position();
const auto& windowed_size = window->get_windowed_size();
const bool maximized = window->is_maximized();
const bool fullscreen = window->is_fullscreen();
(*settings)["window_x"] = windowed_position.x();
(*settings)["window_y"] = windowed_position.y();
(*settings)["window_w"] = windowed_size.x();
(*settings)["window_h"] = windowed_size.y();
(*settings)["maximized"] = maximized;
(*settings)["fullscreen"] = fullscreen;
// Destruct window
window.reset();
// Save settings
resource_manager->set_write_path(shared_config_path);
resource_manager->save(*settings, "settings.cfg");
// Destruct input and window managers
input_manager.reset();
window_manager.reset();
// Shut down audio
shutdown_audio();
debug::log::trace("Boot down complete");
}
void game::parse_options(int argc, const char* const* argv)
{
if (argc <= 1)
{
// No command-line options specified
return;
}
debug::log::trace("Parsing command-line options...");
// Parse command-line options with cxxopts
try
{
cxxopts::Options options(config::application_name, config::application_name);
options.add_options()
("c,continue", "Continues from the last save")
("d,data", "Sets the data package path", cxxopts::value())
("f,fullscreen", "Starts in fullscreen mode")
("n,new-game", "Starts a new game")
("q,quick-start", "Skips to the main menu")
("r,reset", "Resets all settings to default")
("v,v-sync", "Enables or disables v-sync", cxxopts::value())
("w,windowed", "Starts in windowed mode");
auto result = options.parse(argc, argv);
// --continue
if (result.count("continue"))
{
option_continue = true;
}
// --data
if (result.count("data"))
{
option_data = result["data"].as();
}
// --fullscreen
if (result.count("fullscreen"))
{
option_fullscreen = true;
}
// --new-game
if (result.count("new-game"))
{
option_new_game = true;
}
// --quick-start
if (result.count("quick-start"))
{
option_quick_start = true;
}
// --reset
if (result.count("reset"))
{
option_reset = true;
}
// --v-sync
if (result.count("v-sync"))
{
option_v_sync = result["v-sync"].as();
}
// --windowed
if (result.count("windowed"))
{
option_windowed = true;
}
debug::log::info("Parsed {} command-line options", argc);
}
catch (const std::exception& e)
{
debug::log::error("An error occurred while parsing command-line options: {}", e.what());
}
}
void game::setup_resources()
{
// Allocate resource manager
resource_manager = std::make_unique<::resource_manager>();
// Get executable data path
const auto data_path = get_executable_data_path();
// Determine data package path
if (option_data)
{
// Handle command-line data path option
data_package_path = option_data.value();
if (data_package_path.is_relative())
{
data_package_path = data_path / data_package_path;
}
}
else
{
data_package_path = data_path / (config::application_slug + std::string("-data.zip"));
}
// Determine mods path
mods_path = data_path / "mods";
// Determine config paths
local_config_path = get_local_config_path() / config::application_name;
shared_config_path = get_shared_config_path() / config::application_name;
saves_path = shared_config_path / "saves";
screenshots_path = shared_config_path / "gallery";
controls_path = shared_config_path / "controls";
// Log paths
debug::log::info("Data package path: \"{}\"", data_package_path.string());
debug::log::info("Local config path: \"{}\"", local_config_path.string());
debug::log::info("Shared config path: \"{}\"", shared_config_path.string());
debug::log::info("Mods path: \"{}\"", mods_path.string());
// Create nonexistent config directories
std::vector config_paths;
config_paths.push_back(local_config_path);
config_paths.push_back(shared_config_path);
config_paths.push_back(saves_path);
config_paths.push_back(screenshots_path);
config_paths.push_back(controls_path);
for (const auto& path: config_paths)
{
try
{
if (std::filesystem::create_directories(path))
{
debug::log::info("Created directory \"{}\"", path.string());
}
}
catch (const std::filesystem::filesystem_error& e)
{
debug::log::error("Failed to create directory \"{}\": {}", path.string(), e.what());
}
}
// Scan for mods
std::vector mod_paths;
if (std::filesystem::is_directory(mods_path))
{
for (const auto& entry: std::filesystem::directory_iterator{mods_path})
{
if (entry.is_directory() || (entry.is_regular_file() && entry.path().extension() == ".zip"))
{
mod_paths.push_back(entry.path());
debug::log::info("Found mod \"{}\"", entry.path().filename().string());
}
}
}
// Mount mod paths
for (const std::filesystem::path& mod_path: mod_paths)
{
resource_manager->mount(mods_path / mod_path);
}
// Mount config path
resource_manager->mount(local_config_path);
resource_manager->mount(shared_config_path);
// Mount data package path
resource_manager->mount(data_package_path);
// Mount controls path
resource_manager->mount(shared_config_path / "controls");
}
void game::load_settings()
{
if (option_reset)
{
// Command-line reset option found, reset settings
settings = std::make_shared>();
resource_manager->set_write_path(shared_config_path);
resource_manager->save(*settings, "settings.cfg");
debug::log::info("Settings reset");
}
else
{
settings = resource_manager->load>("settings.cfg");
if (!settings)
{
debug::log::info("Settings not found");
settings = std::make_shared>();
}
}
}
void game::setup_window()
{
// Construct window manager
window_manager = app::window_manager::instance();
// Default window settings
std::string window_title = config::application_name;
int window_x = -1;
int window_y = -1;
int window_w = -1;
int window_h = -1;
bool maximized = true;
bool fullscreen = true;
bool v_sync = true;
// Read window settings
bool resize = false;
read_or_write_setting(*this, "window_title", window_title);
read_or_write_setting(*this, "window_x", window_x);
read_or_write_setting(*this, "window_y", window_y);
if (!read_or_write_setting(*this, "window_w", window_w) ||
!read_or_write_setting(*this, "window_h", window_h))
{
resize = true;
}
read_or_write_setting(*this, "maximized", maximized);
read_or_write_setting(*this, "fullscreen", fullscreen);
read_or_write_setting(*this, "v_sync", v_sync);
// If window size not set, resize and reposition relative to default display
if (resize)
{
const app::display& display = window_manager->get_display(0);
const auto& usable_bounds = display.get_usable_bounds();
const auto usable_bounds_center = usable_bounds.center();
const float default_windowed_scale = 1.0f / 1.2f;
window_w = static_cast((usable_bounds.max.x() - usable_bounds.min.x()) * default_windowed_scale);
window_h = static_cast((usable_bounds.max.y() - usable_bounds.min.y()) * default_windowed_scale);
window_x = usable_bounds_center.x() - window_w / 2;
window_y = usable_bounds_center.y() - window_h / 2;
}
// Handle window-related command-line options
if (option_windowed)
{
// Start in windowed mode
maximized = false;
fullscreen = false;
}
if (option_fullscreen)
{
// Start in fullscreen mode
fullscreen = true;
}
if (option_v_sync)
{
v_sync = option_v_sync.value();
}
// Construct window
window = window_manager->create_window
(
window_title,
{window_x, window_y},
{window_w, window_h},
maximized,
fullscreen,
v_sync
);
// Restrict window size
window->set_minimum_size({160, 144});
// Setup window closed callback
window_closed_subscription = window->get_closed_channel().subscribe
(
[&](const auto& event)
{
closed = true;
}
);
}
void game::setup_audio()
{
debug::log::trace("Setting up audio...");
// Default audio settings
master_volume = 1.0f;
ambience_volume = 1.0f;
effects_volume = 1.0f;
mono_audio = false;
captions = false;
captions_size = 1.0f;
// Read audio settings
read_or_write_setting(*this, "master_volume", master_volume);
read_or_write_setting(*this, "ambience_volume", ambience_volume);
read_or_write_setting(*this, "effects_volume", effects_volume);
read_or_write_setting(*this, "mono_audio", mono_audio);
read_or_write_setting(*this, "captions", captions);
read_or_write_setting(*this, "captions_size", captions_size);
// Open audio device
debug::log::trace("Opening audio device...");
alc_device = alcOpenDevice(nullptr);
if (!alc_device)
{
debug::log::error("Failed to open audio device: AL error code {}", alGetError());
return;
}
else
{
// Get audio device name
const ALCchar* alc_device_name = nullptr;
if (alcIsExtensionPresent(alc_device, "ALC_ENUMERATE_ALL_EXT"))
{
alc_device_name = alcGetString(alc_device, ALC_ALL_DEVICES_SPECIFIER);
}
if (alcGetError(alc_device) != AL_NO_ERROR || !alc_device_name)
{
alc_device_name = alcGetString(alc_device, ALC_DEVICE_SPECIFIER);
}
// Log audio device name
debug::log::info("Opened audio device \"{}\"", alc_device_name);
}
// Create audio context
debug::log::trace("Creating audio context...");
alc_context = alcCreateContext(alc_device, nullptr);
if (!alc_context)
{
debug::log::error("Failed to create audio context: ALC error code {}", alcGetError(alc_device));
alcCloseDevice(alc_device);
return;
}
else
{
debug::log::trace("Created audio context");
}
// Make audio context current
debug::log::trace("Making audio context current...");
if (alcMakeContextCurrent(alc_context) == ALC_FALSE)
{
debug::log::error("Failed to make audio context current: ALC error code {}", alcGetError(alc_device));
if (alc_context != nullptr)
{
alcDestroyContext(alc_context);
}
alcCloseDevice(alc_device);
return;
}
else
{
debug::log::trace("Made audio context current");
}
debug::log::trace("Set up audio");
}
void game::setup_input()
{
// Construct input manager
input_manager = app::input_manager::instance();
// Process initial input events, such as connecting gamepads
input_manager->update();
// Setup application quit callback
application_quit_subscription = input_manager->get_event_dispatcher().subscribe
(
[&](const auto& event)
{
closed = true;
}
);
/*
// Gamepad deactivation function
auto deactivate_gamepad = [&](const auto& event)
{
if (gamepad_active)
{
gamepad_active = false;
// WARNING: huge source of lag
input_manager->set_cursor_visible(true);
}
};
// Setup gamepad activation callbacks
gamepad_axis_moved_subscription = input_manager->get_event_dispatcher().subscribe
(
[&](const auto& event)
{
if (!gamepad_active && std::abs(event.position) > 0.5f)
{
gamepad_active = true;
input_manager->set_cursor_visible(false);
}
}
);
gamepad_button_pressed_subscription = input_manager->get_event_dispatcher().subscribe
(
[&](const auto& event)
{
if (!gamepad_active)
{
gamepad_active = true;
input_manager->set_cursor_visible(false);
}
}
);
// Setup gamepad deactivation callbacks
mouse_button_pressed_subscription = input_manager->get_event_dispatcher().subscribe
(
deactivate_gamepad
);
mouse_moved_subscription = input_manager->get_event_dispatcher().subscribe
(
deactivate_gamepad
);
mouse_scrolled_subscription = input_manager->get_event_dispatcher().subscribe
(
deactivate_gamepad
);
// Activate gamepad if one is connected
if (!input_manager->get_gamepads().empty())
{
gamepad_active = true;
input_manager->set_cursor_visible(false);
}
else
{
gamepad_active = false;
}
*/
}
void game::load_strings()
{
debug::log::trace("Loading strings...");
// Default strings settings
language_tag = "en";
// Read strings settings
read_or_write_setting(*this, "language_tag", language_tag);
// Slugify language tag
std::string language_slug = language_tag;
std::transform
(
language_slug.begin(),
language_slug.end(),
language_slug.begin(),
[](unsigned char c)
{
return std::tolower(c);
}
);
// Load string map
string_map = resource_manager->load(language_slug + ".str");
// Log language info
debug::log::info("Language tag: {}", language_tag);
// Change window title
const std::string window_title = get_string(*this, "window_title");
window->set_title(window_title);
// Update window title setting
(*settings)["window_title"] = window_title;
debug::log::trace("Loaded strings");
}
void game::setup_rendering()
{
debug::log::trace("Setting up rendering...");
// Default rendering settings
render_scale = 1.0f;
anti_aliasing_method = render::anti_aliasing_method::none;
shadow_map_resolution = 4096;
// Read rendering settings
read_or_write_setting(*this, "render_scale", render_scale);
read_or_write_setting(*this, "anti_aliasing_method", *reinterpret_cast*>(&anti_aliasing_method));
read_or_write_setting(*this, "shadow_map_resolution", shadow_map_resolution);
// Create framebuffers
::graphics::create_framebuffers(*this);
// Load fallback material
auto fallback_material = resource_manager->load("fallback.mtl");
// Setup common render passes
{
// Construct bloom pass
bloom_pass = std::make_unique(window->get_rasterizer(), resource_manager.get());
bloom_pass->set_source_texture(hdr_color_texture.get());
bloom_pass->set_mip_chain_length(5);
//bloom_pass->set_mip_chain_length(0);
bloom_pass->set_filter_radius(0.005f);
common_final_pass = std::make_unique(window->get_rasterizer(), ldr_framebuffer_a.get(), resource_manager.get());
common_final_pass->set_color_texture(hdr_color_texture.get());
common_final_pass->set_bloom_texture(bloom_pass->get_bloom_texture());
common_final_pass->set_bloom_weight(0.04f);
//common_final_pass->set_bloom_weight(0.0f);
common_final_pass->set_blue_noise_texture(resource_manager->load("blue-noise.tex"));
fxaa_pass = std::make_unique(window->get_rasterizer(), &window->get_rasterizer()->get_default_framebuffer(), resource_manager.get());
fxaa_pass->set_source_texture(ldr_color_texture_a.get());
resample_pass = std::make_unique(window->get_rasterizer(), &window->get_rasterizer()->get_default_framebuffer(), resource_manager.get());
resample_pass->set_source_texture(ldr_color_texture_b.get());
resample_pass->set_enabled(false);
// Configure anti-aliasing according to settings
graphics::select_anti_aliasing_method(*this, anti_aliasing_method);
// Configure render scaling according to settings
graphics::change_render_resolution(*this, render_scale);
}
// Setup UI compositor
{
ui_clear_pass = std::make_unique(window->get_rasterizer(), &window->get_rasterizer()->get_default_framebuffer());
ui_clear_pass->set_cleared_buffers(false, true, false);
ui_clear_pass->set_clear_depth(0.0f);
ui_material_pass = std::make_unique(window->get_rasterizer(), &window->get_rasterizer()->get_default_framebuffer(), resource_manager.get());
ui_material_pass->set_fallback_material(fallback_material);
ui_compositor = std::make_unique();
ui_compositor->add_pass(ui_clear_pass.get());
ui_compositor->add_pass(ui_material_pass.get());
}
// Setup surface compositor
{
surface_cascaded_shadow_map_pass = std::make_unique(window->get_rasterizer(), resource_manager.get());
surface_clear_pass = std::make_unique(window->get_rasterizer(), hdr_framebuffer.get());
surface_clear_pass->set_clear_color({0.0f, 0.0f, 0.0f, 1.0f});
surface_clear_pass->set_clear_depth(0.0f);
surface_clear_pass->set_clear_stencil(0);
surface_clear_pass->set_cleared_buffers(true, true, true);
sky_pass = std::make_unique(window->get_rasterizer(), hdr_framebuffer.get(), resource_manager.get());
// sky_pass->set_magnification(3.0f);
surface_material_pass = std::make_unique(window->get_rasterizer(), hdr_framebuffer.get(), resource_manager.get());
surface_material_pass->set_fallback_material(fallback_material);
surface_outline_pass = std::make_unique(window->get_rasterizer(), hdr_framebuffer.get(), resource_manager.get());
surface_outline_pass->set_outline_width(0.25f);
surface_outline_pass->set_outline_color(math::fvec4{1.0f, 1.0f, 1.0f, 1.0f});
surface_compositor = std::make_unique();
surface_compositor->add_pass(surface_cascaded_shadow_map_pass.get());
surface_compositor->add_pass(surface_clear_pass.get());
surface_compositor->add_pass(sky_pass.get());
surface_compositor->add_pass(surface_material_pass.get());
//surface_compositor->add_pass(surface_outline_pass.get());
surface_compositor->add_pass(bloom_pass.get());
surface_compositor->add_pass(common_final_pass.get());
surface_compositor->add_pass(fxaa_pass.get());
surface_compositor->add_pass(resample_pass.get());
}
// Setup underground compositor
{
underground_clear_pass = std::make_unique(window->get_rasterizer(), hdr_framebuffer.get());
underground_clear_pass->set_cleared_buffers(true, true, false);
underground_clear_pass->set_clear_color({0, 0, 0, 1});
underground_clear_pass->set_clear_depth(0.0f);
underground_material_pass = std::make_unique(window->get_rasterizer(), hdr_framebuffer.get(), resource_manager.get());
underground_material_pass->set_fallback_material(fallback_material);
underground_compositor = std::make_unique();
underground_compositor->add_pass(underground_clear_pass.get());
underground_compositor->add_pass(underground_material_pass.get());
underground_compositor->add_pass(bloom_pass.get());
underground_compositor->add_pass(common_final_pass.get());
underground_compositor->add_pass(fxaa_pass.get());
underground_compositor->add_pass(resample_pass.get());
}
// Create renderer
renderer = std::make_unique(*window->get_rasterizer(), *resource_manager);
debug::log::trace("Set up rendering");
}
void game::setup_scenes()
{
debug::log::trace("Setting up scenes...");
// Ratio of meters to scene units.
constexpr float scene_scale = 1.0f / 100.0f;
// Get default framebuffer
const auto& viewport_size = window->get_viewport_size();
const float viewport_aspect_ratio = static_cast(viewport_size[0]) / static_cast(viewport_size[1]);
// Allocate and init surface scene
surface_scene = std::make_unique();
surface_scene->set_scale(scene_scale);
// Allocate and init surface camera
surface_camera = std::make_shared();
surface_camera->set_perspective(math::radians(45.0f), viewport_aspect_ratio, 0.5f, 1000.0f);
surface_camera->set_compositor(surface_compositor.get());
surface_camera->set_composite_index(0);
// Allocate and init underground scene
underground_scene = std::make_unique();
underground_scene->set_scale(scene_scale);
// Allocate and init underground camera
underground_camera = std::make_shared();
underground_camera->set_perspective(math::radians(45.0f), viewport_aspect_ratio, 0.1f, 200.0f);
underground_camera->set_compositor(underground_compositor.get());
underground_camera->set_composite_index(0);
// Clear active scene
active_scene = nullptr;
debug::log::trace("Set up scenes");
}
void game::setup_animation()
{
// Setup timeline system
timeline = std::make_unique<::timeline>();
timeline->set_autoremove(true);
// Setup animator
animator = std::make_unique<::animator>();
}
void game::setup_ui()
{
// Default UI settings
font_scale = 1.0f;
debug_font_size_pt = 10.0f;
menu_font_size_pt = 22.0f;
title_font_size_pt = 80.0f;
dyslexia_font = false;
// Read UI settings
read_or_write_setting(*this, "font_scale", font_scale);
read_or_write_setting(*this, "debug_font_size_pt", debug_font_size_pt);
read_or_write_setting(*this, "menu_font_size_pt", menu_font_size_pt);
read_or_write_setting(*this, "title_font_size_pt", title_font_size_pt);
read_or_write_setting(*this, "dyslexia_font", dyslexia_font);
// Allocate font materials
debug_font_material = std::make_shared();
menu_font_material = std::make_shared();
title_font_material = std::make_shared();
// Load fonts
debug::log::trace("Loading fonts...");
try
{
::load_fonts(*this);
debug::log::trace("Loaded fonts");
}
catch (...)
{
debug::log::error("Failed to load fonts");
}
// Get default framebuffer
const auto& viewport_size = window->get_viewport_size();
const float viewport_aspect_ratio = static_cast(viewport_size[0]) / static_cast(viewport_size[1]);
// Setup UI scene
ui_scene = std::make_unique();
// Setup UI camera
ui_camera = std::make_unique();
ui_camera->set_compositor(ui_compositor.get());
const float clip_left = 0.0f;
const float clip_right = static_cast(viewport_size.x());
const float clip_top = 0.0f;
const float clip_bottom = static_cast(viewport_size.y());
const float clip_near = -100.0f;
const float clip_far = 100.0f;
ui_camera->set_orthographic(clip_left, clip_right, clip_top, clip_bottom, clip_near, clip_far);
ui_camera->look_at({0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, -1.0f}, {0.0f, 1.0f, 0.0f});
// Menu BG material
menu_bg_material = std::make_shared();
menu_bg_material->set_shader_template(resource_manager->load("ui-element-untextured.glsl"));
std::shared_ptr menu_bg_tint = std::make_shared(1, math::fvec4{0.0f, 0.0f, 0.0f, 0.5f});
menu_bg_material->set_variable("tint", menu_bg_tint);
menu_bg_material->set_blend_mode(render::material_blend_mode::translucent);
// Menu BG billboard
menu_bg_billboard = std::make_unique();
menu_bg_billboard->set_material(menu_bg_material);
menu_bg_billboard->set_scale({std::ceil(viewport_size.x() * 0.5f), std::ceil(viewport_size.y() * 0.5f), 1.0f});
menu_bg_billboard->set_translation({std::floor(viewport_size.x() * 0.5f), std::floor(viewport_size.y() * 0.5f), -100.0f});
// Create fade transition
fade_transition = std::make_unique();
fade_transition->get_material()->set_shader_template(resource_manager->load("fade-transition.glsl"));
fade_transition_color = std::make_shared(1, math::fvec3{0, 0, 0});
fade_transition->get_material()->set_variable("color", fade_transition_color);
fade_transition->get_billboard()->set_translation({0, 0, 98});
// Create inner radial transition
radial_transition_inner = std::make_unique();
radial_transition_inner->get_material()->set_shader_template(resource_manager->load("radial-transition-inner.glsl"));
// Create outer radial transition
radial_transition_outer = std::make_unique();
radial_transition_outer->get_material()->set_shader_template(resource_manager->load("radial-transition-outer.glsl"));
// Menu BG animations
{
auto menu_bg_frame_callback = [menu_bg_tint](int channel, const float& opacity)
{
menu_bg_tint->set(math::fvec4{0.0f, 0.0f, 0.0f, opacity});
};
// Menu BG fade in animation
menu_bg_fade_in_animation = std::make_unique>();
{
menu_bg_fade_in_animation->set_interpolator(ease::out_cubic);
animation_channel* channel = menu_bg_fade_in_animation->add_channel(0);
channel->insert_keyframe({0.0f, 0.0f});
channel->insert_keyframe({config::menu_fade_in_duration, config::menu_bg_opacity});
menu_bg_fade_in_animation->set_frame_callback(menu_bg_frame_callback);
menu_bg_fade_in_animation->set_start_callback
(
[&, menu_bg_tint]()
{
ui_scene->add_object(*menu_bg_billboard);
menu_bg_tint->set(math::fvec4{0.0f, 0.0f, 0.0f, 0.0f});
//menu_bg_billboard->set_active(true);
}
);
}
// Menu BG fade out animation
menu_bg_fade_out_animation = std::make_unique>();
{
menu_bg_fade_out_animation->set_interpolator(ease::out_cubic);
animation_channel* channel = menu_bg_fade_out_animation->add_channel(0);
channel->insert_keyframe({0.0f, config::menu_bg_opacity});
channel->insert_keyframe({config::menu_fade_out_duration, 0.0f});
menu_bg_fade_out_animation->set_frame_callback(menu_bg_frame_callback);
menu_bg_fade_out_animation->set_end_callback
(
[&]()
{
ui_scene->remove_object(*menu_bg_billboard);
//menu_bg_billboard->set_active(false);
}
);
}
}
// Add UI scene objects to UI scene
ui_scene->add_object(*ui_camera);
ui_scene->add_object(*fade_transition->get_billboard());
// Add UI animations to animator
animator->add_animation(fade_transition->get_animation());
animator->add_animation(menu_bg_fade_in_animation.get());
animator->add_animation(menu_bg_fade_out_animation.get());
// Setup window resized callback
window_resized_subscription = window->get_resized_channel().subscribe
(
[&](const auto& event)
{
const auto& viewport_size = event.window->get_viewport_size();
const float viewport_aspect_ratio = static_cast(viewport_size.x()) / static_cast(viewport_size.y());
// Resize framebuffers
::graphics::change_render_resolution(*this, render_scale);
// Update camera projection matrix
surface_camera->set_perspective
(
surface_camera->get_vertical_fov(),
viewport_aspect_ratio,
surface_camera->get_clip_near(),
surface_camera->get_clip_far()
);
// Update UI camera projection matrix
ui_camera->set_orthographic
(
0.0f,
static_cast(viewport_size.x()),
0.0f,
static_cast(viewport_size.y()),
ui_camera->get_clip_near(),
ui_camera->get_clip_far()
);
// Resize menu BG billboard
menu_bg_billboard->set_scale({std::ceil(viewport_size.x() * 0.5f), std::ceil(viewport_size.y() * 0.5f), 1.0f});
menu_bg_billboard->set_translation({std::floor(viewport_size.x() * 0.5f), std::floor(viewport_size.y() * 0.5f), -100.0f});
// Re-align debug text
frame_time_text->set_translation({std::round(0.0f), std::round(viewport_size.y() - debug_font.get_font_metrics().size), 99.0f});
// Re-align menu text
::menu::align_text(*this);
}
);
}
void game::setup_rng()
{
std::random_device rd;
rng.seed(rd());
}
void game::setup_entities()
{
// Create entity registry
entity_registry = std::make_unique();
}
void game::setup_systems()
{
const auto& viewport_size = window->get_viewport_size();
math::fvec4 viewport = {0.0f, 0.0f, static_cast(viewport_size[0]), static_cast(viewport_size[1])};
// Setup terrain system
terrain_system = std::make_unique<::terrain_system>(*entity_registry);
// Setup camera system
camera_system = std::make_unique<::camera_system>(*entity_registry);
camera_system->set_viewport(viewport);
// Setup subterrain system
subterrain_system = std::make_unique<::subterrain_system>(*entity_registry, resource_manager.get());
// Setup collision system
collision_system = std::make_unique<::collision_system>(*entity_registry);
// Setup behavior system
behavior_system = std::make_unique<::behavior_system>(*entity_registry);
// Setup steering system
steering_system = std::make_unique<::steering_system>(*entity_registry);
// Setup locomotion system
locomotion_system = std::make_unique<::locomotion_system>(*entity_registry);
// Setup IK system
ik_system = std::make_unique<::ik_system>(*entity_registry);
// Setup metabolic system
metabolic_system = std::make_unique<::metabolic_system>(*entity_registry);
// Setup metamorphosis system
metamorphosis_system = std::make_unique<::metamorphosis_system>(*entity_registry);
// Setup animation system
animation_system = std::make_unique<::animation_system>(*entity_registry);
// Setup physics system
physics_system = std::make_unique<::physics_system>(*entity_registry);
physics_system->set_gravity({0.0f, -9.80665f * 100.0f, 0.0f});
// Setup reproductive system
reproductive_system = std::make_unique<::reproductive_system>(*entity_registry);
reproductive_system->set_physics_system(physics_system.get());
// Setup spatial system
spatial_system = std::make_unique<::spatial_system>(*entity_registry);
// Setup constraint system
constraint_system = std::make_unique<::constraint_system>(*entity_registry);
// Setup orbit system
orbit_system = std::make_unique<::orbit_system>(*entity_registry);
// Setup blackbody system
blackbody_system = std::make_unique<::blackbody_system>(*entity_registry);
// Setup atmosphere system
atmosphere_system = std::make_unique<::atmosphere_system>(*entity_registry);
atmosphere_system->set_sky_pass(sky_pass.get());
// Setup astronomy system
astronomy_system = std::make_unique<::astronomy_system>(*entity_registry);
astronomy_system->set_transmittance_samples(16);
astronomy_system->set_sky_pass(sky_pass.get());
// Setup render system
render_system = std::make_unique<::render_system>(*entity_registry);
render_system->set_renderer(renderer.get());
render_system->add_layer(surface_scene.get());
render_system->add_layer(underground_scene.get());
render_system->add_layer(ui_scene.get());
}
void game::setup_controls()
{
debug::log::trace("Setting up controls...");
// Load SDL game controller mappings database
// debug::log::trace("Loading SDL game controller mappings...");
// file_buffer* game_controller_db = resource_manager->load("gamecontrollerdb.txt");
// if (!game_controller_db)
// {
// debug::log::error("Failed to load SDL game controller mappings");
// }
// else
// {
// app->add_game_controller_mappings(game_controller_db->data(), game_controller_db->size());
// debug::log::trace("Loaded SDL game controller mappings");
// resource_manager->unload("gamecontrollerdb.txt");
// }
// Pass input event queue to action maps
event::dispatcher* input_event_dispatcher = &input_manager->get_event_dispatcher();
window_action_map.set_event_dispatcher(input_event_dispatcher);
menu_action_map.set_event_dispatcher(input_event_dispatcher);
movement_action_map.set_event_dispatcher(input_event_dispatcher);
camera_action_map.set_event_dispatcher(input_event_dispatcher);
ant_action_map.set_event_dispatcher(input_event_dispatcher);
debug_action_map.set_event_dispatcher(input_event_dispatcher);
// Default control profile settings
control_profile_filename = "controls.cfg";
// Read control profile settings
if (read_or_write_setting(*this, "control_profile", control_profile_filename))
{
control_profile = resource_manager->load<::control_profile>(control_profile_filename);
}
if (!control_profile)
{
// Allocate control profile
control_profile = std::make_shared<::control_profile>();
// Reset control profile to default settings.
::reset_control_profile(*control_profile);
// Save control profile
resource_manager->set_write_path(controls_path);
resource_manager->save(*control_profile, control_profile_filename);
}
// Apply control profile
::apply_control_profile(*this, *control_profile);
// Setup mouse sensitivity
mouse_pan_factor = mouse_radians_per_pixel * mouse_pan_sensitivity * (mouse_invert_pan ? -1.0 : 1.0);
mouse_tilt_factor = mouse_radians_per_pixel * mouse_tilt_sensitivity * (mouse_invert_tilt ? -1.0 : 1.0);
// Setup gamepad sensitivity
gamepad_pan_factor = gamepad_radians_per_second * gamepad_pan_sensitivity * (gamepad_invert_pan ? -1.0 : 1.0);
gamepad_tilt_factor = gamepad_radians_per_second * gamepad_tilt_sensitivity * (gamepad_invert_tilt ? -1.0 : 1.0);
// Setup action callbacks
setup_window_controls(*this);
setup_menu_controls(*this);
setup_camera_controls(*this);
setup_game_controls(*this);
setup_ant_controls(*this);
// Enable window controls
enable_window_controls(*this);
#if defined(DEBUG)
// Setup and enable debug controls
setup_debug_controls(*this);
enable_debug_controls(*this);
#endif
debug::log::trace("Set up controls");
}
void game::setup_debugging()
{
cli = std::make_unique();
const auto& viewport_size = window->get_viewport_size();
frame_time_text = std::make_unique();
frame_time_text->set_material(debug_font_material);
frame_time_text->set_color({1.0f, 1.0f, 0.0f, 1.0f});
frame_time_text->set_font(&debug_font);
frame_time_text->set_translation({std::round(0.0f), std::round(viewport_size.y() - debug_font.get_font_metrics().size), 99.0f});
#if defined(DEBUG)
ui_scene->add_object(*frame_time_text);
debug_ui_visible = true;
#endif
}
void game::setup_timing()
{
// Init default settings
max_frame_rate = static_cast(window_manager->get_display(0).get_refresh_rate() * 2);
// Read settings
read_or_write_setting(*this, "fixed_update_rate", fixed_update_rate);
read_or_write_setting(*this, "max_frame_rate", max_frame_rate);
read_or_write_setting(*this, "limit_frame_rate", limit_frame_rate);
const auto fixed_update_interval = std::chrono::duration_cast<::frame_scheduler::duration_type>(std::chrono::duration(1.0 / fixed_update_rate));
const auto min_frame_duration = (limit_frame_rate) ? std::chrono::duration_cast<::frame_scheduler::duration_type>(std::chrono::duration(1.0 / max_frame_rate)) : frame_scheduler::duration_type::zero();
const auto max_frame_duration = fixed_update_interval * 15;
// Configure frame scheduler
frame_scheduler.set_fixed_update_interval(fixed_update_interval);
frame_scheduler.set_min_frame_duration(min_frame_duration);
frame_scheduler.set_max_frame_duration(max_frame_duration);
frame_scheduler.set_fixed_update_callback(std::bind_front(&game::fixed_update, this));
frame_scheduler.set_variable_update_callback(std::bind_front(&game::variable_update, this));
// Init frame duration average
average_frame_duration.reserve(15);
}
void game::shutdown_audio()
{
debug::log::trace("Shutting down audio...");
if (alc_context)
{
alcMakeContextCurrent(nullptr);
alcDestroyContext(alc_context);
}
if (alc_device)
{
alcCloseDevice(alc_device);
}
debug::log::trace("Shut down audio");
}
void game::fixed_update(::frame_scheduler::duration_type fixed_update_time, ::frame_scheduler::duration_type fixed_update_interval)
{
const float t = std::chrono::duration(fixed_update_time).count();
const float dt = std::chrono::duration(fixed_update_interval).count();
// Update tweens
sky_pass->update_tweens();
// Process window events
window_manager->update();
// Process function queue
while (!function_queue.empty())
{
function_queue.front()();
function_queue.pop();
}
// Advance tline
//timeline->advance(dt);
// Update entity systems
animation_system->update(t, dt);
physics_system->update(t, dt);
//terrain_system->update(t, dt);
//subterrain_system->update(t, dt);
collision_system->update(t, dt);
behavior_system->update(t, dt);
steering_system->update(t, dt);
locomotion_system->update(t, dt);
ik_system->update(t, dt);
reproductive_system->update(t, dt);
metabolic_system->update(t, dt);
metamorphosis_system->update(t, dt);
// physics_system->update(t, dt);
orbit_system->update(t, dt);
blackbody_system->update(t, dt);
atmosphere_system->update(t, dt);
astronomy_system->update(t, dt);
spatial_system->update(t, dt);
constraint_system->update(t, dt);
animator->animate(dt);
camera_system->update(t, dt);
render_system->update(t, dt);
}
void game::variable_update(::frame_scheduler::duration_type fixed_update_time, ::frame_scheduler::duration_type fixed_update_interval, ::frame_scheduler::duration_type accumulated_time)
{
// Calculate subframe interpolation factor (`alpha`)
const float alpha = static_cast(std::chrono::duration{accumulated_time} / fixed_update_interval);
// Sample average frame duration
const float average_frame_ms = average_frame_duration(std::chrono::duration(frame_scheduler.get_frame_duration()).count());
const float average_frame_fps = 1000.0f / average_frame_ms;
// Update frame rate display
frame_time_text->set_content(std::format("{:5.02f}ms / {:5.02f} FPS", average_frame_ms, average_frame_fps));
// Process input events
input_manager->update();
// Interpolate physics
physics_system->interpolate(alpha);
// Interpolate animation
animation_system->interpolate(alpha);
// Render
camera_system->interpolate(alpha);
render_system->draw(alpha);
window->swap_buffers();
}
void game::execute()
{
// Change to initial state
state_machine.emplace(std::make_unique(*this, true));
debug::log::trace("Entered main loop");
frame_scheduler.refresh();
while (!closed)
{
frame_scheduler.tick();
}
debug::log::trace("Exited main loop");
// Exit all active game states
while (!state_machine.empty())
{
state_machine.pop();
}
}