Серия игр Heroes of Might and Magic - GL Wrapper & Patches

О, Бараторч, здарова!
О, Дима, здарова! И ты здесь. У меня ощущение, что, куда ни пойду, где ни зарегистрируюсь, ты все равно меня там найдешь...
К слову, можно было бы и рассказать про враппер всем, а то я-то про него недавно чисто случайно узнал

 

Я подробностей не знаю, но речь о людях, которые пытаются поиграть именно в Хоту, и которые не знают что у них в папке с игрой делает файл ddraw.dll.
Я догадался, что качается какая-то сборка. Спрашивал что за сборка, но мне никто не ответил. Единственное чего смог добиться - в одном случае мне прислали 'виновную' в краше ddraw.dll и это оказалася враппер версии 1.35 build 279.
Понятное дело, что есть конфликт хд мода и враппера, но люди не шарят вообще про какие-то там врапперы, они просто хотят поиграть и не могут. Я конечно считаю, что нефиг качать какие-то непонятные сборки, но люди это делают, и у меня совершенно нет времени и желания разбираться с людьми, отвечать им что-то. Гораздо проще что-то закодить, особенно закодить что-нибудь простое.


***

Каких именно фич ХД (перечислите подробно) не хватает в Эре, напишите (вы уже наверняка писали, но если так, сделайте это, пожалуйста, еще раз) мне на почту.
Обрезание фич для вог/эры обусловлено тем, что хорошая дружба ХД и вог/эры возможна только при взаимной работе, взаимодействию с двух сторон. Со стороны вог такое невозможно. Со стороны эры, когда обрезался ХД, берсеркер и сочувствующие тоже были не особо активны. Я получал минимум фидбэка от пользователей Эры, поэтому интерес и пропал.

 

Хм, да с коментариями и чейндж-логами здесь проблема, я не оставлял их, так как делаю это только для себя, ну и сурсы выкладываю для публики на их усмотрение.

А в чем разница в настоящем полноэкране? В DirectX указывается какой режим эксклюзивный или нормальный. В OpenGL это не документируется изза кросплатформености, и это все на управлении винды и драйверов. Враппер также просто меняет размер окна под размер рабочего стола и убирает стили чтобы окно было попроще WS_CAPTION.

Проблема в том что у меня, и не только, есть проблемы с выходом из полноэкранного режима в OpenGL, после чего изображение подвисает. Это возникает из-за неверного удаления OGL контекста после выхода из полноэкранного режима. Контекст полностью удаляетсятолько только с удалением окна, но враппер не может удалить окно игры. Вот изза этого я и делал этот дурацкий код с дублирующим окном, чтобы рисовать в нем и по возможности легко удалять вместе с контекстом.

Другой способ это сделать окно чуть больше рабочего стола, чтобы драйвер не делал OGL эксклюзивным, токда не нужны танцы с дублирующим окном, но тогда OGL рендерится вместе с DWM. Плюс в этом то что не нужен vSync, но зато чутку падает производительность. Правда я замечал что и этот способ не всем помогает, но всетаки подавляющему большинству все ок. Но этого способа кажись я в этот враппер не внедрял.

Я незнаю как сделано в враппере HD мода. Кажись я как-то запускал и вроде проблем у меня небыло, что чутку для меня странно. Но и интересно, возможно я что-то упускаю...

Ну здесь нужно смотреть какие у тебя есть сурсы на враппер, и те которые были у меня на тот момент. Даже й не знаю что делать. Я также сталкиваюсь с вопросами таких игроков, и я им говорю что враппер для ванильной версии, без модов, так как возможны конфликты. И если играете с HD то лучше без враппера.

Как-то пробежкой читал о твоем patcher_x86. Разбиратся конечно лень, так как меня полностью устраивает моя простенькая библиотека (каждому свое). Понимаю для чего ты эго писал, для воизбежания конфликтов модов и мододелов, и patcher_x86 это дает если использовать только его. Но вот переводить все хуки враппера под него, конешно лень. Здесь наверное нужно сделать какой-то общий проект враппера под HD. Например на том же гитхабе, и вносить измененя общими усилиями.

Если хочеш, создай проект с сурсами враппера что у тебя есть, а я уже посмотрю что и как.
Конешно можно и SVN если пользуешся и имееш сервак для него, чтобы дать линк. Ну или я у себя создам SVN репозиторий а ты уже подключишся

На вскидку помню только что из последних улучшений это
- графически - фильтр Lancoz выглядит хорошо, ну и настройка цвета (вряд ли кому нужна)
- геймплей - плавная прокрутка карты
все остальное это какие-то фиксы проблем преыдущих версий враппера

Как я понимаю игроки как-раз тащятся от плавного движения героя и прокрутки карты. Но это конешно не заслуга OpenGL, а просто хук, и лучше внедрять это в сам HD мод, а не в его рендерер. Правда в таком случае увеличивается количество FPS и не понятно как это повлияет на остальные GDI режимы.

Если интересно, то помогу с поиском этих хуков в актуальном коде враппера, для переноса на HD

--- добавлено 23 окт 2020, предыдущее сообщение размещено: 23 окт 2020 ---

Тепеь вижу почему люди вместе с HoTA ставят внешний враппер. Это наверное моя вина, так как меня спрашивали, и я попробовал, и кажись пошло. После этого наверное я у себя в блоге написал инструкцию для HoTA. Надо будет это убрать

 

Я конечно же пробовал плавное перемещение героя без вывода через OpenGL, производительности других режимов вывода совершенно недостаточно, по крайней мере для 60 fps Перемещение не получается таким плавным. Поэтому я допилил плавное перемещение (я вижу ты уже тоже), но оставил его включенным только с OpenGL.

Думаю это не твоя вина, так как проблема в том что люди используют игру с враппером (скорее всего не зная ничего про враппер) и при этом режим (stretchable) 32-bit GDI, который ставится по умолчанию в ХД.

Я с SVN совсем не дружон. Чуть-чуть дружу с git.

Еще я совершенно не дружу с 3Д вообще и с OpenGL в частности, и поэтому ковырять этот код для меня сложно.
Хотя вот глянул на код шейдеров (первый раз в жизни) и написал свой вариант шейдера-апскейлера SaI. Сейчас в ХД он называется SmoothSaI.
Мне этот апскейлер очень нравится, считаю что кроме него и xBRZ - остальные ненужный хлам. Однако с ним картинка получается довольно мыльной. В софтверной реализации SmoothSaI в GDI режимах ХД я немного подкручиваю резкость в плюс (уже после интерполяции) и картинка получается отличной. А вот для opengl нужен шейдер интерполяции типа "билинейная резче" или "бикубическая резче", или вообще постобработка - дополнительный шейдер "увеличить резкость", однако такое я запилить не смог.

не только для этого, а для удобства и скорости написания в том числе.

например, код:

Код:

    VOID __stdcall CalcRunPos(DWORD* obj, DWORD idx)
    {
        ...
    }

    DWORD sub_DrawSizedRect_1;
    VOID __declspec(naked) hook_0048017C()
    {
        __asm
        {
            PUSH ECX
            PUSH EAX

            PUSH EDI
            PUSH ESI
            CALL CalcRunPos

            POP EAX
            POP ECX
            JMP sub_DrawSizedRect_1
        }
    }

    sub_DrawSizedRect_1 = RedirectCall(hooker, hookSpace->move_address, hook_0048017C);

можно было бы заменить кодом:

Код:

    _PI->WriteLoHook(hookSpace->move_address, [](LoHook* h, HookContext* c) -> int
    {
        DWORD* obj = (DWORD*)c->esi;
        DWORD idx = c->edi;
        ...
        return EXEC_DEFAULT;
    });

ну или без лямбды кодом:

Код:

    int __stdcall hook_0048017C(LoHook* h, HookContext* c)
    {
        DWORD* obj = (DWORD*)c->esi;
        DWORD idx = c->edi;
        ...
        return EXEC_DEFAULT;
    }
    
    _PI->WriteLoHook(hookSpace->move_address, hook_0048017C);

но да ладно...

Вот в враппере кликнув на кнопку "развернуть" просто меняется размер окна.
И в ХД перейдя в "полноэкранный" режим просто меняется размер и флаги окна, DisplayMode не меняется, DisplayFrequency не меняется, cursorTime не перерассчитывается, RenderStop не вызывается, "Поверхности" не пересоздаются, ничего прочего не делается. Зачем это все? Ради более производительного эксклюзивного режима?

 

Ну это понятно, это по умолчанию

Ну я как-то пробовал твой кажись BaraSaI, смотрится отлично, правда я играю без апскейлинга. Мне обычный бикубический и ланцош нравится. Там от 3д почти ничего нет. Апскейлеры рендерятся сначала в скрытий фрейм буфер, а потом уже выводится на экран через фильтр интерполяции, то-есть можно сказать что пост обработка

Я с git тоже не сильно дружу, так как закидываю только свои сурсы, и в кооперативе раз другой только приходилось работать. С SVN попроще, да и в общем он намного проще, хоть идеи общие.
Для обеих я использую клиенты TortoiseSVN или TortoiseGit.

SVN клиент самодостаточный, и я держу свой сервак у себя, соответственно могу создать закрытый репозиторий. ну а GIT клиент держу только для GitHUB

Если есть желание и лучше для тебя GIT - то тогда создай ты репозиторий, а я подсоединюсь.
Если же SVN - то я создам репозиторий у себя, и просто отправлю тебе линк с правами доступа

 

Спасибо большое за быстрый ответ!)
Да уж, обновления HD mod и Эры шли как-то независимо.
Тем не менее список я подготовил, и хочу лишь уточнить, почта для связи та же, что и всегда (указанная в hd launcher / информация, а именно: baratorch_yandex_ru) ?
Письма на эту почту остаются пока без ответа.

Кстати, если нужно содействие по Эре, то ethernidee_yandex_ru — почта Берсеркера.
Искренне надеюсь на плодотворные результаты

 

@Baratorch, На случай если будет интересен SVN. Я создал пустой репозиторий. Если пройти по линку, то там можно просмотреть репозиторий а также изменить пароль (Account -> Change Password)
- http://svn.verokster.com:81/paches/Heroes/Heroes3HDGL/
- логин: baratorch
- пароль: barasvn - (желательно сменить пароль)

Я закреплю здесь простенькую инструкцию по пользованию TrotoiseSVN. Этот пост будет полезен тем кто ниразу не пользовался SVN

Сначала зайти на сайт https://tortoisesvn.net/downloads.html и скачать нужный клиент под нашу ОС. Сейчас актуальный клиент TortoiseSVN 1.14.0 - 32/64-bit. Там также есть и языковые пакеты для своего языка.

Инструкция же для более старой англ. версии и на WinXP. Но отличий с актуальной версией почти никаких.

Устанавливаем сначала TrotoiseSVN клиент. Установка проста, без лишних настроек. После установки можно поверх установыть свой языковый пакет. После всего этого желательно перегрузить ПК

Создаем пустую новую папку по свой проэкт. Правой кнопкой миши но созданой папку, и в контекстном меню выбираем Checkout (Извлечь)

Спойлер: Create and Checkout

Появится окно TortoiseSVN клиента с опцией Checkout.

Спойлер: Checkout dialog

В поле URL of repository ввести адрес репозитория (выше). В поле Checkout directory должен быть уже вказан путь нашей локальной папки. Все остальное оставляем как есть и жмем кнопку OK.

Клиент запросит даные доступа: логин и пароль (выше). Вводим их, и ставим галочку Save authentification для того чтобы запомнить, и жмем OK.

Спойлер: Authentification

Мы увидим что наша папка синхронизирована, и имеет иконку с зеленой галочкой

Спойлер: Authentification

После этого если вызвать контекстное меню для папки, появятся дополнительные опции TortoiseSVN. Нас же интересуют в основном:
- SVN Update - для обновления локальной папки из репозитория (загрузка файлов)
- SVN Commit - для обновления репозиторя из локальной папки (выгрузка файлов)

Спойлер: Update|Checkout

На даном этапе пока что ничего не нужно нажимать, так как у нас папка в актуальной версии (зеленый значек)

Если зайти в папку, то мы увыдим системную папку .svn, она видима в том случае если в винде включена видимость системных и скрытых файлов

Спойлер: .svn

Создаем файл например test.txt, Мы увидим к нему значек знака вопроса что значит что такого файла еще нет в репозитории, тоесть он неверсионен. Редактируем наш файл если нужно, и вызываем на нем контекстное меню чтобы добавить его в репозиторий

Спойлер: Add file

После этого файл имеет значек + (плюса), что значит что файл еще не в репозитории, но уже готов к добавлению и синхронизации.

Спойлер: Added file

Для синхронизации вызываем снова контексное меню на новом/измененном файле, или на корневой папке. И жмем SVN Commit

Спойлер: Commit folder

Появится окно коммита. В окне, в поле Message для лога указываем причину коммита (не обязательно). Убеждаемся какие файлы выбраны и жмем OK

Спойлер: Commit dialog

Появится окно коммита с результатами

Спойлер: Commit results

После успешного коммита иконка файла и его папки станет зеленой

Спойлер: Commit success

Всё, файлы в репозитории на сервере.

Если файл снова изменить то его иконка, а также иконки всех родительских папок станут красными, что значит что файл был изменет

Спойлер: Modified

Делаем также как и раньше. вызываем контексное меню и жмем SVN Commit.
Чтобы обновить файлы из репозитория, нужно вызвать контексное меню и выбрать SVN Update.

--- добавлено 23 окт 2020, предыдущее сообщение размещено: 23 окт 2020 ---

Все это конешно только базовое пользование, без всяких ветвления, бренчей и тегоа. Но этого достаточно.

C TortoiseGit почти также. Коммиты, обновления, бренчи и тд..

 

Если что, я уже написал)
Забыл только добавить, что переигровка боя вызывает сломанную тень курсора под самим курсором, когда не соглашаешься с результатами боя. Проявляется только на HD 5, ныне сделан костыль, который отключает "тень курсора" при каждой переигровке, но тогда она не возвращается. А это уже я скриптом ну очень уж закостылил.
UPD: нет больше такой проблемы, говорят.

Если получится добавить смену артов на кукле героя на "shift+ЛКМ", то вообще сказка будет)

Кстати, забыл указать, что на HD mod 5.0+ 32-бит цветовой режим не поддерживает больше цветные шрифты. Ныне они работают лишь в 16-битном режиме. На HD mod 4.208 цветной текст был в режиме 32-bit TRUE, кажется.
Если потребуется, могу скинуть готовую сборку со всеми настройками. И видео могу записать.

 

@Verok, я уже закончил интеграцию свежего враппера и потом узнал что для скачивания доступен враппер 1.50 билд 428.
А я работал с гитхабовскими исходниками 1.49 билд 412. Можно узнать что изменилось? М.б. закоммитишь изменения на гитхаб?

C svn я пока не пытаюсь разобраться, отложу это на попозже.

***

Нет, цветной текст никогда не работал в 32-bit TRUE режимах в ХД. Для этого нужно переписывать код цветного текста под 32 бита. Я считаю, это лучше сделать со стороны Эры, с помощью моих консультаций.

 

@Baratorch, Обновил сурсы. Там из значимых изменений только фикс для Bink Video, то-есть чтобы враппер проверял Bink файлы даже если их нет в таблице экзешника, а только Smack (см Hooks->CreateFileHook).
А второе фикс для стартового бонуса для сценария, когда нужно выбрать героя а не ресурсы или артефакты (см. Hooks->hook_00457CC9)

Я эти фиксы описывал несколько постов выше. Лучше их интегрировать напрямую в сам мод, если их там еще нет.

Из остальніх изменений, это всякие обертки для манифеста диалогов и всякая иная мелочь
Вот скрин с изменнніми файлами, остальное будет видно на самом GitHUB

 

@Verok, При закрытии окна настройки цвета через крестик в правом верхнем углу - игра падает. Я это решил добавив return NULL; в конец case WM_CLOSE: { этого окна.
(а потом еще и крестик убрал совсем)

С фиксами Bink и стартового бонуса я разберусь позже. Я ведь и так выпиливаю большую часть того, что не связано с графическим режимом.
Например я исключил плавную прокрутку карты, т.к. у меня она не плавная (чуть подергивается через некоторые промежутки). В оригинальной прокрутке частота кадров низкая, но прокрутка идет равномерно, без подергиваний.

***

Несколько вопросов еще:
1. Зачем нужны хуки AIL_waveOutOpenHook, AIL_stream_positionHook, AIL_open_streamHook, AIL_set_stream_positionHook? Что они делают?
2. Зачем нужен хук StrToDoubleHook? Зачем внутри менять запятую на точку?
3. зачем нужен activation context (я не знаю) и все эти CreateActCtxC, ReleaseActCtxC, ActivateActCtxC, ...?
4. Я не очень в курсе что там с bink и со стартовым бонусом для сценария в игре. Можно объяснить как увидеть проблему без фикса и увидеть ее исчезновение с фиксом, что нужно делать в игре, на что смотреть?
5. в 1.50 относительно 1.49 появились изменения с кодом вертикальной синхронизации. Можно прокомментировать? VSync теперь работает только в полноэкране?

 

@Baratorch, Спасибо за фикс. Я это в других врапперах подфиксил, наверное для HoMM забыл.

Ух, постараюсь все потихоньку вспомнить, так как лог не веду, а по ревизиям смотреть лень

Наверное самое старое из вопросов. AIL_waveOutOpenHook захардкодена 44100/2ch для музыки, в HD мооде похожий фикс есть. Все остальное для внешнего аудио файлов, для музыки в форматах wav, для запоминания позиции трека кажись входа/выхода из замок или меню, точно уже сказать не могу, лучше здесь форум листать, гдето на первых страницах я это описывал

Некоторые параметры существ в русской локализации записаны через запятую, изза чего игра плохо конвертирует их. Игра наскольо я помню локаль не ставит, и у меня были неверные результаты при atof, все что после запятой не парсалось. Как сейчас помню число 0,7 ставало 0.0. Вообще то эту проблему не я нашел, а один парень с ником Sergey, правда он эту проблему увидел в одном только месте, я же увидел что это еще в нескольких местах, поэтому сделал глобальный хук на atof

Ну через него я подключал манифест для стилей XP+, так как прилагать отдельно манифест не хотел ну и экзешника у меня нет. Может не элегантно, но других методов и не искал. В HD моде с эти попроще, так как у него есть главный исполняемый файл с манифестом, поэтому можно спокойно убирать все эти вызовы с моими хуками

Игроки жаловались что в некоторых играх если в архиве и есть BIK ролик, то всеравно играет SMK не взирая на настройку проигрывания BIK. В экзешнике захардкодена таблица с роликами, где указано для каждого ролика свой формат. Поэтому и случалось что BIK ролики не проигрывались так как или экзешник не от родного релиза, или ролики взяты откуда еще. Например кажись в той же эрафии много BIK роликов, но с приходом AB ролики оставляли только SMK, наверное для экономии места на носителях.
Поэтому пришлось при инициализации сначала таблицу переписать чтобы все ролики были с флагом SMK, а потом вовремя хука CreateFile парсить открываемый архив на BIK файлы, сравнивая их с таблицей, и ставить в таблице флаг BIK если файл в архиве был найден

Для примера старт первого сценария кампании "Отголоски Войны" из "Эрафии". Там как стартовый бонус дают выбрать героя, а не ресурсы и не артефакты как для большинства других сценариев. Когда загружается экран деталей сценария и выбора стартового бонуса, то нет еще выбраной ячейки, и игроку предстоит выбрать 1 из 3х для того чтобы начать сценарий. Так как ячейка еще не выбрана SelectedIndex = -1. Для ячеек с артефактами или ресурсами есть проверка на SelectedIndex != -1, иначе считать что 0. Для ячеек с героями этой проверки нет ни в одной версии, изза чего игра при выборе или старте кампании падала. Чтобы проверить можно попытаться несколько раз начать новую кампанию "Отголоски Войны". Этот баг особенно случается на 4.0 от буки

От vSync а точнее wglSwapIntervalEXT нет смысла в оконном режиме, так как OpenGL в винде работает через GDI и в окноом режиме все синхронизировано с DWM. У меня если в оконном режиме включать wglSwapIntervalEXT(1) то FPS не 60 а 59. wglSwapIntervalEXT тошнотная штука, если хочеш можеш прочитать доки . У меня на ноуте вообще эта зараза не работает, а изобритать велосипед со своим таймером не хочу.

Короче если хочешь можеш оставлять код от 1.49, разницы в большинства не будет никакой, тем более на него кажись никто не жаловался

--- добавлено 27 окт 2020, предыдущее сообщение размещено: 27 окт 2020 ---

Да с этим есть нюанс. Не помню юзал ли я QueryPerormanceCounter и Frequency, но некоторое подергивание наверное изза таймера. Больше же проблем создает vSync при wglSwapIntervalEXT(1) вместе с DWM (desktop window manager), почему-то вообще скипаются кадры в оконном режиме, не взирая на то скачет ли герой, илли прокручивается карта. Понятия не имею почему так, углубленно этим не занимался.
Кстати если юзаеш сам враппер, то лучше отключить ColdCPU так как он притормаживает игру и при скролинге больше дергается

Я вообще о HoMM врапперах мало что помню, так как в основном занимаюсь иными играми, а H3 вообще был в наинизшем приоритете из серии, для галочки, хотя плавность сделал какраз только для нее, и без нее играть уже в 3-ку не могу

 

Возможно, я перепутал с другим режим на 32 -bit, который назывался GDI. Но я буду рад, если бует написан код сразу под HD mod, в том числе и ddraw.dll от ув. Verok.

Дабы не плодить здесь offtop (вроде как) и получить консультации ,указываю ссылку на Дискорд Сервер по Эре, там же есть и Berserker. Могу скинуть либой иной удобный канал связи по запросу.

 

@Verok, Я получил свежий репорт от тестировщика команды хоты о работе свежего враппера 1.50 интегрированного в ХД мод:

Здесь уже писали о таком..

Сам проверил на виртуальной машине со слабой графикой и обнаружил что в новом враппере 1.50 исчезновение кнопок есть даже с OpenGL 1 Renderer.
А вот в старом враппере 1.24 этого не наблюдаю.

Я взял код RenderOld от 1.24 вставил его в 1.50, убрал лишнее, переименовал нужное
и на моей виртуальной машине кнопки при нажатии исчезать перестали.

Я совершенно не знаю OpenGL, и код довольно объемный, поэтому я не смогу понять в чем разница.

Спойлер: Вот код старого RenderOld

Код:

VOID OpenDraw::RenderOldOld()
{
    if (this->filterState.interpolation > InterpolateLinear)
        this->filterState.interpolation = InterpolateLinear;

    DWORD glMaxTexSize;
    GLGetIntegerv(GL_MAX_TEXTURE_SIZE, (GLint*)&glMaxTexSize);
    if (glMaxTexSize < 256)
        glMaxTexSize = 256;

    DWORD size = this->mode.width > this->mode.height ? this->mode.width : this->mode.height;
    DWORD maxAllow = 1;
    while (maxAllow < size)
        maxAllow <<= 1;

    DWORD maxTexSize = maxAllow < glMaxTexSize ? maxAllow : glMaxTexSize;
    DWORD glFilter = this->filterState.interpolation == InterpolateNearest ? GL_NEAREST : GL_LINEAR;

    DWORD framePerWidth = this->mode.width / maxTexSize + (this->mode.width % maxTexSize ? 1 : 0);
    DWORD framePerHeight = this->mode.height / maxTexSize + (this->mode.height % maxTexSize ? 1 : 0);
    DWORD frameCount = framePerWidth * framePerHeight;
    Frame* frames = (Frame*)MemoryAlloc(frameCount * sizeof(Frame));
    {
        Frame* frame = frames;
        for (DWORD y = 0; y < this->mode.height; y += maxTexSize)
        {
            DWORD height = this->mode.height - y;
            if (height > maxTexSize)
                height = maxTexSize;

            for (DWORD x = 0; x < this->mode.width; x += maxTexSize, ++frame)
            {
                DWORD width = this->mode.width - x;
                if (width > maxTexSize)
                    width = maxTexSize;

                frame->point.x = x;
                frame->point.y = y;

                frame->rect.x = x;
                frame->rect.y = y;
                frame->rect.width = width;
                frame->rect.height = height;

                frame->vSize.width = x + width;
                frame->vSize.height = y + height;

                frame->tSize.width = width == maxTexSize ? 1.0f : (FLOAT)width / maxTexSize;
                frame->tSize.height = height == maxTexSize ? 1.0f : (FLOAT)height / maxTexSize;

                GLGenTextures(1, &frame->id);

                GLBindTexture(GL_TEXTURE_2D, frame->id);

                GLTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, config.gl.caps.clampToEdge);
                GLTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, config.gl.caps.clampToEdge);
                GLTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
                GLTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
                GLTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, glFilter);
                GLTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, glFilter);

                GLTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

                if (this->mode.bpp == 16)
                {
                    if (config.gl.version.value > GL_VER_1_1)
                        GLTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, maxTexSize, maxTexSize, GL_NONE, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, NULL);
                    else
                        GLTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, maxTexSize, maxTexSize, GL_NONE, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
                }
                else
                    GLTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, maxTexSize, maxTexSize, GL_NONE, config.gl.caps.bgra ? GL_BGRA_EXT : GL_RGBA, GL_UNSIGNED_BYTE, NULL);
            }
        }

        GLMatrixMode(GL_PROJECTION);
        GLLoadIdentity();
        GLOrtho(0.0, (GLdouble)this->mode.width, (GLdouble)this->mode.height, 0.0, 0.0, 1.0);
        GLMatrixMode(GL_MODELVIEW);
        GLLoadIdentity();

        GLEnable(GL_TEXTURE_2D);
        GLClearColor(0.0f, 0.0f, 0.0f, 1.0f);
        this->viewport.refresh = TRUE;

        VOID* frameBuffer = MemoryAlloc(maxTexSize * maxTexSize * (this->mode.bpp == 16 && config.gl.version.value > GL_VER_1_1 ? sizeof(WORD) : sizeof(DWORD)));
        {
            {
                BOOL isVSync = FALSE;
                if (WGLSwapInterval)
                    WGLSwapInterval(0);

                DWORD clear = TRUE;
                do
                {
                    OpenDrawSurface* surface = this->attachedSurface;
                    if (this->attachedSurface)
                    {
                        if (WGLSwapInterval)
                        {
                            BOOL vs = config.image.vSync && o_FullScreenMode;
                            if (isVSync != vs)
                            {
                                isVSync = vs;
                                if (WGLSwapInterval)
                                    WGLSwapInterval(isVSync);
                            }
                        }

                        if (this->CheckView())
                        {
                            clear = TRUE;
                            GLViewport(this->viewport.rectangle.x, this->viewport.rectangle.y, this->viewport.rectangle.width, this->viewport.rectangle.height);
                        }

                        FLOAT currScale = surface->scale;
                        BOOL isSizeChanged = surface->isSizeChanged;
                        if (surface->isSizeChanged)
                        {
                            surface->isSizeChanged = FALSE;
                            clear = TRUE;
                        }

                        DWORD glFilter = 0;
                        FilterState state = this->filterState;
                        this->filterState.flags = FALSE;
                        if (state.flags)
                            glFilter = state.interpolation == InterpolateNearest ? GL_NEAREST : GL_LINEAR;

                        UpdateRect* updateClip = surface->poinetrClip;
                        UpdateRect* finClip = surface->currentClip;
                        surface->poinetrClip = finClip;

                        if (clear)
                        {
                            if (clear < 3)
                            {
                                if (clear & 1)
                                {
                                    updateClip = (finClip == surface->clipsList ? surface->endClip : finClip) - 1;
                                    updateClip->rect.left = 0;
                                    updateClip->rect.top = 0;
                                    updateClip->rect.right = this->mode.width;
                                    updateClip->rect.bottom = this->mode.height;
                                    updateClip->isActive = TRUE;
                                }

                                ++clear;
                            }
                            else
                                clear = FALSE;

                            GLClear(GL_COLOR_BUFFER_BIT);
                        }

                        BOOL isDouble = currScale != 1.0f;
                        DWORD frameWidth = isDouble ? DWORD(currScale * this->mode.width) : this->mode.width;
                        DWORD count = frameCount;
                        frame = frames;
                        while (count--)
                        {
                            if (frameCount == 1)
                            {
                                if (glFilter)
                                {
                                    GLTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, glFilter);
                                    GLTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, glFilter);
                                }

                                while (updateClip != finClip)
                                {
                                    if (updateClip->isActive)
                                    {
                                        RECT update = updateClip->rect;
                                        DWORD texWidth = update.right - update.left;
                                        DWORD texHeight = update.bottom - update.top;
                                        if (isDouble)
                                        {
                                            update.left = DWORD(currScale * update.left);
                                            update.top = DWORD(currScale * update.top);
                                            update.right = DWORD(currScale * update.right);
                                            update.bottom = DWORD(currScale * update.bottom);

                                            texWidth = DWORD(currScale * texWidth);
                                            texHeight = DWORD(currScale * texHeight);
                                        }

                                        if (texWidth == frameWidth)
                                        {
                                            if (this->mode.bpp == 32)
                                            {
                                                if (config.gl.caps.bgra)
                                                    GLTexSubImage2D(GL_TEXTURE_2D, 0, 0, update.top, texWidth, texHeight, GL_BGRA_EXT, GL_UNSIGNED_BYTE, (DWORD*)surface->indexBuffer + update.top * texWidth);
                                                else
                                                {
                                                    DWORD* source = (DWORD*)surface->indexBuffer + update.top * texWidth;
                                                    DWORD* dest = (DWORD*)frameBuffer;
                                                    DWORD copyWidth = texWidth;
                                                    DWORD copyHeight = texHeight;
                                                    do
                                                    {
                                                        DWORD* src = source;
                                                        source += frameWidth;

                                                        DWORD count = copyWidth;
                                                        do
                                                            *dest++ = _byteswap_ulong(_rotl(*src++, 8));
                                                        while (--count);
                                                    } while (--copyHeight);

                                                    GLTexSubImage2D(GL_TEXTURE_2D, 0, 0, update.top, texWidth, texHeight, GL_RGBA, GL_UNSIGNED_BYTE, frameBuffer);
                                                }
                                            }
                                            else
                                            {
                                                if (config.gl.version.value > GL_VER_1_1)
                                                    GLTexSubImage2D(GL_TEXTURE_2D, 0, 0, update.top, texWidth, texHeight, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, (WORD*)surface->indexBuffer + update.top * texWidth);
                                                else
                                                {
                                                    WORD* source = (WORD*)surface->indexBuffer + update.top * texWidth;
                                                    DWORD* dest = (DWORD*)frameBuffer;
                                                    DWORD copyWidth = texWidth;
                                                    DWORD copyHeight = texHeight;
                                                    do
                                                    {
                                                        WORD* src = source;
                                                        source += frameWidth;

                                                        DWORD count = copyWidth;
                                                        do
                                                        {
                                                            WORD px = *src++;
                                                            *dest++ = ((px & 0xF800) >> 8) | ((px & 0x07E0) << 5) | ((px & 0x001F) << 19);
                                                        } while (--count);
                                                    } while (--copyHeight);

                                                    GLTexSubImage2D(GL_TEXTURE_2D, 0, 0, update.top, texWidth, texHeight, GL_RGBA, GL_UNSIGNED_BYTE, frameBuffer);
                                                }
                                            }
                                        }
                                        else
                                        {
                                            if (this->mode.bpp == 32)
                                            {
                                                if (config.gl.caps.bgra)
                                                {
                                                    DWORD* source = (DWORD*)surface->indexBuffer + update.top * frameWidth + update.left;
                                                    DWORD* dest = (DWORD*)frameBuffer;
                                                    DWORD copyHeight = texHeight;
                                                    do
                                                    {
                                                        MemoryCopy(dest, source, texWidth << 2);
                                                        source += frameWidth;
                                                        dest += texWidth;
                                                    } while (--copyHeight);

                                                    GLTexSubImage2D(GL_TEXTURE_2D, 0, update.left, update.top, texWidth, texHeight, GL_BGRA_EXT, GL_UNSIGNED_BYTE, frameBuffer);
                                                }
                                                else
                                                {
                                                    DWORD* source = (DWORD*)surface->indexBuffer + update.top * frameWidth + update.left;
                                                    DWORD* dest = (DWORD*)frameBuffer;
                                                    DWORD copyWidth = texWidth;
                                                    DWORD copyHeight = texHeight;
                                                    do
                                                    {
                                                        DWORD* src = source;
                                                        source += frameWidth;

                                                        DWORD count = copyWidth;
                                                        do
                                                            *dest++ = _byteswap_ulong(_rotl(*src++, 8));
                                                        while (--count);
                                                    } while (--copyHeight);

                                                    GLTexSubImage2D(GL_TEXTURE_2D, 0, update.left, update.top, texWidth, texHeight, GL_RGBA, GL_UNSIGNED_BYTE, frameBuffer);
                                                }
                                            }
                                            else
                                            {
                                                if (texWidth & 1)
                                                {
                                                    ++texWidth;
                                                    if (update.left)
                                                        --update.left;
                                                    else
                                                        ++update.right;
                                                }

                                                if (config.gl.version.value > GL_VER_1_1)
                                                {
                                                    WORD* source = (WORD*)surface->indexBuffer + update.top * frameWidth + update.left;
                                                    WORD* dest = (WORD*)frameBuffer;
                                                    DWORD copyHeight = texHeight;
                                                    do
                                                    {
                                                        MemoryCopy(dest, source, texWidth << 1);
                                                        source += frameWidth;
                                                        dest += texWidth;
                                                    } while (--copyHeight);

                                                    GLTexSubImage2D(GL_TEXTURE_2D, 0, update.left, update.top, texWidth, texHeight, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, frameBuffer);
                                                }
                                                else
                                                {
                                                    WORD* source = (WORD*)surface->indexBuffer + update.top * frameWidth + update.left;
                                                    DWORD* dest = (DWORD*)frameBuffer;
                                                    DWORD copyWidth = texWidth;
                                                    DWORD copyHeight = texHeight;
                                                    do
                                                    {
                                                        WORD* src = source;
                                                        source += frameWidth;

                                                        DWORD count = copyWidth;
                                                        do
                                                        {
                                                            WORD px = *src++;
                                                            *dest++ = ((px & 0xF800) >> 8) | ((px & 0x07E0) << 5) | ((px & 0x001F) << 19);
                                                        } while (--count);
                                                    } while (--copyHeight);

                                                    GLTexSubImage2D(GL_TEXTURE_2D, 0, update.left, update.top, texWidth, texHeight, GL_RGBA, GL_UNSIGNED_BYTE, frameBuffer);
                                                }
                                            }
                                        }
                                    }

                                    if (++updateClip == surface->endClip)
                                        updateClip = surface->clipsList;
                                }
                            }
                            else
                            {
                                GLBindTexture(GL_TEXTURE_2D, frame->id);

                                if (glFilter)
                                {
                                    GLTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, glFilter);
                                    GLTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, glFilter);
                                }

                                INT rect_right = frame->rect.x + frame->rect.width;
                                INT rect_bottom = frame->rect.y + frame->rect.height;

                                UpdateRect* update = updateClip;
                                while (update != finClip)
                                {
                                    if (update->isActive)
                                    {
                                        RECT clip = {
                                            frame->rect.x > update->rect.left ? frame->rect.x : update->rect.left,
                                            frame->rect.y > update->rect.top ? frame->rect.y : update->rect.top,
                                            rect_right < update->rect.right ? rect_right : update->rect.right,
                                            rect_bottom < update->rect.bottom ? rect_bottom : update->rect.bottom
                                        };

                                        INT clipWidth = clip.right - clip.left;
                                        INT clipHeight = clip.bottom - clip.top;
                                        if (clipWidth > 0 && clipHeight > 0)
                                        {
                                            if (this->mode.bpp == 32)
                                            {
                                                if (config.gl.caps.bgra)
                                                {
                                                    DWORD* source = (DWORD*)surface->indexBuffer + clip.top * frameWidth + clip.left;
                                                    DWORD* dest = (DWORD*)frameBuffer;
                                                    DWORD copyHeight = clipHeight;
                                                    do
                                                    {
                                                        MemoryCopy(dest, source, clipWidth << 2);
                                                        source += frameWidth;
                                                        dest += clipWidth;
                                                    } while (--copyHeight);

                                                    GLTexSubImage2D(GL_TEXTURE_2D, 0, clip.left - frame->rect.x, clip.top - frame->rect.y, clipWidth, clipHeight, GL_BGRA_EXT, GL_UNSIGNED_BYTE, frameBuffer);
                                                }
                                                else
                                                {
                                                    DWORD* source = (DWORD*)surface->indexBuffer + clip.top * frameWidth + clip.left;
                                                    DWORD* dest = (DWORD*)frameBuffer;
                                                    DWORD copyWidth = clipWidth;
                                                    DWORD copyHeight = clipHeight;
                                                    do
                                                    {
                                                        DWORD* src = source;
                                                        source += frameWidth;

                                                        DWORD count = copyWidth;
                                                        do
                                                            *dest++ = _byteswap_ulong(_rotl(*src++, 8));
                                                        while (--count);
                                                    } while (--copyHeight);

                                                    GLTexSubImage2D(GL_TEXTURE_2D, 0, clip.left - frame->rect.x, clip.top - frame->rect.y, clipWidth, clipHeight, GL_RGBA, GL_UNSIGNED_BYTE, frameBuffer);
                                                }
                                            }
                                            else
                                            {
                                                if (clipWidth & 1)
                                                {
                                                    ++clipWidth;
                                                    if (clip.left != frame->rect.x)
                                                        --clip.left;
                                                    else
                                                        ++clip.right;
                                                }

                                                if (config.gl.version.value > GL_VER_1_1)
                                                {
                                                    WORD* source = (WORD*)surface->indexBuffer + clip.top * frameWidth + clip.left;
                                                    WORD* dest = (WORD*)frameBuffer;
                                                    DWORD copyHeight = clipHeight;
                                                    do
                                                    {
                                                        MemoryCopy(dest, source, clipWidth << 1);
                                                        source += frameWidth;
                                                        dest += clipWidth;
                                                    } while (--copyHeight);

                                                    GLTexSubImage2D(GL_TEXTURE_2D, 0, clip.left - frame->rect.x, clip.top - frame->rect.y, clipWidth, clipHeight, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, frameBuffer);
                                                }
                                                else
                                                {
                                                    WORD* source = (WORD*)surface->indexBuffer + clip.top * frameWidth + clip.left;
                                                    DWORD* dest = (DWORD*)frameBuffer;
                                                    DWORD copyWidth = clipWidth;
                                                    DWORD copyHeight = clipHeight;
                                                    do
                                                    {
                                                        WORD* src = source;
                                                        source += frameWidth;

                                                        DWORD count = copyWidth;
                                                        do
                                                        {
                                                            WORD px = *src++;
                                                            *dest++ = ((px & 0xF800) >> 8) | ((px & 0x07E0) << 5) | ((px & 0x001F) << 19);
                                                        } while (--count);
                                                    } while (--copyHeight);

                                                    GLTexSubImage2D(GL_TEXTURE_2D, 0, clip.left - frame->rect.x, clip.top - frame->rect.y, clipWidth, clipHeight, GL_RGBA, GL_UNSIGNED_BYTE, frameBuffer);
                                                }
                                            }
                                        }
                                    }

                                    if (++update == surface->endClip)
                                        update = surface->clipsList;
                                }
                            }

                            GLBegin(GL_TRIANGLE_FAN);
                            {
                                FLOAT texX = frame->tSize.width * currScale;
                                FLOAT texY = frame->tSize.height * currScale;

                                GLTexCoord2f(0.0f, 0.0f);
                                GLVertex2s((SHORT)frame->point.x, (SHORT)frame->point.y);

                                GLTexCoord2f(texX, 0.0f);
                                GLVertex2s(frame->vSize.width, (SHORT)frame->point.y);

                                GLTexCoord2f(texX, texY);
                                GLVertex2s(frame->vSize.width, frame->vSize.height);

                                GLTexCoord2f(0.0f, texY);
                                GLVertex2s((SHORT)frame->point.x, frame->vSize.height);

                            }
                            GLEnd();
                            ++frame;
                        }

                        if (this->isTakeSnapshot)
                        {
                            this->isTakeSnapshot = FALSE;

                            if (OpenClipboard(NULL))
                            {
                                EmptyClipboard();

                                DWORD texWidth = this->mode.width;
                                DWORD texHeight = this->mode.height;
                                if (isDouble)
                                {
                                    texWidth = DWORD(currScale * texWidth);
                                    texHeight = DWORD(currScale * texHeight);
                                }

                                DWORD dataSize = texWidth * texHeight * sizeof(WORD);
                                HGLOBAL hMemory = GlobalAlloc(GMEM_MOVEABLE, sizeof(BITMAPV5HEADER) + dataSize);
                                {
                                    VOID* data = GlobalLock(hMemory);
                                    {
                                        BITMAPV5HEADER* bmi = (BITMAPV5HEADER*)data;
                                        MemoryZero(bmi, sizeof(BITMAPINFOHEADER));
                                        bmi->bV5Size = sizeof(BITMAPV5HEADER);
                                        bmi->bV5Width = texWidth;
                                        bmi->bV5Height = -*(LONG*)&texHeight;
                                        bmi->bV5Planes = 1;
                                        bmi->bV5BitCount = 16;
                                        bmi->bV5Compression = BI_BITFIELDS;
                                        bmi->bV5XPelsPerMeter = 1;
                                        bmi->bV5YPelsPerMeter = 1;
                                        bmi->bV5RedMask = 0xF800;
                                        bmi->bV5GreenMask = 0x07E0;
                                        bmi->bV5BlueMask = 0x001F;

                                        MemoryCopy((BYTE*)data + sizeof(BITMAPV5HEADER), surface->indexBuffer, dataSize);
                                    }
                                    GlobalUnlock(hMemory);

                                    SetClipboardData(CF_DIBV5, hMemory);
                                }
                                GlobalFree(hMemory);

                                CloseClipboard();
                                clear = TRUE;
                            }
                        }

                        SwapBuffers(this->hDc);
                        if (!clear)
                            WaitForSingleObject(this->hDrawEvent, INFINITE);
                        if (isVSync)
                            GLFinish();
                    }
                } while (!this->isFinish);
            }
        }
        MemoryFree(frameBuffer);

        frame = frames;
        DWORD count = frameCount;
        while (count--)
        {
            GLDeleteTextures(1, &frame->id);
            ++frame;
        }
    }
    MemoryFree(frames);
}

 

@Baratorch, Ок, спасибо посмотрю

--- добавлено 28 окт 2020, предыдущее сообщение размещено: 28 окт 2020 ---

@Baratorch, Попробуй смени местами GLFinish c WaitForSingleObject, в 3-х рендереров, а то-есть:

с

Код:

...
SwapBuffers(this->hDc);
GLFinish();

if (clear >= 2)
    WaitForSingleObject(this->hDrawEvent, INFINITE);
...

на

Код:

...
SwapBuffers(this->hDc);
if (clear >= 2)
    WaitForSingleObject(this->hDrawEvent, INFINITE);
GLFinish();
...

Незнаю почему я это менял местами, но причина должна была бить. В любом случае мне помогло.
glFinish для синхронизации GPU=CPU, а то-есть в нашем случае для вертикальной синхронизации.

Вообще то не советуется оспользование glFinish, но у меня без нее лаги. Раньше я делал проверку чтобы ф-я вызывалась только если включена vSync, но даже без vSync у меня лаги, поэтому теперь всегда glFinish

--- добавлено 28 окт 2020 ---

Кстати если станет лучше - напиши, чтобы я и у себя сменил

 

@Verok, в 1.24 была проблема. Картинка не всегда обновлялась при открытии/закрытии окон в игре (т.е. при отрисовке чего-то на экран). Не отрисовывались окна почти целиком. Особенно это было часто с включенным VSync.
Я эту проблему решил добавлением ((OpenDraw*)this->ddraw)->viewport.refresh = TRUE; в OpenDrawSurface::Blt

Спойлер: Было

Код:

        if (((OpenDraw*)this->ddraw)->attachedSurface == this)
        {
            SetEvent(((OpenDraw*)this->ddraw)->hDrawEvent);
            Sleep(0);
        }

Спойлер: Стало

Код:

        if (((OpenDraw*)this->ddraw)->attachedSurface == this)
        {
            ((OpenDraw*)this->ddraw)->viewport.refresh = TRUE;
            SetEvent(((OpenDraw*)this->ddraw)->hDrawEvent);
            Sleep(0);
        }

Возможно эту проблему ты решал меняя if (isVSync) GLFinish() после WaitForSingleObject(this->hDrawEvent, INFINITE)
на GLFinish() перед WaitForSingleObject(this->hDrawEvent, INFINITE)
??
Я не знаю как на производительность повлияло мое "решение" (Как?). Но если проблема была в этом, то переставлять обратно GLFinish получается нельзя?

Я сейчас, к сожалению, даже со старым кодом не могу повторить ту непрорисовку...

Что если сделать так?

Код:

    GLFinish();

    if (clear >= 2)
        WaitForSingleObject(this->hDrawEvent, INFINITE);
               
    GLFinish();

Или лучше так?

Код:

    GLFlush();

    if (clear >= 2)
        WaitForSingleObject(this->hDrawEvent, INFINITE);
               
    GLFinish();

Все эти варианты (в том числе и без GLFinish/GLFlush перед вэйтом. Убирают исчезновение кнопки при нажатии у меня.

--- добавлено 28 окт 2020, предыдущее сообщение размещено: 28 окт 2020 ---

Такое тоже работает вроде как надо:

Код:

    GLFlush();

    if (clear >= 2)
        WaitForSingleObject(this->hDrawEvent, INFINITE);
              
    GLFlush();

 

@Baratorch,viewport.refresh = TRUE заставляет перечситать вьюпорт. По идее перестраивать viewport не нужно при каждом Blt, но после перестройки сбрасывается переменная clear которая влияет на WaitForSingleObject

Код:

if (clear >= 2)
       WaitForSingleObject(this->hDrawEvent, INFINITE);

Хотя возле этого также SetEvent который как раз прерывает ожидание WaitForSingleObject. Коротче нужно все это обдумывать, так сходу сказать не могу. В любом случае ели критично, можно также сменить INFINITE на число.

glFinish 2 раза не нужно делать, а glFlush вообще не нужен, так как SwapBuffers внутри делает тот же glFlush.
glFlush дает команду GPU на рисование, glFinish то же самое, только ждет окончания. glFinish после SwapBuffer фактично просто синхронизирует, но ничего не ждет, так как буфер (очередь команд) еще пуст и нечего рисовать. Вот в этой статье можно прочитать (последний пункт GPU vs CPU synchronization)

Все это нужно тыкать эксперементальным методом. Для одних GPU может быть так лучше, а для других по иному

 

Доброе время суток, подскажите пожалуйста. GL-Wrapper версии 1.48 для HoMM1 не воспроизводит CD-треки из локальной папки на HDD. Путь к папке в реестре указан верно, однако в главном меню и в самой игре тишина. В каком направлении копать?

 

@Eli Springer, Версия от Буки, или какая-то иная?

 

Бука