Keyboard shortcuts

Press ← or → to navigate between chapters

Press ? to show this help

Press Esc to hide this help

Как прочитать полосу опыта игры, не трогая её память: DXGI desktop duplication на Rust

Я написал эту статью с помощью ИИ. Код лежит в репозитории, а каждое число ниже взято из руководства проекта, из его журнала изменений или из самого кода.

PoE2 Oracle — бесплатная программа с открытым кодом для Path of Exile 2 под Windows, написанная на Rust: проверка цен и оверлей опыта. Оверлей ставит на интерфейс игры плашки, которые показывают, как быстро вы растёте в уровне и когда будет следующий. Для этого программе нужно знать, насколько заполнена полоса опыта.

Пиксели, а не память

Программа читает полосу с экрана. Память игры она не трогает никогда. Полоса выведена на экран для игрока — значит, её видит и программа. Страница руководства «Конфиденциальность» перечисляет, что программа читает на вашем компьютере: среди прочего два файла игры (файл настроек и журнал, оба только на чтение) и экран. Памяти игры в этом списке нет.

От копии экрана к дублированию рабочего стола

Плашки стоят на двух планках интерфейса игры. Когда игра рисует поверх планки подсказку, панель или чат, плашка должна уйти в сторону. Чтобы это заметить, поток-наблюдатель смотрит на несколько строк верхнего края каждой планки — её кромки. Тот же взгляд читает и полосу.

Старый способ — копия экрана через GDI. Она ждёт следующей сборки кадра рабочего стола: на тестовом ПК с игрой в 4K — 11 мс на одну кромку, 27 мс на обе, бывает и до 145 мс. Раз в две секунды это приемлемо, а для многих взглядов в секунду слишком медленно.

С DXGI desktop duplication Windows отдаёт программе каждый собранный кадр рабочего стола как текстуру Direct3D. Программа копирует из неё несколько строк на видеокарте и читает обратно только их. В lip_watch.rs функция Duplication::open выбирает выход видеокарты — монитор под серединой клиентской области окна игры, создаёт на его адаптере устройство Direct3D 11 и вызывает DuplicateOutput1. Она просит только 8-битный BGRA: как сказано в комментарии к коду, именно он приходит при любом рабочем столе, в том числе с HDR.

Копируются три прямоугольника: две кромки и полоса заполнения вместе с ножками засечек (1536 на 10 пикселей на тестовом ПК с 4K). Все они в физических пикселях, как и прямоугольник самого монитора. Код считает, что интерфейс игры масштабируется по её высоте, поэтому каждый прямоугольник рассчитан для 2160 строк и пересчитывается под настоящую высоту. CopySubresourceRegion складывает их в одну маленькую промежуточную (staging) текстуру, кромки первыми. Вот сердцевина одного взгляда, сокращённая из Duplication::look:

// …
match unsafe {
    self.duplication
        .AcquireNextFrame(wait, &mut info, &mut resource)
} {
    Err(err) if err.code() == DXGI_ERROR_WAIT_TIMEOUT => return Ok(()),
    other => other.context("AcquireNextFrame")?,
}
self.framed = true;
// A present time of zero: only the pointer moved.
let copied = match resource {
    Some(frame) if info.LastPresentTime != 0 => {
        self.copy(slot, &frame, lips, bar, game, now).map(Some)
    }
    _ => Ok(None),
};
// Windows holds the next frame back until this one is released. The copies are queued
// on the GPU before the release, so they read this frame.
unsafe { self.duplication.ReleaseFrame() }.context("ReleaseFrame")?;
// …

wait равен 100 мс, пока новое дублирование не получило первый кадр, и нулю после этого. Изменённые и сдвинутые прямоугольники кадра (dirty и moved rects) код не использует.

Не ждать видеокарту

Чтобы процессор прочитал промежуточную текстуру, её нужно отобразить в память (Map). Ранняя сборка делала это сразу после того, как ставила копирование в очередь, и Map ждал внутри графического драйвера, в потоке наблюдателя, пока видеокарта доберётся до копии за работой самой игры. По замеру 27 сентября 2026 года, с игрой на переднем плане в покое, этот поток тратил 1,45 мс процессора на взгляд при четырёх взглядах в секунду. И делал четыре переключения контекста на взгляд: три — на опрос ввода и одно — на это ожидание.

Теперь Map пробуют через 4 мс после копирования, с флагом D3D11_MAP_FLAG_DO_NOT_WAIT:

while let Some(slot) = self.oldest() {
    // …
    match unsafe {
        self.context.Map(
            &texture,
            0,
            D3D11_MAP_READ,
            D3D11_MAP_FLAG_DO_NOT_WAIT.0 as u32,
            Some(&mut mapped),
        )
    } {
        Err(err) if err.code() == DXGI_ERROR_WAS_STILL_DRAWING => break,
        other => other.context("Map")?,
    }
    // …
}

Если видеокарта ещё не закончила, поток пробует позже, удваивая ожидание до 50 мс. Три промежуточные текстуры работают по очереди, а взгляд, который застал занятыми все три, пропускается.

Когда он смотрит, а когда нет

Наблюдатель — обычный поток, а каждое его сообщение через async_channel будит поток интерфейса, поэтому он сообщает только о переменах: планку стало видно там, где её не было видно, или наоборот. Показание полосы меняется по мере того, как идёт опыт, поэтому оно идёт мимо канала: лежит в AtomicU64 как биты f64, а u64::MAX — образец NaN, которого у заполнения не бывает, — значит «показания нет». Сэмплер забирает его каждые две секунды.

Поток наблюдает, только пока игра на переднем плане и не свёрнута, и ещё две секунды после — чтобы быстрый щелчок по другому окну не обрывал дублирование. Передний план он не опрашивает: Windows сама сообщает о каждой смене. В остальное время он спит, а дублирование и его устройство освобождаются вместе с видеопамятью — 32 МиБ под кадр монитора в 4K. Пока игра за другим окном, работает старая копия экрана: раз в две секунды для планок и раз в десять — для полосы.

Пока он наблюдает, темп следует за игроком:

  • Взгляд каждые 50 мс, пока движется мышь или нажимаются клавиши, и пока игрок не замрёт на 250 мс.
  • Дальше каждый взгляд ждёт столько, сколько игрок не двигался к прошлому взгляду, но не больше 2 секунд.
  • На закрытую планку поток смотрит каждые 250 мс в течение 10 секунд после последнего ввода.

Полоса читается во взгляде не чаще раза в 500 мс. Игра выводит кадры гораздо чаще: взгляд на каждый её кадр стоил 4 % ядра при 77 кадрах в секунду. При 50 мс подсказка над планкой замечается примерно через 55 мс после кадра, который её показал.

Между взглядами поток спит на ожидаемом таймере высокого разрешения. Пока игрок не двигается, сон прерывает и сырой ввод (raw input). Поток регистрирует мышь и клавиатуру с RIDEV_INPUTSINK на собственное окно, которое принимает только сообщения (message-only). При первом же сообщении он снимает регистрацию через RIDEV_REMOVE, так что сотни сообщений в секунду от движущейся мыши до него не доходят. Он узнаёт, что игрок что-то сделал, но никогда — какую клавишу нажал или где. Собственный ввод игры не затрагивается. Низкоуровневый перехватчик мыши пропускал бы через программу каждое её сообщение. Если сырой ввод не приходит — так бывает с игрой, запущенной от имени администратора, — поток вместо этого спрашивает GetLastInputInfo каждые 100 мс.

Сколько это стоит

Страница руководства «Производительность» сравнивает сборку с асинхронным чтением и пробуждением по сырому вводу (коммит 5fc9b59) со сборкой перед ней. ПК: NVIDIA RTX 4090, два монитора 3840 × 2160 с масштабом 200 %, игра на переднем плане. В покое весь процесс тратил 53 мс процессора в минуту, из них 6,8 мс — наблюдатель. Пока мышь двигалась, наблюдатель брал 158 мс в минуту. В сборке перед ней один наблюдатель брал 347–399 мс в минуту в покое и 3199 мс, пока мышь двигалась. По сравнению с ней PoE2 Oracle тратила примерно в 8 раз меньше процессора в покое и в 16 раз меньше при движении мыши. Это один ПК и один сеанс: метод и оговорки — на странице «Производительность».

Что может пойти не так

  • Два монитора. Одно дублирование покрывает один выход. Если кромки и полоса не все на дублируемом мониторе, наблюдатель один раз пишет причину в лог и оставляет плашки старой копии экрана.
  • Потерянное дублирование. Его обрывают смена режима экрана, защищённый рабочий стол запроса UAC или монопольный полноэкранный режим другой программы. Наблюдатель открывает новое на следующем круге, а после неудачи ждёт 3 секунды.
  • Окно над полосой. Дублируется собранный рабочий стол, вместе с панелью цены, и окно поверх полосы, которое пройдёт проверки заполнения, прочиталось бы как неверное заполнение. Поэтому программа спрашивает WindowFromPoint в девяти точках вдоль полосы и требует, чтобы во всех было окно игры.
  • Другие раскладки. Положение планок подтверждено только для 16:9. При других раскладках интерфейса игры плашка не показывается.

Как читается заполнение

У полосы 20 делений и 19 декоративных засечек, тёмные ножки которых свисают ниже заполнения. read_fill возвращает долю уровня или None, если на экране не совершенно точно полоса. На месте должны быть хотя бы 17 ножек из 19. Дорожка должна показывать либо яркое тёплое начало, хотя бы вдвое ярче остального (выбиваться могут 3 % столбцов), либо отсутствие заполнения и тёмную дорожку. Заполнение отличают от дорожки по относительной яркости, а не по цвету и не по фиксированному порогу. Подсказка, панель или экран загрузки над полосой дают None и никогда — полосу полнее, чем она есть.

Дважды пиксели подвели так, что это видели игроки. Когда указатель лежал на полосе, её подсказка заставляла полосу читаться почти полной: 94,75 % в течение 40 секунд, хотя полоса показывала 59,33 %. Игрок 93 уровня полчаса видел +250…350 %/ч — до версии 0.1.1. Теперь показания откладываются, пока указатель рядом с полосой, и ещё секунду после. Тёплый свет в сцене заставлял пустую часть читаться заполненной: игрок 93 уровня видел +186 %/ч там, где настоящая скорость была около +40 %/ч, — до версии 0.1.3.

От заполнения к опыту в час

Трекер берёт показание каждые две секунды и читает журнал игры: повышения уровня и смены локаций. Скорость — это опыт за час игры в процентах текущего уровня. Недавняя игра весит больше: при «Сглаживании скорости» 10 минут (по умолчанию) игра десятиминутной давности весит вдвое меньше, чем игра сейчас. Время в городах и убежищах не считается. Время до следующего уровня — это оставшееся время игры при такой скорости. Остальное — на странице «Оверлей опыта».

Код

Код — в файле lip_watch.rs репозитория. Программа — на сайте oracle.pushka.biz.

PoE2 Oracle — фанатский инструмент. Он никак не связан с Grinding Gear Games и не одобрен ею. Path of Exile — товарный знак Grinding Gear Games.

Тексты и код я пишу с помощью ИИ (Claude). Устройство программы придумываю я сам, каждый выпуск проверяю в своей игре и исправляю то, о чём вы сообщаете.