¿Cómo pongo mi aplicación OpenGL en modo de pantalla completa?

Question

Soy nuevo en OpenGL, pero he escrito una pequeña aplicación que funciona muy bien en una ventana. Ahora me gustaría ejecutarlo a pantalla completa.

No es this de la FAQ, pero parece requerir GLUT, que no es de código abierto. ¿Cuál es un buen método para poner una aplicación OpenGL en modo de pantalla completa? En Windows XP por ahora, pero voy a portar a otras plataformas.

Answer 1

Asumo que está creando la ventana OpenGL el "camino difícil" (a través de Win32)

el código de abajo es oriundo de NeHe, los puntos de enlace a un tutorial que contiene la creación ventana de OpenGL con soporte de pantalla completa:

en caso de que el compilador no define CDS_FULLSCREEN, añadir:

#define CDS_FULLSCREEN 4 

en la parte superior de su aplicación.

if (fullscreen) 
    { 
DEVMODE dmScreenSettings;     // Device Mode 
     memset(&dmScreenSettings,0,sizeof(dmScreenSettings));  // Makes Sure Memory's Cleared 
     dmScreenSettings.dmSize=sizeof(dmScreenSettings);  // Size Of The Devmode Structure 
     dmScreenSettings.dmPelsWidth = width;   // Selected Screen Width 
     dmScreenSettings.dmPelsHeight = height;   // Selected Screen Height 
     dmScreenSettings.dmBitsPerPel = bits;    // Selected Bits Per Pixel 
     dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT; 
// Try To Set Selected Mode And Get Results. NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar. 
     if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL) 
     { 
// If The Mode Fails, Offer Two Options. Quit Or Run In A Window. 
      if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES) 
      {(...) 

Answer 2

soy parcial a SDL para OpenGL window mangament and context wrangling.

Answer 3

Aquí es cómo SDL hace (MS Windows):

// query desktop video settings 
DEVMODE SDL_desktop_mode; 
EnumDisplaySettings (NULL, ENUM_CURRENT_SETTINGS, &SDL_desktop_mode); 

settings.dmBitsPerPel = video->format->BitsPerPixel; 
settings.dmPelsWidth = width; 
settings.dmPelsHeight = height; 
settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL; 
// make sure to use monitor frequency that works in fullscreen 
if (width <= (int)SDL_desktop_mode.dmPelsWidth && 
    height <= (int)SDL_desktop_mode.dmPelsHeight) { 
     settings.dmDisplayFrequency = SDL_desktop_mode.dmDisplayFrequency; 
     settings.dmFields |= DM_DISPLAYFREQUENCY; 
     } 
changed = (ChangeDisplaySettings(&settings, CDS_FULLSCREEN) == DISP_CHANGE_SUCCESSFUL); 
if (! changed && (settings.dmFields & DM_DISPLAYFREQUENCY)) { 
    settings.dmFields &= ~DM_DISPLAYFREQUENCY; 
    changed = (ChangeDisplaySettings(&settings, CDS_FULLSCREEN) == DISP_CHANGE_SUCCESSFUL); 
} 

Lo SDL hace cuando se establece el modo de pantalla completa y la resolución de su objetivo no es la resolución del escritorio es asegurarse de que está utilizando la frecuencia del monitor adecuado para el modo de pantalla completa con sólo decirle al conductor a aplicar la frecuencia que el escritorio se ha estado utilizando (que se ejecuta en pantalla completa, por lo que su frecuencia de actualización funciona con cualquier resolución en el modo de pantalla completa).

Answer 4

respuesta de Maciek debería funcionar. Solo necesita la fuente completa del tutorial de NeHe.

Hay muchos más recursos involucrados en el cuidado de todos los pequeños detalles, como cambiar el tamaño de la ventana a pantalla completa, cubriendo la barra de inicio. Aquí está la función CreateGLWindow de una de mis aplicaciones (una copia del método de NeHe).

inline BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag) 
{ 
    GLuint  PixelFormat;   // Holds The Results After Searching For A Match 
    HINSTANCE hInstance;    // Holds The Instance Of The Application 
    WNDCLASS wc;      // Windows Class Structure 
    DWORD  dwExStyle;    // Window Extended Style 
    DWORD  dwStyle;    // Window Style 
    RECT  WindowRect;    // Grabs Rectangle Upper Left/Lower Right Values 
    WindowRect.left=(long)0;   // Set Left Value To 0 
    WindowRect.right=(long)width;  // Set Right Value To Requested Width 
    WindowRect.top=(long)0;    // Set Top Value To 0 
    WindowRect.bottom=(long)height;  // Set Bottom Value To Requested Height 

    SCREENWIDTH=width; 
    SCREENHEIGHT=height; 

    fullscreen=fullscreenflag;   // Set The Global Fullscreen Flag 

    hInstance   = GetModuleHandle(NULL);    // Grab An Instance For Our Window 
    wc.style   = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Redraw On Size, And Own DC For Window. 
    wc.lpfnWndProc  = (WNDPROC) WndProc;     // WndProc Handles Messages 
    wc.cbClsExtra  = 0;         // No Extra Window Data 
    wc.cbWndExtra  = 0;         // No Extra Window Data 
    wc.hInstance  = hInstance;       // Set The Instance 
    wc.hIcon   = LoadIcon(NULL, IDI_WINLOGO);   // Load The Default Icon 
    wc.hCursor   = LoadCursor(NULL, IDC_ARROW);   // Load The Arrow Pointer 
    wc.hbrBackground = NULL;         // No Background Required For GL 
    wc.lpszMenuName  = NULL;         // We Don't Want A Menu 
    wc.lpszClassName = "OpenGL";        // Set The Class Name 

    if (!RegisterClass(&wc))         // Attempt To Register The Window Class 
    { 
     MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION); 
     return FALSE;           // Return FALSE 
    } 

    if (fullscreen)            // Attempt Fullscreen Mode? 
    { 
     DEVMODE dmScreenSettings;        // Device Mode 
     memset(&dmScreenSettings,0,sizeof(dmScreenSettings)); // Makes Sure Memory's Cleared 
     dmScreenSettings.dmSize=sizeof(dmScreenSettings);  // Size Of The Devmode Structure 
     dmScreenSettings.dmPelsWidth = width;    // Selected Screen Width 
     dmScreenSettings.dmPelsHeight = height;    // Selected Screen Height 
     dmScreenSettings.dmBitsPerPel = bits;     // Selected Bits Per Pixel 
     dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT; 

     // Try To Set Selected Mode And Get Results. NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar. 
     if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL) 
     { 
      // If The Mode Fails, Offer Two Options. Quit Or Use Windowed Mode. 
      if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES) 
      { 
       fullscreen=FALSE;  // Windowed Mode Selected. Fullscreen = FALSE 
      } 
      else 
      { 
       // Pop Up A Message Box Letting User Know The Program Is Closing. 
       MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP); 
       return FALSE;         // Return FALSE 
      } 
     } 
    } 

    if (fullscreen)            // Are We Still In Fullscreen Mode? 
    { 
     dwExStyle=WS_EX_APPWINDOW;        // Window Extended Style 
     dwStyle=WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN; // Windows Style 
     ShowCursor(FALSE);          // Hide Mouse Pointer 
    } 
    else 
    { 
     dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;      // Window Extended Style 
     dwStyle=WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN; // Windows Style 
    } 

    AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle);  // Adjust Window To True Requested Size 

    // Create The Window 
    if (!(hWnd=CreateWindowEx( dwExStyle,       // Extended Style For The Window 
           "OpenGL",       // Class Name 
           title,        // Window Title 
           dwStyle |       // Defined Window Style 
           WS_CLIPSIBLINGS |     // Required Window Style 
           WS_CLIPCHILDREN,     // Required Window Style 
           0, 0,        // Window Position 
           WindowRect.right-WindowRect.left, // Calculate Window Width 
           WindowRect.bottom-WindowRect.top, // Calculate Window Height 
           NULL,        // No Parent Window 
           NULL,        // No Menu 
           hInstance,       // Instance 
           NULL)))        // Dont Pass Anything To WM_CREATE 
    { 
     KillGLWindow();        // Reset The Display 
     MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION); 
     return FALSE;        // Return FALSE 
    } 

    static PIXELFORMATDESCRIPTOR pfd=    // pfd Tells Windows How We Want Things To Be 
    { 
     sizeof(PIXELFORMATDESCRIPTOR),    // Size Of This Pixel Format Descriptor 
     1,           // Version Number 
     PFD_DRAW_TO_WINDOW |      // Format Must Support Window 
     PFD_SUPPORT_OPENGL |      // Format Must Support OpenGL 
     PFD_DOUBLEBUFFER,       // Must Support Double Buffering 
     PFD_TYPE_RGBA,        // Request An RGBA Format 
     bits,          // Select Our Color Depth 
     0, 0, 0, 0, 0, 0,       // Color Bits Ignored 
     0,           // No Alpha Buffer 
     0,           // Shift Bit Ignored 
     0,           // No Accumulation Buffer 
     0, 0, 0, 0,         // Accumulation Bits Ignored 
     32,           // 16Bit Z-Buffer (Depth Buffer) 
     0,           // No Stencil Buffer 
     0,           // No Auxiliary Buffer 
     PFD_MAIN_PLANE,        // Main Drawing Layer 
     0,           // Reserved 
     0, 0, 0          // Layer Masks Ignored 
    }; 

    if (!(hDC=GetDC(hWnd)))       // Did We Get A Device Context? 
    { 
     KillGLWindow();        // Reset The Display 
     MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION); 
     return FALSE;        // Return FALSE 
    } 

    if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd))) // Did Windows Find A Matching Pixel Format? 
    { 
     KillGLWindow();        // Reset The Display 
     MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION); 
     return FALSE;        // Return FALSE 
    } 

    if(!SetPixelFormat(hDC,PixelFormat,&pfd))  // Are We Able To Set The Pixel Format? 
    { 
     KillGLWindow();        // Reset The Display 
     MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION); 
     return FALSE;        // Return FALSE 
    } 

    if (!(hRC=wglCreateContext(hDC)))    // Are We Able To Get A Rendering Context? 
    { 
     KillGLWindow();        // Reset The Display 
     MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION); 
     return FALSE;        // Return FALSE 
    } 

    if(!wglMakeCurrent(hDC,hRC))     // Try To Activate The Rendering Context 
    { 
     KillGLWindow();        // Reset The Display 
     MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION); 
     return FALSE;        // Return FALSE 
    } 

    ShowWindow(hWnd,SW_SHOW);      // Show The Window 
    SetForegroundWindow(hWnd);      // Slightly Higher Priority 
    SetFocus(hWnd);         // Sets Keyboard Focus To The Window 
    ReSizeGLScene(width, height);     // Set Up Our Perspective GL Screen 

    if (!InitGL())         // Initialize Our Newly Created GL Window 
    { 
     KillGLWindow();        // Reset The Display 
     MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION); 
     return FALSE;        // Return FALSE 
    } 

    return TRUE;         // Success 
} 

Todo esto incluido en NeHe Lesson 1.