197-577-902| Домой | Софт | Мастерская | Лирика | ЧаВО | Юмор | 197-577-902 |
Данный документ представляет собой перевод статьи Джеймса Брауна "Flicker-Free Drawing in Windows"
Мелькание при рисовании в окне - следствие неряшливого программирования и невнимания к деталям. Не существует весомой причины, из-за которой хоть одна Windows программа должна выводить изображение с мерцанием. Цель этой статьи - ознакомить читателя с методами, позволяющими избежать мерцания при выводе графики в своих приложениях.
Мерцание это просто-напросто, когда поверх одного видимого на экране изображения сразу же рисуется другое. Т.е. вы видите на экране какое-то изображение очень короткое время, после чего оно заменяется другим. Когда я сталкиваюсь с приложением, которое выводит графику с мерцанием, причиной которого всегда является лишь плохое кодирование пользовательского интерфейса, я задаю себе вопрос: "Если в приложении так плохо реализована работа с графикой, то, как хорошо оно тогда решает задачу, для которой оно предназначено?"
Мерцания возникают при разных обстоятельствах. В основном оно происходит при изменении размеров окна, т.к. при этом окно перерисовывает свое содержимое.
Это золотое правило для любых операций рисования на компьютере, независимо от операционной системы которую вы используете. Вы никогда не должны рисовать в одном и томже пикселе дважды. Однако программисты часто вместо оптимизации процесса рисования выбирают самый легкий путь.
Ваша обязанность обеспечить отсутствие перерисовки одних и тех же областей экрана более одного раза. Windows и ваш компьютер в основе своей туп, они не будут ничего делать, пока вы не дадите им точные инструкции к действию. Таким образом, если вы заметили мерцание, то это потому что ваша программа перерисовывает некоторую область несколько раз.
Первым под подозрение обычно попадает сообщение WM_ERASEBKGND. Это сообщение посылается окну, когда оно нуждается в очистке своего фона (background). Мерцание происходит потому, что окна, обычно, рисуются в две стадии:
- WM_ERASEBKGND: Очистка фона окна
- WM_PAINT: Рисование содержимого поверх фона
Это облегчает рисование содержимого окна: так как каждый раз когда вы получаете сообщение WM_PAINT вы знаете что вам предоставлено абсолютно чистое полотно (канва), и вам остается только нарисовать содержимое (текст, картинка и т.п.). Однако, из-за рисования в окне дважды (сначала в WM_ERASEBKGND, а потом еще раз в WM_PAINT) возникает очень сильное мерцание. Для примера, просто посмотрите на стандартный элемент Edit в Windows - запустите notepad.exe, наберите какой-нибудь текст и измените размер окна. Вы увидите, как при этом будет мерцать содержимое окна.
Так как же избежать очистки канвы окна? Есть два способа:
- Выбрать в качестве кисти фона окна - пустую кисть (NULL / 0). (присвоить полю hbrBackground структуры WNDCLASS ноль при регистрации класса окна.
- Возвращать ненулевое значение в обработчике сообщения WM_ERASEBKGND.
Оба этих метода не позволят сообщению WM_ERASEBKGND очищать канву окна. Второй способ обычно легче в реализации.
case WM_ERASEBKGND: Result:= 1;Также можно запретить посылку сообщения WM_ERASEBKGND, когда вы обновляете окно или объявляете его недействительным. Функция InvalidateRect последним параметром запрашивает должно ли окно очистить канву при следующей перерисовке. Указав в качестве этого параметра FALSE вы запретите посылку сообщения WM_ERASEBKGND перед перерисовкой окна.
InvalidateRect(hwnd, &rect, FALSE);
Перерисовка всего содержимого окна, даже если в нем изменилась лишь малая часть (например, при изменении размеров окна) - обычное дело для многих Windows приложений. Однако обычно в такой перерисовке нет необходимости. Когда размеры окна изменяются, предыдущее изображение сохраняется и лишь небольшая часть окна требует перерисовки (при увеличении размеров). Таким образом, алгоритм рисования можно реализовать так, чтобы он рисовал лишь необходимый минимум.С каждым окном в системе связана область обновления (update region). Она описывает область окна, которая стала невалидной и требует перерисовки. Если окно будет перерисовывать только эту область и ничего более, то значительно увеличится скорость прорисовки окна.
Существует несколько способов получения информации об области обновления окна. Функция GetUpdateRgn возвращает точную информацию об области обновления, будь то прямоугольник, или более сложная фигура. В отличие от нее, функция GetUpdateRect возвращает информацию не о самой области обновления, а о наименьшем прямоугольнике, который целиком содержит в себе область обновления. Естественно, что работать с прямоугольной областью гораздо легче. Третий же способ заключается в использовании структуры PAINTSTRUCT совместно с функциями BeginPaint/EndPaint.
Обычно, процедура рисования выглядит так:
PAINTSTRUCT ps; HDC hdc; case WM_PAINT: hdc = BeginPaint(hwnd, &ps); // do painting EndPaint(hwnd, &ps); return 0;Функция BeginPaint заполняет структуру ps (PAINTSTRUCT). Одно из полей структуры - rcPaint является структурой типа RECT, которое описывает наименьший прямоугольник, содержащий в себе область обновления (т.е. тот же самый, что вернула бы нам функция GetUpdateRect). Одним лишь ограничением рисования только в этом прямоугольнике, мы значительно увеличим скорость прорисовки окна.
Следует помнить, что Windows автоматически обрезает любое рисование вне области обновления, когда вы используете функции BeginPaint/EndPaint. Это значит, что вы не сможете что-нибудь нарисовать вне области обновления. Вы можете подумать, в чем же тогда смысл ограничения рисования лишь в области обновления, если все равно ничего лишнего нарисовано не будет. Однако не забывайте, что вы вызываете функции и вычисления - в холостую, которые занимают какое-то время, а результата от них - ноль.
Возможна ситуация, когда вы потратите кучу времени на оптимизацию процесса рисования окна, однако выяснится, что окно все равно перерисовывается полностью. Обычно это происходит из-за двух стилей класса окна: CS_VREDRAW и СS_HREDRAW. Когда класс окна имеет установленным, хотя бы из этих стилей, содержимое окна будет полностью перерисовываться при изменении его размеров по вертикали или по горизонтали соответственно.
Одним из решений проблемы является отключение этих двух стилей.
WNDCLASSEX wc; wc.cbSize = sizeof(wc); wc.style = 0; // CS_VREDRAW | CS_HREDRAW; ... RegisterClassEx(&wc);Замечание: если главное окно приложения имеет эти стили, то независимо от того имеют ли их дочерние окна, они будут полностью перерисовываться во время изменения размеров главного окна.
Далее рассматривается другое решение этой проблемы (более правильное, на мой взгляд - зам. переводчика).
Мерцание может возникать из-за того, что родительское окно не вырезает области, занимаемые дочерними окнами из своей области обновления. Поэтому, при рисовании своего содержимого, родительское окно затирает дочерние окна своим изображением, а затем поверх него рисуются сами дочерние окна. Эта проблема легко решается установкой родительскому окну стиля WS_CLIPCHILDREN.
Когда окну установлен этот стиль, все области, занимаемые дочерними окнами, автоматически вырезаются из области обновления. А как говорилось ранее, при использовании BeginPaint, рисование вне области обновления не дает никакого результата, поэтому дочерние окна не затираются, и мерцания не происходит.
Основной метод борьбы с мерцанием - так называемая двойная буферизация. Идея метода заключается в том, что сначала вы рисуете окно в не экрана, в памяти, а затем, выводите полностью готовое изображение окна на экран, используя, например, BitBlt. Это очень эффективное оружие против мерцания, но часто, им злоупотребляют, особенно программисты, которые не знают, как эффективно пользоваться графическими средствами Windows.
Простейший способ двойной буферизации выглядит примерно так:
HDC hdcMem; HBITMAP hbmMem; HANDLE hOld; PAINTSTRUCT ps; HDC hdc; .... case WM_PAINT: // Получаем DC для окна hdc = BeginPaint(hwnd, &ps); // Создаем off-screen DC для двойной буферизации hdcMem = CreateCompatibleDC(hdc); hbmMem = CreateCompatibleBitmap(hdc, win_width, win_height); hOld = SelectObject(hdcMem, hbmMem); // Здесь рисуем в hdcMem // Выводим построенное изображение и памяти на экран BitBlt(hdc, 0, 0, win_width, win_height, hdcMem, 0, 0, SRCCOPY); // Освобождаем память SelectObject(hdcMem, hOld); DeleteObject(hbmMem); DeleteDC (hdcMem); EndPaint(hwnd, &ps); return 0;Этот пример довольно медленный, потому что внеэкранный буфер создается / уничтожается каждый раз при обработке сообщения WM_PAINT. Для увеличения производительности, память под буфер можно выделять при обработке сообщения WM_SIZE, а удалять его при уничтожении окна. Потенциально, оба этих метода могут быть очень требовательны к памяти. Например, если окно будет развернуто на весь экран, то, при разрешении экрана 1024x768x32, для буфера потребуется 2,5 Мб памяти.
Кроме того, метод двойной буферизации медленней, чем обычное рисование сразу на экран. Т.к. сначала мы рисует в памяти, а затем еще раз рисуем созданный образ, но, уже на экране. Конечно, современные видио-карты сделают это быстро, однако факт остается фактом - прямое рисование на экране было бы быстрей.
Если вашему приложению требуется отображать очень сложную информацию / графику (например, веб-страничку), тогда вы должны использовать двойную буферизацию. Так, например, поступает Internet Explorer. Не существует другого способа вывести содержимое веб-странички или другой сложной графики на экран без мерцания.
Не обязательно использовать двойную буферизацию для рисования всего окна. Представьте, что у вас в окне лишь в малой части окна имеется сложный графический объект. Вы можете рисовать лишь этот объект при помощи двойной буферизации, тогда как остальную часть окна рисовать как обычно.
Часто, после небольшого и аккуратного продумывания процесса рисования, можно вообще не использовать двойную буферизацию и рисовать прямо на экран, при этом, не нарушая золотого правила "никогда не рисуй в одном пикселе дважды".
Что я под этим подразумеваю? Допустим, вы хотите изменить вид заголовка вашего окна, добавив в него дополнительную графику: картинку, кнопку и т.п. Для этого, вы будете рисовать свое изображение поверх уже нарисованного заголовка - возникает мерцание. Это происходит из-за того, что нарушено золотое правило.
Существует две техники устранения такого типа мерцания. Первая заключается в использовании clipping, а вторая - в использовании смекалки.
Рассмотрим первую технику. Используя функцию ExcludeClipRect, вы можете замаскировать некоторые области. Когда область замаскирована, игнорируются все попытки что-либо нарисовать в ней. После того, как фон будет нарисован, вы можете снять маскировку с этих областей, используя функцию SelectClipRgn, и нарисовать в них то, что вам нужно.
Теперь о второй технике. Представим, что нам нужно нарисовать в окне сетку. Самый очевидный способ - нарисовать серию вертикальных и горизонтальных линий поверх фона окна. Сетка будет нарисована, но проблема заключается в том, что сетка будет мерцать, потому что сначала будет рисовать фон окна, а уже только после этого поверх фона будет нарисована сама сетка. Т.е. снова нарушено золотое правило.
А теперь, немного подумаем. Нарисовать сетку можно и другим способом. Вместо рисования одноцветного фона, можно рисовать серию квадратиков разделенных между собой линией.
А если подумать еще, то можно вспомнить, что мы может создать и использовать свою кисть для закраски фона окна (WNDCLASSEX.hbrBackground). Кисть должна выглядеть следующим образом:
Т.е. кисть должна быть прямоугольником, левая и верхняя (можно и другие) стороны которого - цвет сетки, а остальная часть - цвет фона окна. При этом нам достаточно будет выбрать такую кисть в качестве кисти для фона, и сетка будет рисоваться сама.
Надеюсь, теперь вы никогда не зададите вопрос: "Почему мое окно мерцает?". Я описал основные причины мерцания, а также методы избавления от него. И если вы в будущем столкнетесь с ним, вы сможете установить причину и окончательно избавиться от него.
| Слава Антонов © 2002 — August 13, 2008 |
|
