await_shutdown()

void MayaFlux::Core::Engine::await_shutdown

(

)

Blocks until shutdown is requested (main thread event loop)

Pumps platform-specific events on the main thread and waits for shutdown. On macOS: Runs CFRunLoop to process dispatch queue (required for GLFW) On other platforms: Simple blocking wait for user input

Should be called on the main thread after Start().

Definition at line 201 of file Engine.cpp.

{
#ifdef MAYAFLUX_PLATFORM_MACOS
    run_macos_event_loop();
#elif defined(MAYAFLUX_PLATFORM_WINDOWS)
    static std::atomic<bool> s_signal_received { false };
    s_signal_received.store(false, std::memory_order_relaxed);
 
    SetConsoleCtrlHandler([](DWORD type) -> BOOL {
        if (type == CTRL_C_EVENT || type == CTRL_BREAK_EVENT || type == CTRL_CLOSE_EVENT) {
            s_signal_received.store(true, std::memory_order_release);
            return TRUE;
        }
        return FALSE;
    },
        TRUE);
 
    HANDLE h_stdin = GetStdHandle(STD_INPUT_HANDLE);
    bool has_console = h_stdin != INVALID_HANDLE_VALUE && GetFileType(h_stdin) == FILE_TYPE_CHAR;
 
    if (has_console) {
        while (!s_signal_received.load(std::memory_order_acquire)
            && !m_should_shutdown.load(std::memory_order_acquire)) {
            if (WaitForSingleObject(h_stdin, 100) == WAIT_OBJECT_0) {
                INPUT_RECORD rec {};
                DWORD read {};
                if (ReadConsoleInputW(h_stdin, &rec, 1, &read) && read > 0
                    && rec.EventType == KEY_EVENT
                    && rec.Event.KeyEvent.bKeyDown
                    && rec.Event.KeyEvent.wVirtualKeyCode == VK_RETURN) {
                    break;
                }
            }
        }
    } else {
        m_should_shutdown.wait(false);
    }
#else
    static std::atomic<bool> s_signal_received { false };
    s_signal_received.store(false, std::memory_order_relaxed);
 
    struct sigaction sa {};
    sa.sa_handler = [](int) { s_signal_received.store(true, std::memory_order_release); };
    sigaction(SIGINT, &sa, nullptr);
    sigaction(SIGTERM, &sa, nullptr);
 
    bool has_tty = isatty(STDIN_FILENO);
    if (has_tty) {
        while (!s_signal_received.load(std::memory_order_acquire)) {
            fd_set fds;
            FD_ZERO(&fds);
            FD_SET(STDIN_FILENO, &fds);
            timeval tv { .tv_sec = 0, .tv_usec = 100000 };
            if (select(1, &fds, nullptr, nullptr, &tv) > 0) {
                char c {};
                if (read(STDIN_FILENO, &c, 1) > 0 && c == '\n')
                    break;
            }
        }
    } else {
        sigset_t mask;
        sigfillset(&mask);
        sigdelset(&mask, SIGINT);
        sigdelset(&mask, SIGTERM);
        sigsuspend(&mask);
    }
 
#endif
 
    m_should_shutdown.store(true, std::memory_order_release);
 
    MF_LOG(Journal::Component::Core, Journal::Context::Runtime,
        "Shutdown requested, awaiting all subsystem termination ......");
}

References MayaFlux::Journal::Core, m_should_shutdown, MF_LOG, and MayaFlux::Journal::Runtime.

Referenced by MayaFlux::Await().

Here is the caller graph for this function: