Class ApplicationSystem

Examples/SCExample/SCExample.cpp:104–220

};

struct ApplicationSystem
{
    ApplicationState state;

    HotReloadSystem         hotReloadSystem;
    HotReloadOptionsStorage hotReloadOptionsStorage;

    Result create()
    {
        currentThreadID = Thread::CurrentThreadID();
        lastEventTime.snap();
        SocketNetworking::initNetworking();
        AsyncEventLoop::Options options;
#if SC_PLATFORM_LINUX && 0
        // Just for testing purposes, we can force using epoll instead of io_uring
        options.apiType = AsyncEventLoop::Options::ApiType::ForceUseEpoll;
#endif
        SC_TRY(eventLoop.create(options));
        timeout.callback = [this](AsyncLoopTimeout::Result& result) { onTimeout(result); };
        SC_TRY(timeout.start(eventLoop, Time::Milliseconds(state.timeoutOccursEveryMs)));
        eventLoopMonitor.onNewEventsAvailable = []() { sokol_wake_up(); };
        SC_TRY(eventLoopMonitor.create(eventLoop));
        SC_TRY(buildHotReloadOptions(hotReloadOptionsStorage));
        const HotReloadSystem::Options hotReloadOptions = {hotReloadOptionsStorage.examplesPath.view(),
                                                           hotReloadOptionsStorage.defaultIncludePathsText.view()};
        SC_TRY(hotReloadSystem.create(eventLoop, hotReloadOptions));
        SC_TRY(hotReloadSystem.syncRegistry());
        return Result(true);
    }

    void resetLastEventTime() { lastEventTime.snap(); }

    // This is called during "frame callback" and it will either quickly execute or block when it's time to sleep
    Result runLoopStepInsideSokolApp()
    {
        // Update loop time, mainly to display it in the GUI
        state.loopTime = eventLoop.getLoopTime();

        // Check if enough time has passed since last user input event
        const Time::Relative sinceLastEvent = Time::HighResolutionCounter().snap().subtractApproximate(lastEventTime);
        if (sinceLastEvent > Time::Milliseconds(state.continueDrawingForMs))
        {
            // Enough time has passed such that we need to pause execution to avoid unnecessary cpu usage
            if (state.pausedCounter < ApplicationState::NumPauseFrames)
            {
                state.pausedCounter++;
                // Additional frames are needed to draw "paused" before entering sleep
                return hotReloadSystem.update();
            }
            // If we are here we really want to sleep the app until a new input event OR an I/O event arrives
            // We implement this logic by:
            // 1. Starting to monitor the event loop for IO in a different thread
            // 2. Blocking on sokol native gui event loop (sokol_sleep)
            //  2a. If input from user occurs, sokol_sleep() will unblock itself
            //  2b. If I/O event occurs, calling sokol_wake_up() from the monitoring thread will unblock sokol_sleep
            // 3. After returning from sokol_sleep, we make sure to dispatch callbacks for all ready completions
            auto resetLastEventTime = MakeDeferred([this] { lastEventTime.snap(); });
            SC_TRY(eventLoopMonitor.startMonitoring());