Программа Switch

Программа Switch — полноэкранное приложение DirectDraw, которое выводит меню всех поддерживаемых видеорежимов и позволяет активизировать любой из них. На рис. 4.1 показано, как она выглядит.

Рис. 4.1. Программа Switch

Эта программа представляет собой модифицированное полноэкранное приложение, сгенерированное DirectDraw AppWizard. В программу было добавлено меню, позволяющее выбрать видеорежим (с помощью клавиш со стрелками) и активизировать его (клавишей Enter). Клавиша Esc завершает работу программы. Программа Switch также вычисляет и отображает FPS приложения (количество кадров в секунду).

В программе Switch мы научимся:

• переключать видеорежимы;
• выводить текст на поверхностях DirectDraw;
• рассчитывать FPS приложения;
• работать с цветовыми ключами.

Структура приложения

Программа Switch, как и все остальные программы в этой книге, была создана с помощью DirectDraw AppWizard, так что ее структура покажется вам знакомой, если вы прочитали главу 3. Реализация программы основана на двух классах, SwitchWin и SwitchApp, производных от классов DirectDrawWin и DirectDrawApp соответственно. Класс SwitchApp остался в том виде, в котором он был сгенерирован AppWizard, и потому дальнейшему обсуждению не подлежит.

Класс SwitchWin создает три поверхности: одна используется для перемещения растрового изображения на экране, вторая реализует меню видеорежимов, а третья — вывод FPS. Но перед тем, как рассматривать код программы, давайте поговорим о том, как вывести на поверхность текст и как рассчитать FPS приложения.

Вывод текста

Самый простой способ вывести текст на поверхность — получить у Windows контекст устройства (DC) с помощью функции GetDC() интерфейса DirectDrawSurface. После этого можно вывести текст на поверхность стандартными функциями TextOut() и TextOutExt() и освободить DC функцией DirectDrawSurface::ReleaseDC(). Атрибуты текста (цвет, фон и способ вывода) выбираются следующими функциями Win32:

• SelectObject()
• SetBkMode()
• SetBkColor()
• SetTextColor()

Мы воспользуемся этими функциями в программе Switch для вывода меню видеорежимов и значения FPS.

Вычисление FPS

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

Чтобы вычислить FPS во время работы приложения, необходимо производить периодические измерения. К сожалению, скорость работы приложения может изменяться в зависимости от сложности графического вывода и объема внутренних вычислений. Кроме того, Windows замедляет работу приложения при передаче части процессорного времени другим приложениям или при переносе содержимого памяти на диск. В момент запуска приложение обычно работает медленнее, потому что Windows начинает сбрасывать данные на диск. Только после того, как Windows «успокоится» и перестанет работать с диском, можно будет получить достоверные значения FPS.

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

Для хронометража используется функция Win32 timeGetTime(), которая возвращает количество миллисекунд, прошедших с момента запуска Windows. В программе Switch функция timeGetTime() вызывается после каждых 100 кадров; значение FPS равно 100, разделенному на количество прошедших секунд.

Функция timeGetTime() не обеспечивает максимальной точности измерений, которую можно получить в Windows (для более точного хронометража можно воспользоваться функцией QueryPerformanceCounter()). Если бы мы отслеживали очень короткие периоды времени (например, интервалы по 10 миллисекунд), то функция timeGetTime() не давала бы приемлемых результатов, но поскольку таймер используется не чаще одного раза в секунду, подходит и timeGetTime().

Класс SwitchWin

Давайте рассмотрим код программы Switch. Начнем с определения класса SwitchWin (см. листинг 4.2).

class SwitchWin : public DirectDrawWin
{
    public:
        SwitchWin();
    protected:
        //{{AFX_MSG(SwitchWin)
        afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
        //}}AFX_MSG
        DECLARE_MESSAGE_MAP()
    private:
        int SelectDriver();
        int SelectInitialDisplayMode();
        BOOL CreateCustomSurfaces();
        void DrawScene();
        void RestoreSurfaces();

        BOOL CreateMenuSurface();
        BOOL UpdateMenuSurface();
        BOOL CreateFPSSurface();
        BOOL UpdateFPSSurface();
    private:
        LPDIRECTDRAWSURFACE bmpsurf;
        int x, y;
        int xinc, yinc;

        LPDIRECTDRAWSURFACE menusurf;
        int selectmode;

        LPDIRECTDRAWSURFACE fpssurf;
        RECT fpsrect;
        BOOL displayfps;
        DWORD framecount;

        HFONT smallfont, largefont;
};

Класс SwitchWin содержит всего одну открытую (public) функцию — конструктор класса (вскоре мы его рассмотрим). В классе также присутствует функция OnKeyDown() — обработчик сообщений, созданный ClassWizard (закомментированные директивы AFX, окружающие функцию OnKeyDown(), используются ClassWizard для поиска функций-обработчиков). Мы воспользуемся этой функцией для обработки нажимаемых клавиш — стрелок, Enter и незаменимой клавиши Esc.

Следующие пять функций являются переопределенными версиями функций DirectDrawWin:

• SelectDriver()
• SelectInitialDisplayMode()
• CreateCustomSurfaces()
• DrawScene()
• RestoreSurfaces()

С помощью функции SelectDriver() приложение выбирает используемое видеоустройство (если их несколько). Она полностью совпадает со стандартной версией, создаваемой AppWizard, и выводит меню при наличии нескольких драйверов. Функция SelectInitialDisplayMode() задает исходный видеорежим, устанавливаемый приложением. Здесь снова используется стандартная версия AppWizard, которая ищет видеорежим с параметрами 640x480x16.

Функция CreateCustomSurfaces() вызывается DirectDrawWin при активизации нового видеорежима; мы воспользуемся этой функцией для создания и подготовки поверхностей программы Switch. Функция DrawScene() отвечает за обновление экрана; она будет использоваться для отображения анимации, меню видеорежимов и значения FPS. Наконец, функция RestoreSurfaces() вызывается классом DirectDrawWin при необходимости восстановить потерянные поверхности. Эта функция восстанавливает не только сами поверхности, но и (для особо важных поверхностей) их содержимое.

Затем класс SwitchWin объявляет четыре функции, специфические для программы Switch:

• CreateMenuSurface()
• UpdateMenuSurface()
• CreateFPSSurface()
• UpdateFPSSurface()

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

Закрытые переменные, объявленные в конце, предназначены для отображения анимации, меню видеорежимов и FPS, а также для работы со шрифтами средствами Win32.

Переменная bmpsurf — указатель на интерфейс DirectDrawSurface, через который мы будем обращаться к данным перемещаемого растра, а переменные x, y, xinc и yinc определяют его положение.

Указатель menusurf используется для доступа к поверхности меню видеорежимов, а в целой переменной selectmode хранится индекс текущего активного видеорежима.

Следующие переменные списка связаны с выводом значения FPS. Переменная fpssurf — указатель на интерфейс DirectDrawSurface, через который производится доступ к поверхности FPS. Структура типа RECT (fpsrect) содержит размеры поверхности fpssurf. Логическая переменная displayfps управляет отображением значения FPS, а в переменной framecount хранится количество кадров, выведенных в очередном временном интервале измерения FPS.

Две последние переменные, smallfont и largefont, имеют тип HFONT. Это логические номера шрифтов Win32, используемые для вывода текста на поверхностях menusurf и fpssurf.

Инициализация приложения

Наше знакомство с программой Switch начинается с конструктора SwitchWin, внутри которого происходит первоначальная инициализация переменных класса. Не следует путать эту инициализацию с той, что выполняется функцией CreateCustomSurfaces(), потому что в отличие от конструктора CreateCustomSurfaces() вызывается при каждой смене видеорежима. Конструктор выглядит так:

SwitchWin::SwitchWin()
{
    bmpsurf = 0;
    x = y = 0;
    xinc = 8;
    yinc = 1;
    menusurf = 0;
    fpssurf = 0;

    largefont = CreateFont(28, 0, 0, 0,
                       FW_NORMAL, FALSE, FALSE, FALSE,
                       ANSI_CHARSET,
                       OUT_DEFAULT_PRECIS,
                       CLIP_DEFAULT_PRECIS,
                       DEFAULT_QUALITY,
                       VARIABLE_PITCH,
                       "Arial");

    smallfont = CreateFont(14, 0, 0, 0,
                       FW_NORMAL, FALSE, FALSE, FALSE,
                       ANSI_CHARSET,
                       OUT_DEFAULT_PRECIS,
                       CLIP_DEFAULT_PRECIS,
                       DEFAULT_QUALITY,
                       VARIABLE_PITCH,
                       "Arial");
}

В основном конструктор просто обнуляет переменные. Два логических номера шрифтов инициализируются функцией Win32 CreateFont(). В программе используются два разных размера одного и того же шрифта: крупным шрифтом выводится заголовок на поверхности меню видеорежимов, а мелким — описания видеорежимов и текст со значением FPS.

После того как объект SwitchWin будет создан, DirectDrawWin вызывает функции SelectDriver() и SelectInitialDisplayMode(). Поскольку в программе Switch обе функции ведут себя стандартным образом (как описано в главе 3), мы не будем их рассматривать.

Затем класс DirectDrawWin вызывает функцию SwitchWin::CreateCustomSurfaces(), в которой подготавливает три поверхности, используемые программой Switch:

BOOL SwitchWin::CreateCustomSurfaces()
{
    int displaydepth = GetCurDisplayDepth();
    CString filename;
    if (displaydepth == 8)
        filename="tri08.bmp";
    else
        filename="tri24.bmp";

    bmpsurf = CreateSurface(filename, TRUE);
    if (bmpsurf == 0)
    {
        TRACE("surface creation failed\n");
        return FALSE;
    }

    selectmode = GetCurDisplayMode();
    CreateMenuSurface();
    UpdateMenuSurface();

    CreateFPSSurface();

    return TRUE;
}

Содержимое одной из этих трех поверхностей определяется BMP-файлом. Функция CreateCustomSurfaces() по текущей глубине пикселей определяет, какой из двух BMP-файлов нужно использовать. Затем указатель на поверхность (bmpsurf) инициализируется функцией DirectDrawWin::CreateSurface(). В случае 8-битного видеорежима содержимое палитры DirectDraw определяется палитрой из BMP-файла.

Затем происходит инициализация самой поверхности и переменных, связанных с видеорежимом. Переменной selectmode присваивается значение, зависящее от текущего видеорежима. Это значение используется для выделения активного видеорежима в меню. Указатель на поверхность меню видеорежимов (menusurf) инициализируется вызовами функций CreateMenuSurface() и UpdateMenuSurface().

Наконец, переменные поверхности FPS инициализируются функцией CreateFPSSurface(). Мы рассмотрим ее позднее, после функций CreateMenuSurface() и UpdateMenuSurface().

Функция CreateMenuSurface() выглядит так:

BOOL SwitchWin::CreateMenuSurface()
{
    if (menusurf)
        menusurf->Release(), menusurf = 0;

    menusurf = CreateSurface(menuwidth, menuheight);
    if (menusurf == 0)
    Fatal("SwitchWin::CreateMenuSurface() failed\n");

    DDCOLORKEY ddck;
    ddck.dwColorSpaceLowValue = 0;
    ddck.dwColorSpaceHighValue = 0;
    menusurf->SetColorKey(DDCKEY_SRCBLT, &ddck);

    return TRUE;
}

Прежде всего CreateMenuSurface() освобождает любые поверхности, созданные ранее. Новая поверхность создается функцией CreateSurface(). Доступ к ней осуществляется через переменную menusurf. Затем мы назначаем новой поверхности цветовой ключ с помощью структуры DDCOLORKEY и функции SetColorKey() интерфейса DirectDrawSurface.

Если вы не знаете, для чего нужны цветовые ключи, попробуйте запустить программу Switch и понаблюдать за поведением меню видеорежимов. Обратите внимание — когда перемещающийся растр оказывается в верхней части экрана, он проходит как бы позади меню, но при этом остается видимым. Текст меню непрозрачен, однако те части меню, в которых текста нет, прозрачны. Дело в том, что пиксели пустых участков меню не выводятся DirectDraw и потому не заслоняют растр. Цветовой ключ определяет, какие именно пиксели поверхности не будут выводиться.

Мы назначаем цветовой ключ поверхности меню с помощью структуры DDCOLORKEY и функции SetColorKey(). Оба поля DDCOLORKEY обнуляются (некоторые видеокарты позволяют задавать интервалы цветовых ключей, но в нашем случае используется всего один цвет). Это означает, что пиксели поверхности, равные нулю, не будут копироваться при блит-операциях с активным цветовым ключом.

После того как поверхность меню будет создана функцией CreateMenuSurface(), она заполняется с помощью функции UpdateMenuSurface(). Внутри последней для вывода текста на поверхность используются функция GetDC() интерфейса DirectDrawSurface и текстовые функции Win32. Функция UpdateMenuSurface() приведена в листинге 4.3.

BOOL SwitchWin::UpdateMenuSurface()
{
    char buf[40];
    int len;
    int hdrlen = strlen(headertext);

    ClearSurface(menusurf, 0);

    HDC hdc;
    menusurf->GetDC(&hdc);
    SelectObject(hdc, largefont);

    SetBkMode(hdc, TRANSPARENT);

    SetTextColor(hdc, textshadow);
    TextOut(hdc, 1, 1, headertext, hdrlen);

    SetTextColor(hdc, textcolor);
    TextOut(hdc, 0, 0, headertext, hdrlen);

    SelectObject(hdc, smallfont);

    int nmodes = GetNumDisplayModes();
    if (nmodes > maxmodes)
        nmodes = maxmodes;

    int rows = nmodes / menucols;
    if (nmodes % menucols)
        rows++;
    for (int i = 0; i < nmodes; i++)
    {
        int x = (i / rows) * colwidth + 2;
        int y = (i % rows) * rowheight + reservedspace;

        DWORD w,h,d;
        GetDisplayModeDimensions(i, w, h, d);

        len = sprintf(buf, "%dx%dx%d", w, h, d);

        SetTextColor(hdc, textshadow);
        TextOut(hdc, x+1, y+1, buf, len);

        if (i == selectmode)
            SetTextColor(hdc, brighttextcolor);
        else
            SetTextColor(hdc, textcolor);
        TextOut( hdc, x, y, buf, len );
    }

    len = sprintf(buf, "[Arrows] [Enter] [Escape]");
    SetTextColor(hdc, textshadow);
    TextOut(hdc, 3, 186, buf, len);
    SetTextColor(hdc, textcolor);
    TextOut(hdc, 2, 185, buf, len);

    menusurf->ReleaseDC(hdc);

    return TRUE;
}

Функция UpdateMenuSurface() вызывает ClearSurface() и передает ей в качестве аргументов указатель menusurf и 0. В результате все пиксели поверхности обнуляются. Так как ноль является цветовым ключом для данной поверхности, вся поверхность становится прозрачной.

Теперь все готово к выводу текста. Обратите внимание на функцию SetBkMode(), которая указывает, что текст должен выводиться в прозрачном режиме. Это значит, что функция TextOut() будет выводить только сам текст, без фона, благодаря чему наш прозрачный фон останется в неприкосновенности. Цвет текста задается функцией Win32 SetTextColor(). В этой программе используются три цвета: первый — для обычного текста, второй — для затененного текста, и третий — для текста, выделенного подсветкой. Каждая текстовая строка выводится дважды — сначала затемненным, а потом обычным цветом; затененный текст смещен на один пиксель по отношению к обычному. После завершения вывода текста вызывается функция ReleaseDC() интерфейса DirectDrawSurface.

Инициализация приложения завершается вызовом функции CreateFPSSurface(), которая создает поверхность для вывода FPS. Она выглядит так:

BOOL SwitchWin::CreateFPSSurface()
{
    static const char dummystr[] = "000 FPS";
    HDC hdc = ::GetDC(0);
    SelectObject(hdc, smallfont);
    SIZE size;
    GetTextExtentPoint(hdc, dummystr, strlen(dummystr), &size);
    ::ReleaseDC(0, hdc);

    fpsrect.left = 0;
    fpsrect.top = 0;
    fpsrect.right = size.cx + 1;
    fpsrect.bottom = size.cy + 1;

    fpssurf = CreateSurface(fpsrect.right, fpsrect.bottom);

    DDCOLORKEY ddck;
    ddck.dwColorSpaceLowValue = 0;
    ddck.dwColorSpaceHighValue = 0;
    fpssurf->SetColorKey(DDCKEY_SRCBLT, &ddck);

    framecount = 0;
    displayfps = FALSE;

    return TRUE;
}

Работа CreateFPSSurface() начинается с определения размера поверхности функцией GetTextExtentPoint(). Фиктивная строка (с текстом, который занимает максимальную возможную площадь) передается в качестве аргумента функции GetTextExtentPoint(), вычисляющей размеры области (в пикселях) для вывода заданного текста. По размерам, полученным от GetTextExtentPoint(), мы определяем размеры поверхности, добавляя один пиксель для смещения тени. Такой подход отличается от использованного в функции CreateMenuSurface(), потому что этот код автоматически регулирует размеры поверхности при изменении размера шрифта. Поверхность меню, напротив, обладает фиксированными размерами, не зависящими от размера шрифта.

По аналогии с menusurf мы обеспечиваем прозрачность, назначая поверхности нулевой цветовой ключ (с помощью функции SetColorKey() интерфейса DirectDrawSurface). Наконец, переменная framecount (предназначенная для подсчета кадров за текущий интервал хронометража) обнуляется, а логической переменной displayfps присваивается значение FALSE, согласно которому поверхность FPS пока не должна отображаться на экране.

Хотя мы создали поверхность fpssurf, она осталась неинициализированной. В отличие от поверхности menusurf, инициализируемой функцией UpdateMenuSurface(), мы пока не можем инициализировать поверхность FPS, потому что у нас еще нет выводимого значения. Приложение только что было запущено (или только что перешло в другой видеорежим), так что вывод любого значения FPS был бы необоснованным.

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

Графический вывод

Графическим выводом в программе Switch занимается функция SwitchWin::DrawScene(). Она отвечает за подготовку кадра во вторичном буфере и переключение страниц, благодаря которому новый кадр отображается на экране. Код функции DrawScene() содержится в листинге 4.4.

void SwitchWin::DrawScene()
{
    ClearSurface(backsurf, 0);

    BltSurface(backsurf, bmpsurf, x, y);

    x += xinc;
    y += yinc;

    const CRect& displayrect = GetDisplayRect();
    if (x < -160 || x > displayrect.right - 160)
    {
        xinc = -xinc;
        x += xinc;
    }
    if (y < -100 || y > displayrect.bottom - 100)
    {
        yinc = -yinc;
        y += yinc;
    }

    backsurf->BltFast(0, 0, menusurf, 0, 
                 DDBLTFAST_SRCCOLORKEY | DDBLTFAST_WAIT);

    UpdateFPSSurface();
    if (displayfps)
    {
        int x = displayrect.right - fpsrect.right - 1;
        int y = displayrect.bottom - fpsrect.bottom - 1;
        backsurf->BltFast(x, y, fpssurf, 0,
                 DDBLTFAST_SRCCOLORKEY | DDBLTFAST_WAIT);
    }

    primsurf->Flip(0, DDFLIP_WAIT);
}

Сначала функция DrawScene() подготавливает вторичный буфер, стирая его содержимое функцией ClearSurface(). Мы заполняем вторичный буфер нулями, но, поскольку он не имеет цветового ключа, 0 в данном случае имеет иной смысл, чем для поверхностей menusurf и fpssurf. Для вторичных буферов 0 означает черный цвет (в большинстве случаев).

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

Затем копируется поверхность меню. Она всегда выводится в левом верхнем углу экрана, а ее размеры совпадают с размерами видеорежима с наименьшим разрешением (320x200), так что отсечение не понадобится. Следовательно, мы можем воспользоваться функцией BltFast() интерфейса DirectDrawSurface. Первые два аргумента BltFast() определяют область приемника для наложения копии (оба аргумента равны нулю, что означает левый верхний угол). Третий аргумент является указателем на поверхность-источник, а четвертый описывает копируемую прямоугольную область источника. Вместо прямоугольника мы передаем 0, тем самым показывая, что копироваться должна вся поверхность.

В последний аргумент функции BltFast() включены флаги DDBLTFAST_SRCCOLORKEY и DDBLTFAST_WAIT. Первый флаг активизирует цветовой ключ поверхности-источника. Если бы он не был указан, то во время блиттинга цветовой ключ поверхности menusurf был бы проигнорирован, а пиксели с нулевыми значениями выводились бы черным цветом. Второй флаг показывает, что выход из функции BltFast() должен произойти лишь после завершения копирования.

Вернемся к функции DrawScene(). Наша следующая задача — обновление и отображение поверхности FPS (fpssurf). Однако, как было сказано выше, поверхность fpssurf обновляется лишь после того, как закончится очередной интервал хронометража.

Вычисление FPS и подготовка поверхности осуществляются функцией UpdateFPSSurface(), вызываемой функцией DrawScene() при каждом обновлении экрана. Функция UpdateFPSSurface() выглядит так:

BOOL SwitchWin::UpdateFPSSurface()
{
    static const long interval = 100;
    framecount++;

    if (framecount == interval)
    {
        static DWORD timenow;
        static DWORD timethen;
        timethen = timenow;
        timenow = timeGetTime();

        double seconds = (double)(timenow - timethen)/(double)1000;
        int fps = (int)((double)framecount / seconds);

        static char buf[10];
        int len = sprintf(buf, "%d FPS", fps);

        ClearSurface(fpssurf, 0);

        HDC hdc;
        fpssurf->GetDC(&hdc);

        SelectObject(hdc, smallfont);
        SetBkMode(hdc, TRANSPARENT);
        SetBkColor(hdc, RGB(0,0,0));

        SetTextColor(hdc, textshadow);
        TextOut(hdc, 1, 1, buf, len);
        SetTextColor(hdc, brighttextcolor);
        TextOut(hdc, 0, 0, buf, len);

        fpssurf->ReleaseDC(hdc);

        displayfps = TRUE;
        framecount = 0;
    }

    return TRUE;
}

Функция UpdateFPSSurface() использует переменную framecount для подсчета выведенных кадров. Переменная framecount обнуляется в двух случаях: при изменении видеорежима и при обновлении поверхности fpssurf заново вычисленным значением FPS.

Каждый раз, когда заданное количество кадров будет подготовлено и выведено на экран, функция timeGetTime() подсчитывает количество прошедших миллисекунд. По этой величине определяется текущий FPS приложения.

Значение FPS преобразуется в строку и выводится на поверхность FPS (после предварительной очистки поверхности функцией ClearSurface()). После вывода текста переменная framecount обнуляется, и начинается новый интервал хронометража. Наконец, переменной displayfps присваивается значение TRUE; оно говорит о том, что на поверхности FPS находится допустимое значение, которое следует вывести на экран.

Возвращаясь к функции DrawScene() (см. листинг 4.4), мы видим, что код отображения fpssurf и переключения страниц выглядит так:

if (displayfps)
{
    int x = displayrect.right - fpsrect.right - 1;
    int y = displayrect.bottom - fpsrect.bottom - 1;
    backsurf->BltFast(x, y, fpssurf, 0,
             DDBLTFAST_SRCCOLORKEY | DDBLTFAST_WAIT);
}
primsurf->Flip(0, DDFLIP_WAIT);

Если флаг displayfps равен TRUE, поверхность FPS следует вывести на экран. Однако сначала мы рассчитываем ее положение по известным размерам видеорежима и поверхности. Затем мы копируем поверхность fpssurf функцией BltFast(), после чего выводим на экран вторичный буфер функцией Flip() интерфейса DirectDrawSurface.

Задача функции DrawScene() выполнена — все три поверхности программы Switch выведены на экран. Тем не менее изучение приложения еще не закончено. Мы должны рассмотреть обработку пользовательского ввода.

Но перед тем как продолжить, я должен сделать одно замечание относительно программы Switch. Как мы видели во время рассмотрения ее кода, две из трех поверхностей программы имеют цветовые ключи для отображения прозрачных пикселей. Однако при запуске программы кажется, что анимационная поверхность (не имеющая цветового ключа) тоже является прозрачной. Почему? Потому что цвет фона растра (черный) совпадает с цветом вторичного буфера. Если изменить значение для заливки вторичного буфера, станет ясно, что анимационная поверхность на самом деле непрозрачна.

Обработка пользовательского ввода

При запуске программы Switch текст в нижней части меню подсказывает, какие клавиши управляют работой приложения. Клавиши со стрелками изменяют текущий выделенный видеорежим, клавиша Enter активизирует его (если он не является текущим), а клавиша Esc завершает работу программы. Все эти клавиши обрабатываются функцией OnKeyDown(), создаваемой ClassWizard. Ее код приведен в листинге 4.5.

void SwitchWin::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
    int newindex;
    int nmodes = GetNumDisplayModes();
    if (nmodes > maxmodes)
        nmodes = maxmodes;
    int rows = nmodes / menucols;
    if (nmodes % menucols)
        rows++;

    switch (nChar)
    {
        case VK_ESCAPE:
            PostMessage(WM_CLOSE);
            break;
        case VK_UP:
            newindex = selectmode - 1;
            if (newindex >= 0)
            {
                selectmode = newindex;
                UpdateMenuSurface();
            }
            break;
        case VK_DOWN:
            newindex = selectmode + 1;
            if (newindex < nmodes)
            {
                selectmode = newindex;
                UpdateMenuSurface();
            }
            break;
        case VK_LEFT:
            newindex = selectmode - rows;
            if (newindex >= 0)
            {
                selectmode = newindex;
                UpdateMenuSurface();
            }
            break;
        case VK_RIGHT:
            newindex = selectmode + rows;
            if (newindex < nmodes)
            {
                selectmode = newindex;
                UpdateMenuSurface();
            }
            break;
        case VK_RETURN:
            if (selectmode != GetCurDisplayMode())
            {
                ActivateDisplayMode(selectmode);
                x = y = 0;
            }
            break;
        case 'S':
            SaveSurface(primsurf, "switch.bmp");
            break;
        case 'M':
            SaveSurface(menusurf, "menusurf.bmp");
            break;
        case 'F':
            SaveSurface(fpssurf, "fpssurf.bmp");
            break;
        case 'T':
            SaveSurface(bmpsurf, "trisurf.bmp");
            break;
        default:
            DirectDrawWin::OnKeyDown(nChar, nRepCnt, nFlags);
    }
}

Обработка нажатых клавиш происходит в различных секциях оператора switch. Клавиша Esc (код виртуальной клавиши VK_ESCAPE) приводит к посылке сообщения WM_CLOSE и последующему завершению приложения. При нажатии клавиш со стрелками изменяется индекс текущего видеорежима и вызывается функция UpdateMenuSurface(), которая перерисовывает menusurf в соответствии с произведенными изменениями. При нажатии клавиши Enter (VK_RETURN) вызывается функция ActivateDisplayMode(), которой в качестве аргумента передается индекс режима (при условии, что выбран видеорежим, отличный от текущего). Все остальные клавиши, нажатые пользователем, обрабатываются функцией OnKeyDown() базового класса.

Восстановление поверхностей

Программа Switch почти готова. Она инициализируется, переключает видеорежимы и обрабатывает пользовательский ввод. Но окончательный вид программа примет лишь после того, как мы организуем в ней восстановление потерянных поверхностей. Класс DirectDrawWin обнаруживает потерю поверхностей и автоматически восстанавливает первичную поверхность со вторичным буфером; после этого вызывается функция RestoreSurfaces(), в которой должны восстанавливаться вспомогательные поверхности приложения. В программе Switch функция RestoreSurfaces() реализована так:

void SwitchWin::RestoreSurfaces()
{
    int displaydepth = GetCurDisplayDepth();

    CString filename;
    if (displaydepth == 8)
        filename="tri08.bmp";
    else
        filename="tri24.bmp";

    if (bmpsurf->IsLost())
    {
        bmpsurf->Restore();
        LoadSurface(bmpsurf, filename);
    }

    if (menusurf->IsLost())
    {
        menusurf->Restore();
        UpdateMenuSurface();
    }

    if (fpssurf->IsLost())
    {
        fpssurf->Restore();
        ClearSurface(fpssurf, 0);
    }
    displayfps = FALSE;
    framecount = 0;
}

В нашем случае функция RestoreSurfaces() отвечает за восстановление всех трех вспомогательных поверхностей. Ее работа начинается с анимационной поверхности (bmpsurf). Функция получает текущую глубину пикселей и по ней определяет, какую версию BMP-файла (палитровую или беспалитровую) следует использовать при восстановлении поверхности. Затем мы проверяем, действительно ли поверхность была потеряна.

При этом учитывается, что «потеряться» могут лишь поверхности, находящиеся в видеопамяти. Поверхности в системной памяти никогда не теряются, поэтому предварительная проверка может избавить нас от хлопот с повторной загрузкой содержимого BMP-файла и, следовательно, ускорить процесс восстановления.

Если поверхность потеряна, мы вызываем функцию Restore() интерфейса DirectDrawSurface, чтобы вернуть видеопамять в объеме, достаточном для хранения поверхности. Содержимое поверхности восстанавливается функцией LoadSurface().

Восстановление двух других поверхностей происходит несколько иначе, потому что их содержимое не является BMP-файлом. Поверхность menusurf восстанавливается функцией Restore() с последующим вызовом функции UpdateMenuSurface(), в которой происходит стирание и перерисовка поверхности меню. При восстановлении fpssurf мы сначала вызываем Restore(), а потом стираем содержимое поверхности, потому что это содержимое после восстановления оказывается непредсказуемым. Не забывайте, поверхности чаще всего теряются из-за того, что занимаемая ими видеопамять понадобилась другому приложению.

Обратите внимание: мы не восстанавливаем значение, отображаемое на поверхности FPS. Потеря первичной поверхности и вторичного буфера означает, что последнее вычисленное значение FPS, по всей видимости, стало неверным. Наша программа была свернута или уступила фокус другому приложению; в любом случае нельзя с уверенностью сказать, насколько быстро обновляется изображение в данный момент. Вместо того чтобы выводить устаревшее значение FPS, мы очищаем поверхность и присваиваем переменной displayfps значение FALSE, тем самым запрещая вывод поверхности до получения новой величины FPS. Кроме того, мы обнуляем переменную framecount, чтобы перезапустить механизм вычисления FPS.

Вот и все, что касается программы Switch. Пора заняться частотой смены кадров и перейти к приложению SuperSwitch.