core.cpp

Go to the documentation of this file.

#include "./asw/modules/core.h"
 
#include <SDL3/SDL.h>
#include <SDL3_mixer/SDL_mixer.h>
#include <SDL3_ttf/SDL_ttf.h>
#include <algorithm>
#include <format>
 
#ifdef __EMSCRIPTEN__
#include <emscripten.h>
#endif
 
#include "./asw/modules/action.h"
#include "./asw/modules/assets.h"
#include "./asw/modules/config.h"
#include "./asw/modules/display.h"
#include "./asw/modules/input.h"
#include "./asw/modules/log.h"
#include "./asw/modules/sound.h"
#include "./asw/modules/util.h"
 
namespace {
bool exiting = false;
 
// Longest frame get_delta_time() reports
constexpr float MAX_DELTA_TIME = 0.25F;
 
uint64_t last_update_ns = 0;
float delta_time = 0.0F;
} // namespace
 
void asw::core::update()
{
    const uint64_t now = SDL_GetTicksNS();
    if (last_update_ns != 0) {
        delta_time
            = std::min(static_cast<float>(now - last_update_ns) / 1'000'000'000.0F, MAX_DELTA_TIME);
    }
    last_update_ns = now;
 
    asw::input::reset();
 
    SDL_Event e;
 
    while (SDL_PollEvent(&e)) {
        switch (e.type) {
        case SDL_EVENT_WINDOW_RESIZED: {
            auto* r = asw::display::get_renderer();
            if (r == nullptr) {
                break;
            }
 
            // Maintain aspect ratio. Window coordinates, not pixels, to match
            // SDL_SetWindowSize on high density displays
            SDL_Point window_size;
            SDL_GetWindowSize(asw::display::get_window(), &window_size.x, &window_size.y);
 
            // SDL reports the logical size of the current render target,
            // which is 0 while a texture is the target
            const auto render_size = asw::display::get_logical_size();
            if (render_size.x <= 0 || render_size.y <= 0 || window_size.x <= 0
                || window_size.y <= 0) {
                break;
            }
 
            const auto x_scale
                = static_cast<float>(window_size.x) / static_cast<float>(render_size.x);
 
            const auto y_scale
                = static_cast<float>(window_size.y) / static_cast<float>(render_size.y);
 
            const auto scale = std::min(x_scale, y_scale);
 
            SDL_SetWindowSize(asw::display::get_window(),
                static_cast<int>(static_cast<float>(render_size.x) * scale),
                static_cast<int>(static_cast<float>(render_size.y) * scale));
            break;
        }
 
        case SDL_EVENT_KEY_DOWN: {
            asw::input::_key_down(e.key.scancode, e.key.repeat);
            break;
        }
 
        case SDL_EVENT_KEY_UP: {
            if (!e.key.repeat) {
                asw::input::_key_up(e.key.scancode);
            }
            break;
        }
 
        case SDL_EVENT_MOUSE_BUTTON_DOWN: {
            asw::input::_mouse_button_down(e.button.button);
            break;
        }
 
        case SDL_EVENT_MOUSE_BUTTON_UP: {
            asw::input::_mouse_button_up(e.button.button);
            break;
        }
 
        case SDL_EVENT_MOUSE_MOTION: {
            // Ensure scale is applied to mouse coordinates
            auto* r = asw::display::get_renderer();
            if (r != nullptr) {
                SDL_ConvertEventToRenderCoordinates(r, &e);
            }
 
            asw::input::_mouse_motion(e.motion.x, e.motion.y, e.motion.xrel, e.motion.yrel);
            break;
        }
 
        case SDL_EVENT_MOUSE_WHEEL: {
            asw::input::_mouse_wheel(e.wheel.y);
            break;
        }
 
        case SDL_EVENT_GAMEPAD_AXIS_MOTION: {
            asw::input::_controller_axis_motion(e.gaxis.which, e.gaxis.axis, e.gaxis.value);
            break;
        }
 
        case SDL_EVENT_GAMEPAD_BUTTON_DOWN: {
            asw::input::_controller_button_down(e.gbutton.which, e.gbutton.button);
            break;
        }
 
        case SDL_EVENT_GAMEPAD_BUTTON_UP: {
            asw::input::_controller_button_up(e.gbutton.which, e.gbutton.button);
            break;
        }
 
        case SDL_EVENT_GAMEPAD_ADDED: {
            asw::input::_controller_added(e.gdevice.which);
            break;
        }
 
        case SDL_EVENT_GAMEPAD_REMOVED: {
            asw::input::_controller_removed(e.gdevice.which);
            break;
        }
 
        case SDL_EVENT_TEXT_INPUT: {
            asw::input::_append_text(e.text.text);
            break;
        }
 
        case SDL_EVENT_QUIT: {
            exit();
        }
 
        default:
            break;
        }
    }
 
    // After the events, so actions match raw input on the same frame
    asw::input::update_actions();
 
    asw::sound::_update();
}
 
float asw::core::get_delta_time()
{
    return delta_time;
}
 
void asw::core::init(int width, int height, int scale)
{
    if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMEPAD)) {
        asw::util::abort_on_error("SDL_Init");
    }
 
    asw::config::_init();
 
    if (!TTF_Init()) {
        asw::util::abort_on_error("TTF_Init");
    }
 
    if (!asw::sound::_init()) {
        asw::util::abort_on_error("Sound initialization failed");
    }
 
    asw::display::_init(width, height, scale);
}
 
void asw::core::init_opengl(int width, int height, int scale)
{
    if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMEPAD)) {
        asw::util::abort_on_error("SDL_Init");
    }
 
    asw::config::_init();
 
    if (!TTF_Init()) {
        asw::util::abort_on_error("TTF_Init");
    }
 
    if (!asw::sound::_init()) {
        asw::util::abort_on_error("Sound initialization failed");
    }
 
    // --- Set GL attributes before creating the window ---
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3); // Request OpenGL 3.x
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
 
    asw::display::_init_opengl(width, height, scale);
}
 
void asw::core::print_info()
{
    asw::log::info("ASW Info");
    asw::log::info("========");
 
    const char* renderer_name = "none";
    if (auto* r = asw::display::get_renderer(); r != nullptr) {
        renderer_name = SDL_GetRendererName(r);
    }
 
    asw::log::info(
        "SDL Version: {}.{}.{}", SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_MICRO_VERSION);
    asw::log::info("Renderer: {}", renderer_name);
}
 
void asw::core::exit()
{
    exiting = true;
}
 
void asw::core::shutdown()
{
    asw::input::clear_actions();
    asw::input::_shutdown();
 
    // Clear asset caches while SDL resources are still valid — SDL_Destroy*
    // calls in the shared_ptr deleters are safe at this point.
    asw::assets::clear_all();
 
    // _shutdown() nulls the renderer/window pointers BEFORE calling
    // SDL_DestroyRenderer/SDL_DestroyWindow.  Any outstanding shared_ptr<SDL_Texture>
    // held by user code will see a null renderer in their deleter and skip the
    // SDL_DestroyTexture call, preventing use-after-free.
    asw::display::_shutdown();
 
    // Same pattern for sound: null mixer pointer before teardown so any
    // surviving Sample/Music shared_ptrs become no-ops.
    asw::sound::_shutdown();
 
    asw::config::_shutdown();
 
    TTF_Quit();
    SDL_Quit();
}
 
void asw::core::run(const std::function<void()>& frame)
{
#ifdef __EMSCRIPTEN__
    // The browser calls the loop, so keep the frame alive after run() returns
    // control to it
    static std::function<void()> run_frame;
    run_frame = frame;
 
    emscripten_set_main_loop(
        []() {
            if (exiting) {
                emscripten_cancel_main_loop();
 
                // Let the page know, for example to offer a restart
                EM_ASM({
                    if (Module.onStop) {
                        Module.onStop();
                    }
                });
                return;
            }
 
            run_frame();
        },
        0, true);
#else
    while (!exiting) {
        frame();
    }
#endif
}
 
bool asw::core::is_exiting()
{
    return exiting;
}