git.mutantstargoat.com Git - freeglut/blob - src/freeglut_gamemode.c

   1 /*
   2  * freeglut_gamemode.c
   3  *
   4  * The game mode handling code.
   5  *
   6  * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
   7  * Written by Pawel W. Olszta, <olszta@sourceforge.net>
   8  * Creation date: Thu Dec 16 1999
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a
  11  * copy of this software and associated documentation files (the "Software"),
  12  * to deal in the Software without restriction, including without limitation
  13  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  14  * and/or sell copies of the Software, and to permit persons to whom the
  15  * Software is furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included
  18  * in all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  21  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  23  * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  24  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  25  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  */
  27
  28 #ifdef HAVE_CONFIG_H
  29 #include "config.h"
  30 #endif
  31
  32 #define  G_LOG_DOMAIN  "freeglut-gamemode"
  33
  34 #include "../include/GL/freeglut.h"
  35 #include "freeglut_internal.h"
  36
  37 /*
  38  * TODO BEFORE THE STABLE RELEASE:
  39  *
  40  *  glutGameModeString()    -- missing
  41  *  glutEnterGameMode()     -- X11 version
  42  *  glutLeaveGameMode()     -- is that correct?
  43  *  glutGameModeGet()       -- is that correct?
  44  */
  45
  46
  47 /* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
  48
  49 /*
  50  * Remembers the current visual settings, so that
  51  * we can change them and restore later...
  52  */
  53 void fghRememberState( void )
  54 {
  55 #if TARGET_HOST_UNIX_X11
  56
  57     /*
  58      * This highly depends on the XFree86 extensions, not approved as X Consortium standards
  59      */
  60 #   ifdef X_XF86VidModeGetModeLine
  61
  62
  63     /*
  64      * Remember the current ViewPort location of the screen to be able to
  65      * restore the ViewPort on LeaveGameMode():
  66      */
  67     XF86VidModeGetViewPort(
  68         fgDisplay.Display,
  69         fgDisplay.Screen,
  70         &fgDisplay.DisplayViewPortX,
  71         &fgDisplay.DisplayViewPortY
  72     );
  73
  74     /*
  75      * Remember the current pointer location before going fullscreen
  76      * for restoring it later:
  77      */
  78     {
  79         Window junk_window;
  80         unsigned int mask;
  81
  82         XQueryPointer(
  83             fgDisplay.Display, fgDisplay.RootWindow,
  84             &junk_window, &junk_window,
  85             &fgDisplay.DisplayPointerX, &fgDisplay.DisplayPointerY,
  86             &fgDisplay.DisplayPointerX, &fgDisplay.DisplayPointerY, &mask
  87         );
  88     }
  89
  90     /*
  91      * Query the current display settings:
  92      */
  93     fgDisplay.DisplayModeValid =
  94       XF86VidModeGetModeLine(
  95         fgDisplay.Display,
  96         fgDisplay.Screen,
  97         &fgDisplay.DisplayModeClock,
  98         &fgDisplay.DisplayMode
  99     );
 100
 101     if (!fgDisplay.DisplayModeValid)
 102             fgWarning( "Runtime use of XF86VidModeGetModeLine failed.\n" );
 103
 104 #   else
 105 #       warning fghRememberState: missing XFree86 video mode extensions, game mode will not change screen resolution when activated
 106 #   endif
 107
 108 #elif TARGET_HOST_WIN32
 109
 110 /*    DEVMODE devMode; */
 111
 112     /*
 113      * Grab the current desktop settings...
 114      */
 115
 116 /* hack to get around my stupid cross-gcc headers */
 117 #define FREEGLUT_ENUM_CURRENT_SETTINGS -1
 118
 119     EnumDisplaySettings( NULL, FREEGLUT_ENUM_CURRENT_SETTINGS, &fgDisplay.DisplayMode );
 120
 121     /*
 122      * Make sure we will be restoring all settings needed
 123      */
 124     fgDisplay.DisplayMode.dmFields |= DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL | DM_DISPLAYFREQUENCY;
 125
 126 #endif
 127 }
 128
 129 /*
 130  * Restores the previously remembered visual settings
 131  */
 132 void fghRestoreState( void )
 133 {
 134 #if TARGET_HOST_UNIX_X11
 135
 136 #   ifdef X_XF86VidModeGetAllModeLines
 137     /*
 138      * Restore the remembered pointer position:
 139      */
 140     XWarpPointer(
 141         fgDisplay.Display, None, fgDisplay.RootWindow, 0, 0, 0, 0,
 142         fgDisplay.DisplayPointerX, fgDisplay.DisplayPointerY
 143     );
 144
 145     /*
 146      * This highly depends on the XFree86 extensions, not approved as X Consortium standards
 147      */
 148
 149     if (fgDisplay.DisplayModeValid)
 150     {
 151         XF86VidModeModeInfo** displayModes;
 152         int i, displayModesCount;
 153
 154         /*
 155          * Query for all the display available...
 156          */
 157         XF86VidModeGetAllModeLines(
 158             fgDisplay.Display,
 159             fgDisplay.Screen,
 160             &displayModesCount,
 161             &displayModes
 162         );
 163
 164         /*
 165          * Check every of the modes looking for one that matches our demands
 166          */
 167         for( i=0; i<displayModesCount; i++ )
 168         {
 169             if( displayModes[ i ]->hdisplay == fgDisplay.DisplayMode.hdisplay &&
 170                 displayModes[ i ]->vdisplay == fgDisplay.DisplayMode.vdisplay &&
 171                 displayModes[ i ]->dotclock == fgDisplay.DisplayModeClock )
 172             {
 173                 /*
 174                  * OK, this is the display mode we have been looking for...
 175                  */
 176                 XF86VidModeSwitchToMode(
 177                     fgDisplay.Display,
 178                     fgDisplay.Screen,
 179                     displayModes[ i ]
 180                 );
 181
 182                 /*
 183                  * Now we can restore the remembered ViewPort:
 184                  */
 185                 XF86VidModeSetViewPort(
 186                      fgDisplay.Display,
 187                      fgDisplay.Screen,
 188                      fgDisplay.DisplayViewPortX,
 189                      fgDisplay.DisplayViewPortY
 190                 );
 191
 192                   /*
 193                    * For the case this would be the last X11 call the application
 194                    * calls exit() we've to flush the X11 output queue to have the
 195                    * commands sent to the X server before the application exists.
 196                    */
 197                   XFlush(fgDisplay.Display);
 198
 199                 return;
 200             }
 201         }
 202     }
 203
 204 #   else
 205 #       warning fghRestoreState: missing XFree86 video mode extensions, game mode will not change screen resolution when activated
 206 #   endif
 207
 208 #elif TARGET_HOST_WIN32
 209
 210     /*
 211      * Restore the previously rememebered desktop display settings
 212      */
 213     ChangeDisplaySettings( &fgDisplay.DisplayMode, 0 );
 214
 215 #endif
 216 }
 217
 218 /*
 219  * Checks the display mode settings against user's preferences
 220  */
 221 GLboolean fghCheckDisplayMode( int width, int height, int depth, int refresh )
 222 {
 223     /*
 224      * The desired values should be stored in fgState structure...
 225      */
 226     return( (width == fgState.GameModeSize.X) && (height == fgState.GameModeSize.Y) &&
 227             (depth == fgState.GameModeDepth)  && (refresh == fgState.GameModeRefresh) );
 228 }
 229
 230 /*
 231  * Changes the current display mode to match user's settings
 232  */
 233 GLboolean fghChangeDisplayMode( GLboolean haveToTest )
 234 {
 235 #if TARGET_HOST_UNIX_X11
 236
 237     /*
 238      * This highly depends on the XFree86 extensions, not approved as X Consortium standards
 239      */
 240 #   ifdef X_XF86VidModeGetAllModeLines
 241
 242     /*
 243      * This is also used by applcations which check modes by calling
 244      * glutGameModeGet(GLUT_GAME_MODE_POSSIBLE), so allow the check:
 245      */
 246     if (haveToTest || fgDisplay.DisplayModeValid)
 247     {
 248         XF86VidModeModeInfo** displayModes;
 249         int i, displayModesCount;
 250
 251         /*
 252          * Query for all the display available...
 253          */
 254         XF86VidModeGetAllModeLines(
 255             fgDisplay.Display,
 256             fgDisplay.Screen,
 257             &displayModesCount,
 258             &displayModes
 259         );
 260
 261         /*
 262          * Check every of the modes looking for one that matches our demands
 263          */
 264         for( i=0; i<displayModesCount; i++ )
 265         {
 266             if( fghCheckDisplayMode( displayModes[ i ]->hdisplay, displayModes[ i ]->vdisplay,
 267                                      fgState.GameModeDepth, fgState.GameModeRefresh ) )
 268             {
 269                       if( haveToTest )
 270                                 return( TRUE );
 271                 /*
 272                  * OKi, this is the display mode we have been looking for...
 273                  */
 274                 XF86VidModeSwitchToMode(
 275                     fgDisplay.Display,
 276                     fgDisplay.Screen,
 277                     displayModes[ i ]
 278                 );
 279                 /*
 280                  * Return successfull...
 281                  */
 282                 return( TRUE );
 283             }
 284         }
 285     }
 286
 287     /*
 288      * Something must have went wrong
 289      */
 290     return( FALSE );
 291
 292 #   else
 293 #       warning fghChangeDisplayMode: missing XFree86 video mode extensions, game mode will not change screen resolution when activated
 294 #   endif
 295
 296 #elif TARGET_HOST_WIN32
 297
 298     unsigned int    displayModes = 0, mode = 0xffffffff;
 299     GLboolean success = FALSE;
 300 /*    HDC      desktopDC; */
 301     DEVMODE  devMode;
 302
 303     /*
 304      * Enumerate the available display modes
 305      * Try to get a complete match
 306      */
 307     while( EnumDisplaySettings( NULL, displayModes, &devMode ) == TRUE )
 308     {
 309         /*
 310          * Does the enumerated display mode match the user's preferences?
 311          */
 312         if( fghCheckDisplayMode( devMode.dmPelsWidth,  devMode.dmPelsHeight,
 313                                  devMode.dmBitsPerPel, devMode.dmDisplayFrequency ) )
 314         {
 315             /*
 316              * OKi, we've found a matching display mode, remember its number and break
 317              */
 318             mode = displayModes;
 319             break;
 320         }
 321
 322         /*
 323          * Switch to the next display mode, if any
 324          */
 325         displayModes++;
 326     }
 327
 328     if ( mode == 0xffffffff )
 329     {
 330       /* then try without Display Frequency */
 331       displayModes = 0;
 332
 333       /*
 334        * Enumerate the available display modes
 335        */
 336       while( EnumDisplaySettings( NULL, displayModes, &devMode ) == TRUE )
 337       {
 338         /* then try without Display Frequency */
 339
 340         if( fghCheckDisplayMode( devMode.dmPelsWidth,  devMode.dmPelsHeight,
 341                                  devMode.dmBitsPerPel, fgState.GameModeRefresh))
 342         {
 343           /*
 344            * OKi, we've found a matching display mode, remember its number and break
 345            */
 346           mode = displayModes;
 347           break;
 348         }
 349
 350         /*
 351          * Switch to the next display mode, if any
 352          */
 353         displayModes++;
 354       }
 355     }
 356
 357     /*
 358      * Did we find a matching display mode?
 359      */
 360     if( mode != 0xffffffff )
 361     {
 362         int retVal = DISP_CHANGE_SUCCESSFUL;
 363
 364         /*
 365          * Mark the values we want to modify in the display change call
 366          */
 367         devMode.dmFields |= DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL | DM_DISPLAYFREQUENCY;
 368
 369         /*
 370          * Change the current display mode (possibly in test mode only)
 371          */
 372         retVal = ChangeDisplaySettings( &devMode, haveToTest ? CDS_TEST : 0 );
 373
 374         /*
 375          * I don't know if it's really needed, but looks nice:
 376          */
 377         success = (retVal == DISP_CHANGE_SUCCESSFUL) || (retVal == DISP_CHANGE_NOTUPDATED);
 378
 379         /*
 380          * If it was not a test, remember the current screen settings
 381          */
 382         if( !haveToTest && success )
 383         {
 384             fgState.GameModeSize.X  = devMode.dmPelsWidth;
 385             fgState.GameModeSize.Y  = devMode.dmPelsHeight;
 386             fgState.GameModeDepth   = devMode.dmBitsPerPel;
 387             fgState.GameModeRefresh = devMode.dmDisplayFrequency;
 388         }
 389     }
 390
 391     /*
 392      * Otherwise we must have failed somewhere
 393      */
 394     return( success );
 395
 396 #endif
 397 }
 398
 399
 400 /* -- INTERFACE FUNCTIONS -------------------------------------------------- */
 401
 402 /*
 403  * Sets the game mode display string
 404  */
 405 void FGAPIENTRY glutGameModeString( const char* string )
 406 {
 407     int width = 640, height = 480, depth = 16, refresh = 72;
 408
 409     /*
 410      * This one seems a bit easier than glutInitDisplayString. The bad thing
 411      * about it that I was unable to find the game mode string definition, so
 412      * that I assumed it is: "[width]x[height]:[depth]@[refresh rate]", which
 413      * appears in all GLUT game mode programs I have seen to date.
 414      */
 415     if( sscanf( string, "%ix%i:%i@%i", &width, &height, &depth, &refresh ) != 4 )
 416         if( sscanf( string, "%ix%i:%i", &width, &height, &depth ) != 3 )
 417             if( sscanf( string, "%ix%i@%i", &width, &height, &refresh ) != 3 )
 418                 if( sscanf( string, "%ix%i", &width, &height ) != 2 )
 419                     if( sscanf( string, ":%i@%i", &depth, &refresh ) != 2 )
 420                         if( sscanf( string, ":%i", &depth ) != 1 )
 421                             if( sscanf( string, "@%i", &refresh ) != 1 )
 422                                 fgWarning( "unable to parse game mode string `%s'", string );
 423
 424     /*
 425      * Hopefully it worked, and if not, we still have the default values
 426      */
 427     fgState.GameModeSize.X  = width;
 428     fgState.GameModeSize.Y  = height;
 429     fgState.GameModeDepth   = depth;
 430     fgState.GameModeRefresh = refresh;
 431 }
 432
 433 /*
 434  * Enters the game mode
 435  */
 436 int FGAPIENTRY glutEnterGameMode( void )
 437 {
 438     /*
 439      * Check if a game mode window already exists...
 440      */
 441     if( fgStructure.GameMode != NULL )
 442     {
 443         /*
 444          * ...if so, delete it before proceeding...
 445          */
 446         fgAddToWindowDestroyList( fgStructure.GameMode, TRUE );
 447     }
 448     else
 449     {
 450         /*
 451          * ...otherwise remember the current resolution, etc.
 452          */
 453         fghRememberState();
 454     }
 455
 456     /*
 457      * We are ready to change the current screen's resolution now
 458      */
 459     if( fghChangeDisplayMode( FALSE ) == FALSE )
 460     {
 461               fgWarning( "failed to change screen settings" );
 462         return( FALSE );
 463     }
 464
 465     /*
 466      * Finally, have the game mode window created
 467      */
 468     fgStructure.GameMode = fgCreateWindow(
 469         NULL, "FREEGLUT", 0, 0, fgState.GameModeSize.X, fgState.GameModeSize.Y, TRUE
 470     );
 471
 472 #if TARGET_HOST_UNIX_X11
 473
 474     /* Move the window up to the topleft corner */
 475     XMoveWindow(fgDisplay.Display, fgStructure.Window->Window.Handle, 0, 0);
 476
 477     /*
 478      * Sync needed to avoid a real race, the Xserver must have really created
 479      * the window before we can grab the pointer into it:
 480      */
 481     XSync(fgDisplay.Display, False);
 482
 483     /* Move the Pointer to the middle of the fullscreen window */
 484     XWarpPointer(
 485         fgDisplay.Display,
 486         None,
 487         fgDisplay.RootWindow,
 488         0, 0, 0, 0,
 489         fgState.GameModeSize.X/2, fgState.GameModeSize.Y/2
 490     );
 491
 492     /*
 493      * Grab the pointer to confine it into the window after the calls to
 494      * XWrapPointer() which ensure that the pointer really enters the window.
 495      *
 496      * We also need to wait here until XGrabPointer() returns GrabSuccess,
 497      * otherwise the new window is not viewable yet and if the next function
 498      * (XSetInputFocus) is called with a not yet viewable window, it will exit
 499      * the application which we have to aviod, so wait until it's viewable:
 500      */
 501     while (GrabSuccess != XGrabPointer(
 502             fgDisplay.Display, fgStructure.GameMode->Window.Handle,
 503             TRUE, ButtonPressMask|ButtonReleaseMask|ButtonMotionMask
 504                 |PointerMotionMask,
 505             GrabModeAsync, GrabModeAsync,
 506             fgStructure.GameMode->Window.Handle, None, CurrentTime)) {
 507         usleep (100);
 508     }
 509
 510     /*
 511      * Change input focus to the new window. This will exit the application
 512      * if the new window is not viewable yet, see the XGrabPointer loop above.
 513      */
 514     XSetInputFocus(
 515         fgDisplay.Display,
 516         fgStructure.GameMode->Window.Handle,
 517         RevertToNone,
 518         CurrentTime
 519     );
 520
 521 #   ifdef X_XF86VidModeSetViewPort
 522
 523     if (fgDisplay.DisplayModeValid) {
 524         int x, y;
 525         Window child;
 526
 527         /*
 528          * Change to viewport to the window topleft edge:
 529          */
 530         XF86VidModeSetViewPort(fgDisplay.Display, fgDisplay.Screen, 0, 0);
 531
 532         /*
 533          * Final window repositioning: It could be avoided using an undecorated
 534          * window using override_redirect, but this * would possily require more
 535          * changes and investigation.
 536          */
 537
 538         /* Get the current postion of the drawable area on screen */
 539         XTranslateCoordinates(
 540             fgDisplay.Display,
 541             fgStructure.Window->Window.Handle,
 542             fgDisplay.RootWindow,
 543             0, 0, &x, &y,
 544             &child
 545         );
 546
 547         /* Move the decorataions out of the topleft corner of the display */
 548         XMoveWindow(fgDisplay.Display, fgStructure.Window->Window.Handle, -x, -y);
 549     }
 550
 551 #endif
 552
 553     /*
 554      * Grab the keyboard, too
 555      */
 556     XGrabKeyboard(
 557         fgDisplay.Display,
 558         fgStructure.GameMode->Window.Handle,
 559         FALSE,
 560         GrabModeAsync, GrabModeAsync,
 561         CurrentTime
 562     );
 563
 564 #endif
 565
 566     /*
 567      * Return successfull
 568      */
 569     return( TRUE );
 570 }
 571
 572 /*
 573  * Leaves the game mode
 574  */
 575 void FGAPIENTRY glutLeaveGameMode( void )
 576 {
 577     freeglut_return_if_fail( fgStructure.GameMode != NULL );
 578
 579     /*
 580      * First of all, have the game mode window destroyed
 581      */
 582     fgAddToWindowDestroyList( fgStructure.GameMode, TRUE );
 583
 584 #if TARGET_HOST_UNIX_X11
 585
 586     /*
 587      * Ungrab the mouse and keyboard
 588      */
 589     XUngrabPointer( fgDisplay.Display, CurrentTime );
 590     XUngrabKeyboard( fgDisplay.Display, CurrentTime );
 591
 592 #endif
 593
 594     /*
 595      * Then, have the desktop visual settings restored
 596      */
 597     fghRestoreState();
 598 }
 599
 600 /*
 601  * Returns information concerning the freeglut game mode
 602  */
 603 int FGAPIENTRY glutGameModeGet( GLenum eWhat )
 604 {
 605     /*
 606      * See why are we bothered
 607      */
 608     switch( eWhat )
 609     {
 610     case GLUT_GAME_MODE_ACTIVE:
 611         /*
 612          * Check if the game mode is currently active
 613          */
 614         return( fgStructure.GameMode != NULL );
 615
 616     case GLUT_GAME_MODE_POSSIBLE:
 617         /*
 618          * Check if the current game mode settings are valid
 619          */
 620         return( fghChangeDisplayMode( TRUE ) );
 621
 622     case GLUT_GAME_MODE_WIDTH:
 623         /*
 624          * The game mode screen width
 625          */
 626         return( fgState.GameModeSize.X );
 627
 628     case GLUT_GAME_MODE_HEIGHT:
 629         /*
 630          * The game mode screen height
 631          */
 632         return( fgState.GameModeSize.Y );
 633
 634     case GLUT_GAME_MODE_PIXEL_DEPTH:
 635         /*
 636          * The game mode pixel depth
 637          */
 638         return( fgState.GameModeDepth );
 639
 640     case GLUT_GAME_MODE_REFRESH_RATE:
 641         /*
 642          * The game mode refresh rate
 643          */
 644         return( fgState.GameModeRefresh );
 645
 646     case GLUT_GAME_MODE_DISPLAY_CHANGED:
 647         /*
 648          * This is true if the game mode has been activated successfully..
 649          */
 650         return( fgStructure.GameMode != NULL );
 651     }
 652
 653     return( -1 );
 654 }
 655
 656 /*** END OF FILE ***/
 657
 658
 659
 660