пятница, 8 июня 2012 г.

Виртуальные текстуры (Virtual textures)

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


суббота, 19 мая 2012 г.

Матрица перспективной проекции

Пусть матрица задана массивом mat[16] или mat[4][4], что тоже самое, т.к. элементы массива в Си располагаются последовательно:

float mat[16];
float * pmat = mat;

float mat[4][4];
float * pmat = &mat[0][0];

Тогда функция получения перспективной проекции будет следующей:



void PerspectiveProjection( float * mat, float fovx, float fovy, float znear, float zfar )
{
      float       xmax = znear * tan( fovx * ( Math::_PI / 360.0 ) );
      float       xmin = -xmax;
      float       ymax = znear * tan( fovy * ( Math::_PI / 360.0 ) );
      float       ymin = -ymax;
      float       invDistance = 1.0f / ( znear - zfar );
      float       w = xmax - xmin;
      float       h = ymax - ymin;

      mat[0] = 2 * znear / w;
      mat[1] = 0;
      mat[2] = 0;
      mat[3] = 0;

      mat[4] = 0;
      mat[5] = 2 * znear / h;
      mat[6] = 0;
      mat[7] = 0;

      mat[8] = 0;
      mat[9] = 0;
      mat[10] = (zfar + znear) * invDistance;
      mat[11] = (2 * zfar * znear) * invDistance;

      mat[12] = 0;
      mat[13] = 0;
      mat[14] = -1;
      mat[15] = 0;
}


Здесь fovx, fovy - аббревиатура field of view (field of vision),углы обзора соответственно по горизонтали и по вертикали.

znear, zfar - ближняя и дальняя плоскости отсечения.

Зная fovx, ширину и высоту (width,height) экрана можно вычислить fovy:
fovy = (float)(atan2( height, width / tan( fovx / 360 * Math::_PI ) ) * 360 / Math::_PI );

Также полезным бывает из текущей матрицы проекции получить ближнюю и дальнюю плоскости отсечения:


void GetPlanesFromProjection( const float * mat, float & znear, float & zfar )
{
znear = mat[11]/(mat[10] - 1.0f);
      zfar = mat[11]/(mat[10] + 1.0f);
}


Спасибо, надеюсь, что кто-то найдет для себя это полезным =) 

четверг, 5 января 2012 г.

Как получить размер окна если известен размер клиентской области


Часто в игровых приложениях нужно, чтобы клиентская область окна была какого-то определенного размера не зависимо от текущей установленной темы Windows. Проще всего воспользоваться функцией AdjustWindowRect:

BOOL WINAPI AdjustWindowRect(
  __inout  LPRECT lpRect,
  __in     DWORD dwStyle,
  __in     BOOL bMenu
);

Расширяя класс из предыдущего поста, можно добавить следующий метод:

Point ClientFrame::adjustSize( const Point & clientSize )
{
      RECT  winRect;
      winRect.left = 0;
      winRect.top = 0;
      winRect.right = clientSize.x;
      winRect.bottom = clientSize.y;
      ::AdjustWindowRect( &winRect, ::GetWindowLong( hwnd, GWL_STYLE ), FALSE );
      return Point(winRect.right - winRect.left, winRect.bottom - winRect.top);
}

Как можно красиво обернуть работу с окнами в WinAPI с помощью классов C++


Рассмотрим конструктор класса. Здесь происходит регистрация класса окна и создание окна. Если все окна принадлежат к одному и тому же классу, то регистрацию класса разумно вынести из конструктора и производить один раз. Для создания уникального имени класса используется переменная namegen. Чтобы не вдаваться в подробности работы метода String::makeFmt, скажу что он работает аналогично функции sprintf, но с безопасным контролем переполнения массива classname.
При создании окна в функцию CreateWindow передается последний параметр - адрес локальной переменной типа MYWNDDATA. Это и есть те магические слова, которые позволят нам в дальнейшем использовать одну функцию-обработчик сообщений WndProc для всех окон.
Ниже приведен код конструктора:

static int namegen=0;

typedef struct tagMyFrameData{

    SHORT   unused;
    ClientFrame  *frame;
} MYWNDDATA, UNALIGNED *PMYWNDDATA;

ClientFrame::ClientFrame()
{
      String::makeFmt( classname, sizeof(classname), "myclass%d", namegen++ );

      WNDCLASSEX  wndClass;
      memset( &wndClass, 0, sizeof( wndClass ) );
      wndClass.lpfnWndProc = WndProc;
      wndClass.cbSize = sizeof (WNDCLASSEX);
      wndClass.lpszClassName = classname;
      wndClass.hbrBackground = reinterpret_cast<HBRUSH>(COLOR_WINDOW + 3);
      wndClass.hCursor = ::LoadCursor( 0, IDC_ARROW );

      ::RegisterClassEx( &wndClass );

      MYWNDDATA   data;
      data.frame = this;

      hwnd = ::CreateWindowEx( 0, wndClass.lpszClassName, TEXT("Frame"), 0,
            40,40,400,400, NULL, NULL, NULL, &data );
      if ( NULL == hwnd ) {
            throw FrameCreateFailed;
      }
}

При вызове CreateWindowEx инициируется сообщение WM_CREATE. Оконная процедура нового окна принимает это сообщение после того, как окно создано, но до того, как окно становится видимым. Рассмотрим функцию WndProc:

static LRESULT CALLBACK WndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
{
      ClientFrame *frame = NULL;

      if ( message == WM_CREATE )
      {
            CREATESTRUCT      *cs = reinterpret_cast<CREATESTRUCT *>(lParam);
            PMYWNDDATA        data = reinterpret_cast<PMYWNDDATA>(cs->lpCreateParams);

            frame = data->frame;
            ::SetWindowLong( hWnd, GWL_USERDATA, reinterpret_cast<long>(frame) );
            return 0;
      }
      else
      {
            frame = reinterpret_cast<ClientFrame *>(::GetWindowLong( hWnd, GWL_USERDATA ));
      }

      if ( NULL == frame )
      {
            return ::DefWindowProc( hWnd, message, wParam, lParam );
      }

      switch (message)
      {

      /* ... */

case WM_MOVE:
      return frame->onMove( (int) LOWORD(lParam), (int) HIWORD(lParam) );

      /* ... */

      }

return ::DefWindowProc( hWnd, message, wParam, lParam );
}

Теперь по порядку:

При получении сообщения WM_CREATE, мы берем указатель на объект окна и помещаем его в область пользовательских данных окна:

::SetWindowLong( hWnd, GWL_USERDATA, reinterpret_cast<long>(frame) );

При получении получении любого другого сообщения мы «достаем» указатель:

frame = reinterpret_cast<ClientFrame *>(::GetWindowLong( hWnd, GWL_USERDATA ));

Далее - чудеса полиморфизма. Для примера было выбрано сообщение WM_MOVE.

switch (message)
      {

      /* ... */

case WM_MOVE:
      return frame->onMove( (int) LOWORD(lParam), (int) HIWORD(lParam) );

      /* ... */

      }

Для каждого сообщения вызывается соответствующий виртуальный метод. В данном случае:

virtual int onMove( int x, int y );


среда, 28 декабря 2011 г.

Установка полноэкранного режима (Fullscreen/Windowed modes)

Это мой первый блог и здесь я хочу описать, как можно установить видео режим в приложении. Тема довольно избитая, но все же вопросы по ней возникают у многих начинающих программистов. Речь пойдет о С++, хотя для других языков принцип ничем не отличается. Варианта два:
- установка режима средствами DirectX;
- установка режима средствами WinAPI.
Рассмотрим второй случай.
Все, что нужно, это EnumDisplaySettings и ChangeDisplaySettings.

BOOL EnumDisplaySettings(
__in LPCTSTR lpszDeviceName,
__in DWORD iModeNum,
__out DEVMODE *lpDevMode
);

LONG ChangeDisplaySettings(
__in DEVMODE *lpDevMode,
__in DWORD dwflags
);
Первая нам понадобиться, чтобы получить список доступных видео режимов, а вторая для установки видео режима.

На высоком уровне нам понадобится функция для смены видео режима, принимающая на вход ширину, высоту и глубину, а так же функции для быстрого переключения между desktop-режимом и установленным новым режимом (для переключения по Alt+Tab или свертке/восстановлении окна). Рассмотрим следующий класс:

class CCDS
{
public:
      CCDS();
      virtual ~CCDS();

      // Функция устанавливает видео режим. Если параметр bpp установлен в 0,
      // то устанавливается режим с максимальным bpp
      bool        changeDisplaySettings( unsigned width, unsigned height, unsigned bpp=0 );

      // Функция восстанавливает настройки режима рабочего стола
      void        restoreDesktopSettings();

      // Функция восстанавливает настройки выбранного ранее режима
      void        restoreDisplaySettings();

      // Функция возвращает состояние - был ли видео режим изменен
      bool        isModeChanged                      () const { return modeChanged != &desktopMode; }

      unsigned    getWidth                () const { return modeChanged->dmPelsWidth; }
      unsigned    getHeight               () const { return modeChanged->dmPelsHeight; }
      unsigned    getBitsPerPel     () const { return modeChanged->dmBitsPerPel; }
      unsigned    getFrequency      () const { return modeChanged->dmDisplayFrequency; }

      bool        getModeDescription      ( unsigned modeNum, unsigned & width, unsigned & height ) const;

private:
      DEVMODE     desktopMode;
      DEVMODE     displayMode;
      DEVMODE     *modeChanged;

      // Функция выбирает подходящий видео режим. Если параметр bpp установлен в 0,
      // то выбирается режим с максимальным bpp
      DWORD chooseAppropriateMode( unsigned width, unsigned height, unsigned bpp=0 );
};
  
 
Desktop-режим можно получить в конструкторе класса следующим образом:

CCDS::CCDS()
      : modeChanged(&desktopMode)
{
      memset( &desktopMode, 0, sizeof( desktopMode ) );
      desktopMode.dmSize = sizeof( desktopMode );
      if( !EnumDisplaySettings( NULL, ENUM_CURRENT_SETTINGS, &desktopMode ) )
            output( "Can't get desktop settings\n" );
}

Выборку режима производит следующий нехитрый метод:

DWORD CCDS::chooseAppropriateMode( unsigned width, unsigned height, unsigned bpp ) {
      DEVMODE     dm;
      DWORD mode = -1;
      DWORD maxBpp = -1;
      DWORD maxFreq = -1;

      while (1) {
            for ( DWORD modeNum = 0 ; ; modeNum++ ) {
                  if (!::EnumDisplaySettings( NULL, modeNum, &dm )) {
                        break;
                  }
                  if ( dm.dmPelsWidth == width && dm.dmPelsHeight == height ) {
                        if ( bpp == 0 ) {
                             if ( (int)maxBpp < (int)dm.dmBitsPerPel ) {
                                   maxBpp = dm.dmBitsPerPel;
                                   mode = modeNum;         // remember current mode
                             }
                        }
                        else if ( bpp == dm.dmBitsPerPel ) {
                             if ( (int)maxFreq < (int)dm.dmDisplayFrequency ) {
                                   maxFreq = dm.dmDisplayFrequency;
                                   mode = modeNum;         // remember current mode
                             }
                        }
                  }
            }

            if ( (int)mode == -1 ) {
                  if (bpp != 0)     // выбранный режим не был найден
                  {
                        output( "WARNING: Your system does not support choosen fullscreen video mode (%d %d %d), trying to choose other like this...\n", width, height, bpp );
                        bpp = 0;          // попытаемся выбрать режим с другим Bpp
                  }
                  else if ( width == DEVICE_SAFE_WIDTH && height == DEVICE_SAFE_HEIGHT ) {
                        output( "Safe fullscreen mode failed\n" );
                        break;
                  }
                  else {
                        output( "Falling to safe resolution (%d %d)...\n", DEVICE_SAFE_WIDTH, DEVICE_SAFE_HEIGHT );
                        width = DEVICE_SAFE_WIDTH;
                        height = DEVICE_SAFE_HEIGHT;
                  }
            }
            else {
                  if ( bpp == 0 ) {
                        bpp = maxBpp;
                        for ( DWORD modeNum = 0 ; ; modeNum++ ) {
                             if (!EnumDisplaySettings( NULL, modeNum, &dm ))
                                   break;
                             if ( dm.dmPelsWidth == width && dm.dmPelsHeight == height && bpp == dm.dmBitsPerPel ) {
                                   if ( (int)maxFreq < (int)dm.dmDisplayFrequency ) {
                                         maxFreq = dm.dmDisplayFrequency;
                                         mode = modeNum;         // remember current mode
                                   }
                             }
                        }
                  }
                  break;
            }
      }
      return mode;
}

Здесь сначала мы подбираем наиболее подходящий режим по ширине и высоте, затем, если указана глубина, подбираем по глубине. Если глубина цвета не указана (bpp=0), то ищем максимально доступную из списка видео режимов. В зваершение подбираем максимальную частоту экрана.

Мотоды restoreDisplaySettings и restoreDesktopSettings просты до безобразия:
  
void CCDS::restoreDesktopSettings() {
      if ( modeChanged != &desktopMode )
      {
            ::ChangeDisplaySettings( &desktopMode, 0 );
#ifdef HWGAMMA
            // restore gamma
            HWND  deskwnd = GetDesktopWindow();
            HDC         deskdc = GetDC( deskwnd );
            SetDeviceGammaRamp( deskdc, desktopGammaTable );
            ReleaseDC( deskwnd, deskdc );
#endif
            modeChanged = &desktopMode;
      }
}

void CCDS::restoreDisplaySettings() {
      if ( modeChanged != &displayMode )
      {
            ::ChangeDisplaySettings( &displayMode, CDS_FULLSCREEN );
#ifdef HWGAMMA
            // restore gamma
            HWND  deskwnd = GetDesktopWindow();
            HDC         deskdc = GetDC( deskwnd );
            SetDeviceGammaRamp( deskdc, gameGammaTable );
            ReleaseDC( deskwnd, deskdc );
#endif
            modeChanged = &displayMode;
      }
}

Их следует поместить в обработчик сообщений Windows в WM_SETFOCUS и WM_KILLFOCUS для  restoreDisplaySettings и restoreDesktopSettings соответственно. Здесь же можно при необходимости устанавливать и восстанавливать гамму. Подробнее о гамме, возможно будет описано в одном из следующих блогов :)

Метод  getModeDescription возвращает ширину и высоту указанного видео режима.

Метод changeDisplaySettings:

// changeDisplaySettings
// Устанавливает видео режим
bool CCDS::changeDisplaySettings( unsigned width, unsigned height, unsigned bpp ) {
      DWORD mode = chooseAppropriateMode( width, height, bpp );
      if ( (int)mode == -1 ) {
            output( "Failed to find an appropriate fullscreen mode\n" );
            return false;
      }
      memset( &displayMode, 0, sizeof( displayMode ) );
      if ( !::EnumDisplaySettings( NULL, mode, &displayMode ) ) {
            output( "Couldn't get display mode\n" );
            return false;
      }

      // Нас интересуют только следующие поля
      displayMode.dmFields &= DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY | DM_BITSPERPEL;

      output( "Selected fullscreen resolution (%d %d %d %dhz)\n", displayMode.dmPelsWidth, displayMode.dmPelsHeight, displayMode.dmBitsPerPel, displayMode.dmDisplayFrequency );
      output( "Changing display settings... " );
      LONG CDS = ::ChangeDisplaySettings( &displayMode, CDS_FULLSCREEN );
      switch ( CDS )
      {
      case DISP_CHANGE_SUCCESSFUL: output( "DISP_CHANGE_SUCCESSFUL\n" ); break;
      case DISP_CHANGE_BADMODE: output( "DISP_CHANGE_BADMODE\n" ); break;
      case DISP_CHANGE_RESTART: output( "DISP_CHANGE_RESTART\n" ); break;
      case DISP_CHANGE_FAILED: output( "DISP_CHANGE_FAILED\n" ); break;
      case DISP_CHANGE_NOTUPDATED: output( "DISP_CHANGE_NOTUPDATED\n" ); break;
      case DISP_CHANGE_BADFLAGS: output( "DISP_CHANGE_BADFLAGS\n" ); break;
      case DISP_CHANGE_BADPARAM: output( "DISP_CHANGE_BADPARAM\n" ); break;
      }
      if ( CDS == DISP_CHANGE_BADMODE )
            output( "Bad mode (%ix%ix%i %ihz)\n", displayMode.dmPelsWidth, displayMode.dmPelsHeight, displayMode.dmBitsPerPel, displayMode.dmDisplayFrequency );
      else if ( CDS != DISP_CHANGE_SUCCESSFUL )
            output( "Failed to change resolution\n" );
      if ( CDS != DISP_CHANGE_SUCCESSFUL )
            return false;
      modeChanged = &displayMode;
      return true;
}

Полный листинг: 

#define     DEVICE_SAFE_WIDTH       640
#define     DEVICE_SAFE_HEIGHT      480

class CCDS
{
public:
      CCDS();
      virtual ~CCDS();

      // Функция устанавливает видео режим. Если параметр bpp установлен в 0,
      // то устанавливается режим с максимальным bpp
      bool        changeDisplaySettings( unsigned width, unsigned height, unsigned bpp=0 );

      // Функция восстанавливает настройки режима рабочего стола
      void        restoreDesktopSettings();

      // Функция восстанавливает настройки выбранного ранее режима
      void        restoreDisplaySettings();

      // Функция возвращает состояние - был ли видео режим изменен
      bool        isModeChanged                      () const { return modeChanged != &desktopMode; }

      unsigned    getWidth                () const { return modeChanged->dmPelsWidth; }
      unsigned    getHeight               () const { return modeChanged->dmPelsHeight; }
      unsigned    getBitsPerPel     () const { return modeChanged->dmBitsPerPel; }
      unsigned    getFrequency      () const { return modeChanged->dmDisplayFrequency; }

      bool        getModeDescription      ( unsigned modeNum, unsigned & width, unsigned & height ) const;

private:
      DEVMODE     desktopMode;
      DEVMODE     displayMode;
      DEVMODE     *modeChanged;

      // Функция выбирает подходящий видео режим. Если параметр bpp установлен в 0,
      // то выбирается режим с максимальным bpp
      DWORD chooseAppropriateMode( unsigned width, unsigned height, unsigned bpp=0 );
};

CCDS::CCDS()
      : modeChanged(&desktopMode)
{
      memset( &desktopMode, 0, sizeof( desktopMode ) );
      desktopMode.dmSize = sizeof( desktopMode );
      if( !EnumDisplaySettings( NULL, ENUM_CURRENT_SETTINGS, &desktopMode ) )
            output( "Can't get desktop settings\n" );
}

CCDS::~CCDS()
{
      if ( modeChanged != &desktopMode )
            ::ChangeDisplaySettings( &desktopMode, 0 );
}

// chooseAppropriateMode
// Функция просматривает список доступных режимов и ищет
// с такими же параметрами, в противном случае выбирается
// режим по умолчанию 640x480
// Если Bpp не указано, либо равно нулю, то функция подбирает
// наиболее высокий
// Если режим был выбран успешно, функция подбирает максимально
// возможную поддерживаемую частоту обновления экрана
// Функция возвращает (-1) если режим не удалось выбрать
DWORD CCDS::chooseAppropriateMode( unsigned width, unsigned height, unsigned bpp ) {
      DEVMODE     dm;
      DWORD mode = -1;
      DWORD maxBpp = -1;
      DWORD maxFreq = -1;

      while (1) {
            for ( DWORD modeNum = 0 ; ; modeNum++ ) {
                  if (!::EnumDisplaySettings( NULL, modeNum, &dm )) {
                        break;
                  }
                  if ( dm.dmPelsWidth == width && dm.dmPelsHeight == height ) {
                        if ( bpp == 0 ) {
                             if ( (int)maxBpp < (int)dm.dmBitsPerPel ) {
                                   maxBpp = dm.dmBitsPerPel;
                                   mode = modeNum;         // remember current mode
                             }
                        }
                        else if ( bpp == dm.dmBitsPerPel ) {
                             if ( (int)maxFreq < (int)dm.dmDisplayFrequency ) {
                                   maxFreq = dm.dmDisplayFrequency;
                                   mode = modeNum;         // remember current mode
                             }
                        }
                  }
            }

            if ( (int)mode == -1 ) {
                  if (bpp != 0)     // выбранный режим не был найден
                  {
                        output( "WARNING: Your system does not support choosen fullscreen video mode (%d %d %d), trying to choose other like this...\n", width, height, bpp );
                        bpp = 0;          // попытаемся выбрать режим с другим Bpp
                  }
                  else if ( width == DEVICE_SAFE_WIDTH && height == DEVICE_SAFE_HEIGHT ) {
                        output( "Safe fullscreen mode failed\n" );
                        break;
                  }
                  else {
                        output( "Falling to safe resolution (%d %d)...\n", DEVICE_SAFE_WIDTH, DEVICE_SAFE_HEIGHT );
                        width = DEVICE_SAFE_WIDTH;
                        height = DEVICE_SAFE_HEIGHT;
                  }
            }
            else {
                  if ( bpp == 0 ) {
                        bpp = maxBpp;
                        for ( DWORD modeNum = 0 ; ; modeNum++ ) {
                             if (!EnumDisplaySettings( NULL, modeNum, &dm ))
                                   break;
                             if ( dm.dmPelsWidth == width && dm.dmPelsHeight == height && bpp == dm.dmBitsPerPel ) {
                                   if ( (int)maxFreq < (int)dm.dmDisplayFrequency ) {
                                         maxFreq = dm.dmDisplayFrequency;
                                         mode = modeNum;         // remember current mode
                                   }
                             }
                        }
                  }
                  break;
            }
      }
      return mode;
}

// changeDisplaySettings
// Устанавливает видео режим
bool CCDS::changeDisplaySettings( unsigned width, unsigned height, unsigned bpp ) {
      DWORD mode = chooseAppropriateMode( width, height, bpp );
      if ( (int)mode == -1 ) {
            output( "Failed to find an appropriate fullscreen mode\n" );
            return false;
      }
      memset( &displayMode, 0, sizeof( displayMode ) );
      if ( !::EnumDisplaySettings( NULL, mode, &displayMode ) ) {
            output( "Couldn't get display mode\n" );
            return false;
      }

      // Нас интересуют только следующие поля
      displayMode.dmFields &= DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY | DM_BITSPERPEL;

      output( "Selected fullscreen resolution (%d %d %d %dhz)\n", displayMode.dmPelsWidth, displayMode.dmPelsHeight, displayMode.dmBitsPerPel, displayMode.dmDisplayFrequency );
      output( "Changing display settings... " );
      LONG CDS = ::ChangeDisplaySettings( &displayMode, CDS_FULLSCREEN );
      switch ( CDS )
      {
      case DISP_CHANGE_SUCCESSFUL: output( "DISP_CHANGE_SUCCESSFUL\n" ); break;
      case DISP_CHANGE_BADMODE: output( "DISP_CHANGE_BADMODE\n" ); break;
      case DISP_CHANGE_RESTART: output( "DISP_CHANGE_RESTART\n" ); break;
      case DISP_CHANGE_FAILED: output( "DISP_CHANGE_FAILED\n" ); break;
      case DISP_CHANGE_NOTUPDATED: output( "DISP_CHANGE_NOTUPDATED\n" ); break;
      case DISP_CHANGE_BADFLAGS: output( "DISP_CHANGE_BADFLAGS\n" ); break;
      case DISP_CHANGE_BADPARAM: output( "DISP_CHANGE_BADPARAM\n" ); break;
      }
      if ( CDS == DISP_CHANGE_BADMODE )
            output( "Bad mode (%ix%ix%i %ihz)\n", displayMode.dmPelsWidth, displayMode.dmPelsHeight, displayMode.dmBitsPerPel, displayMode.dmDisplayFrequency );
      else if ( CDS != DISP_CHANGE_SUCCESSFUL )
            output( "Failed to change resolution\n" );
      if ( CDS != DISP_CHANGE_SUCCESSFUL )
            return false;
      modeChanged = &displayMode;
      return true;
}

void CCDS::restoreDesktopSettings() {
      if ( modeChanged != &desktopMode )
      {
            ::ChangeDisplaySettings( &desktopMode, 0 );
#ifdef HWGAMMA
            // restore gamma
            HWND  deskwnd = GetDesktopWindow();
            HDC         deskdc = GetDC( deskwnd );
            SetDeviceGammaRamp( deskdc, desktopGammaTable );
            ReleaseDC( deskwnd, deskdc );
#endif
            modeChanged = &desktopMode;
      }
}

void CCDS::restoreDisplaySettings() {
      if ( modeChanged != &displayMode )
      {
            ::ChangeDisplaySettings( &displayMode, CDS_FULLSCREEN );
#ifdef HWGAMMA
            // restore gamma
            HWND  deskwnd = GetDesktopWindow();
            HDC         deskdc = GetDC( deskwnd );
            SetDeviceGammaRamp( deskdc, gameGammaTable );
            ReleaseDC( deskwnd, deskdc );
#endif
            modeChanged = &displayMode;
      }
}

bool        CCDS::getModeDescription     ( unsigned modeNum, unsigned & width, unsigned & height ) const
{
      DEVMODE     devMode;
      memset( &devMode, 0, sizeof( devMode ) );
      if ( !::EnumDisplaySettings( NULL, modeNum, &devMode ) ) {
            output( "Couldn't get display mode\n" );
            return false;
      }
      width = devMode.dmPelsWidth;
      height = devMode.dmPelsHeight;
      return true;
}