Function U6_AsyncReadManagerThreaded_Request

src/library/UnityHacks.cpp:1195–1236

}

static void U6_AsyncReadManagerThreaded_Request(AsyncReadManagerThreaded *t, AsyncReadCommand *c)
{
    char* filepath = *(char**)c;
    LOG(LL_TRACE, LCF_HACKS | LCF_FILEIO, "U6_AsyncReadManagerThreaded_Request called with file %s", filepath);

    if (!(Global::shared_config.game_specific_sync & SharedConfig::GC_SYNC_UNITY_READS))
        return orig::U6_AsyncReadManagerThreaded_Request(t, c);

    void* complete_callback = *((void**)(c + 0x38));
    // void* complete_callback_arg = *((void**)(c + 0x40));

    /* If possible, we can use this nice helper function that performs a sync
     * read from a command. I didn't experienced any softlock for now. */
    if (orig::U6_SyncReadRequest) {
        return orig::U6_SyncReadRequest(c);
    }

    if (orig::U2K_AsyncReadManagerThreaded_SyncRequest) {
        return orig::U2K_AsyncReadManagerThreaded_SyncRequest(t, c);
    }

    /* This function is less preferable, because it still performs the read in
     * another thread. */
    if (orig::U5_AsyncReadManagerThreaded_WaitDone) {
        orig::U6_AsyncReadManagerThreaded_Request(t, c);
        orig::U5_AsyncReadManagerThreaded_WaitDone(t, c);
        return;
    }

    if (complete_callback != 0) {
        /* We wait until the complete callback is called. */
        std::unique_lock<std::mutex> lock(async_read_mutex);
        async_read_complete = false;

        orig::U6_AsyncReadManagerThreaded_Request(t, c);
        
        async_read_condition.wait(lock, [] { return async_read_complete; });
    }
    else {
        orig::U6_AsyncReadManagerThreaded_Request(t, c);
    }
}

static void U2K_AsyncReadManagerThreaded_SyncRequest(AsyncReadManagerThreaded *t, AsyncReadCommand *c)
{