Come si inserisce l'app OpenGL in modalità schermo intero?

Question

Sono nuovo di OpenGL ma ho scritto una piccola applicazione che funziona bene in una finestra. Ora mi piacerebbe eseguirlo a schermo intero.

Ci sono this dalle FAQ, ma sembra richiedere GLUT, che non è open source. Qual è un buon metodo per mettere un'app OpenGL in modalità a schermo intero? Su Windows XP per ora, ma sarò il porting su altre piattaforme.

Answer 1

sto supponendo che si sta creando la finestra OpenGL il "modo più duro" (via win32)

il codice qui sotto proviene da NeHe, il collegamento punta a un tutorial contenente creazione finestra OpenGL con supporto a schermo intero:

nel caso in cui il compilatore non definisce CDS_FULLSCREEN, aggiungere:

#define CDS_FULLSCREEN 4 

in cima alla vostra applicazione.

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

io ho un debole per SDL per OpenGL window mangament and context wrangling.

Answer 3

Ecco come SDL fa (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); 
} 

Cosa SDL fa quando si imposta la modalità a schermo intero e la risoluzione di destinazione non è la risoluzione del desktop è quello di assicurarsi che si sta utilizzando la frequenza del monitor corretto per la modalità a schermo intero semplicemente dicendo al conducente di applicare la frequenza utilizzata dal desktop (che viene eseguita a schermo intero, quindi la sua frequenza di aggiornamento funzionerà con qualsiasi risoluzione in modalità a schermo intero).

Answer 4

La risposta di Maciek dovrebbe funzionare. Hai solo bisogno della fonte completa dal tutorial di NeHe.

C'è molta più fonte di attenzione nel prendersi cura di tutti i piccoli dettagli come ridimensionare la finestra a schermo intero, coprendo la barra di avvio. Ecco la funzione CreateGLWindow da una delle mie app (una copia quasi del metodo di 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 
} 

Questo è tutto incluso in NeHe Lesson 1.