Method EngineMain

Source/Engine/StratusEngine.cpp:18–86

    Engine * Engine::instance_ = nullptr;

    bool Engine::EngineMain(Application * app, const int numArgs, const char ** args) {
        static std::mutex preventMultipleMainCalls;
        std::unique_lock<std::mutex> ul(preventMultipleMainCalls, std::defer_lock);
        if (!ul.try_lock()) {
            throw std::runtime_error("EngineMain already running");
        }

        // Set up engine params and create global Engine instance
        EngineInitParams params;
        params.numCmdArgs = numArgs;
        params.cmdArgs = args;
        Application::Instance_() = app;

        // Delete the instance in case it's left over from a previous run
        delete Engine::instance_;
        Engine::instance_ = new Engine(params);

        // Pre-initialize to set up things like the ApplicationThread
        Engine::Instance()->PreInitialize();
        ApplicationThread::Instance()->Queue([]() {
            Engine::Instance()->Initialize();
        });
        ApplicationThread::Instance()->DispatchAndSynchronize_();

        // Set up shut down sequence
        const auto shutdown = []() {
            Engine::Instance()->BeginShutDown();
            Engine::Instance()->ShutDown();
        };

        // Enter main loop
        std::atomic<SystemStatus> status(SystemStatus::SYSTEM_CONTINUE);
        const auto runFrame = [&status]() {
            status.store(Engine::Instance()->Frame());
        };

        volatile bool shouldRestart = false;
        volatile bool running = true;
        while (running) {
            ApplicationThread::Instance()->Queue(runFrame);
            // No need to synchronize since ApplicationThread uses this thread's context
            ApplicationThread::Instance()->Dispatch_();

            // Check the system status message and decide what to do next
            switch (status.load()) {
            case SystemStatus::SYSTEM_RESTART:
                shouldRestart = true;
                // fall down to next
            case SystemStatus::SYSTEM_SHUTDOWN:
                running = false;
                break;
            case SystemStatus::SYSTEM_PANIC:
                std::cerr << "Critical error - exiting immediately" << std::endl;
                exit(-1);
            default:
                continue;
            }
        }