♬ Phantom Blog

#include <D3D9.h>
#include <DirectXMath.h>

struct Point
{
    Point(const int32_t x, const int32_t y)
        : _x(x)
        , _y(y)
    {
    }
    
    int32_t _x;
    int32_t _y;
};

struct PointF
{
    PointF(const double x, const double y)
        : _x(x)
        , _y(y)
    {
    }
    
    double _x;
    double _y;
};

PointF screen_pos_to_d3d_world_pos(HWND hWnd, IDirect3DDevice9* device, const Point& pt)
{
    using namespace DirectX;

    XMVECTOR screenPos = XMVectorSet(pt.x(), pt.y(), 0, 0);
    XMVECTOR worldPos;
    
    // 获取客户区宽高
    RECT clientRect;
    GetClientRect(hWnd, &clientRect);

    // 获取视口信息
    D3DVIEWPORT9 viewport;
    device->GetViewport(&viewport);

    // 获取投影矩阵
    D3DMATRIX projectionMatrix;
    device->GetTransform(D3DTS_PROJECTION, &projectionMatrix);

    // 获取世界矩阵
    D3DMATRIX worldMatrix;
    device->GetTransform(D3DTS_WORLD, &worldMatrix);

    // 获取视图矩阵
    D3DMATRIX viewMatrix;
    device->GetTransform(D3DTS_VIEW, &viewMatrix);

    XMMATRIX xmProjectionMatrix = XMLoadFloat4x4((XMFLOAT4X4*)&projectionMatrix);
    XMMATRIX xmWorldMatrix      = XMLoadFloat4x4((XMFLOAT4X4*)&worldMatrix);
    XMMATRIX xmViewMatrix       = XMLoadFloat4x4((XMFLOAT4X4*)&viewMatrix);

    worldPos = XMVector3Unproject(
        screenPos,
        viewport.X,
        viewport.Y,
        clientRect.right - clientRect.left,
        clientRect.bottom - clientRect.top,
        viewport.MinZ,
        viewport.MaxZ,
        xmProjectionMatrix,
        xmViewMatrix,
        xmWorldMatrix
    );

    return PointF(XMVectorGetX(worldPos), XMVectorGetY(worldPos));
}

static void routine(std::promise<void*>* p)
{
    RequestContext next_context;

    // g_main_lua_state是主线程的lua状态机
    // 根据它来创建子线程的lua状态机，它们共享全局环境、注册表和栈空间
    // 但新的lua状态机有独立的调用栈，可独立运行
    g_routine_lua_state = lua_newthread(g_main_lua_state);
    
    // 把新状态机记录到全局变量中防止被回收
    // 同时也是平衡主线程lua状态机的栈
    lua_setglobal(g_main_lua_state, "async_request_thread");
    
    // 初始化完毕，唤醒主线程
    p->set_value(g_routine_lua_state);

    for (;;)
    {
        {
            std::unique_lock<std::mutex> lock(g_mutex);
            g_cv.wait_for(lock, std::chrono::milliseconds(100), [] {
                return !g_queue.empty() || g_quit_flag;
            });
            
            // 退出指令
            if (g_quit_flag) {
                break;
            }

            if (g_queue.empty()) {
                continue;
            }

            next_context = g_queue.front();
            g_queue.pop();
        }

        func_request(next_context);
    }

    // 等待子线程lua状态机运行完毕
    while (lua_status(g_routine_lua_state) != LUA_OK && lua_status(g_routine_lua_state) != LUA_YIELD)
    {

    }

    // 关闭子线程lua状态机
    lua_close(g_routine_lua_state);
}

int LUA_API luaopen_async_request(lua_State* L)
{
    luaL_newlib(L, AsyncRequestModuleMethods);

    char full_path[MAX_PATH] = { 0 };
    char abs_full_path[MAX_PATH] = { 0 };

    // 这里是为了从async_request.dll模块的所在目录去加载libcurl.dll模块，libcurl.dll以延迟加载的方式导入
    if (GetModuleFileNameA(GetModuleHandleA("async_request.dll"), full_path, MAX_PATH)) {
        if (GetFullPathNameA(full_path, MAX_PATH, abs_full_path, nullptr)) {
            std::string dll_search_path = std::filesystem::path::path(abs_full_path).parent_path().string();
            SetDllDirectoryA(dll_search_path.c_str());
        }
    }

    // 以g_routine_lua_state是否为空来判断是否已经创建了子线程的lua状态机
    if (g_routine_lua_state) {
        return 1;
    }

    // 初始化libcurl
    curl_global_init(CURL_GLOBAL_ALL);

    std::promise<void*> p;
    std::future<void*> f = p.get_future();

    // 创建子线程，并等待子线程初始化完毕
    g_main_lua_state = L;
    g_routine_thread = std::thread(routine, &p);

    f.wait();

    //luaL_newmetatable(L, "async_request");
    //lua_pushcfunction(L, luaL_async_request_destroy);
    //lua_setfield(L, -2, "__gc");
    //lua_setmetatable(L, -2);

    return 1;
}