Fullscreen Windows

In this lesson, we'll explore SDL's window management features, learning how to implement both desktop and exclusive fullscreen modes. We’ll cover:

• Creating borderless fullscreen windows that cover the entire screen using SDL_WINDOW_FULLSCREEN_DESKTOP
• Using exclusive fullscreen mode, which changes display settings for optimal performance using SDL_WINDOW_FULLSCREEN
• Using SDL_SetWindowFullscreen() lets you change modes at runtime
• Best practices and error handling

Desktop Fullscreen

The easiest way of creating a fullscreen experience is to simply render our game in a borderless window that has the same position and dimensions as the monitor’s display bounds.

SDL provides us with a quick way to set this up, which we’ll cover later in this lesson. However, we could achieve something similar by passing the display index to SDL_GetDisplayBounds(), and then creating a borderless window with the same position and size:

1// Get size and position of display with index 0
2SDL_Rect Bounds;
3SDL_GetDisplayBounds(0, &Bounds);
4
5SDL_Window* Window{SDL_CreateWindow(
6  "Window",
7  Bounds.x, Bounds.y, // Position 
8  Bounds.w, Bounds.h, // Size 
9  SDL_WINDOW_BORDERLESS 
10)};

This technique is sometimes referred to as windowed fullscreen, desktop fullscreen, or borderless fullscreen. With this technique, our game is just another window, which makes multi-tasking easier. It provides a solid user experience when the player is switching between our game and other windows.

However, there are two problems:

• We may want to render our game at a different resolution than what the monitor is currently using
• The way our game represents colors may be different to what the monitor is currently using

SDL automatically handles both of these problems by rescaling each frame to match the display resolution and reformatting it to match the monitor's color requirements.

However, this additional rescaling and reformatting step means each frame takes slightly longer to complete. So, whilst windows fullscreen provides a smooth experience when multitasking, we pay for it by our game possibly running slightly slower.

Exclusive Fullscreen

Instead of having our frames rescaled and reformatted to meet the monitor’s requirements, we could instead update the monitor’s settings to match what our game is outputting.

This allows each frame to be displayed directly on the display. This technique is often called exclusive fullscreen or simply fullscreen, and it eliminates the performance overhead of windowed fullscreen.

However, changing the display mode of a typical monitor takes a few seconds, during which time the monitor is typically unusable. This makes switching to other windows more frustrating for users, as it takes a few seconds to update their display settings. We cover these display modes in detail in the next lesson.

Most games allow players to configure whether they’d prefer the game run in a window, windowed fullscreen or exclusive fullscreen:

When we know which mode they want to use, we can create or update our window to use that preference.

Creating Fullscreen Windows

We can create an exclusive or fullscreen window by passing the appropriate flag to the SDL_CreateWindow() function.

SDL_WINDOW_FULLSCREEN_DESKTOP

SDL uses the SDL_WINDOW_FULLSCREEN_DESKTOP flag to configure desktop fullscreen windows:

1SDL_Window* Window{SDL_CreateWindow(
2  "Window",
3  SDL_WINDOWPOS_UNDEFINED,
4  SDL_WINDOWPOS_UNDEFINED,
5  1920, 1080,
6  SDL_WINDOW_FULLSCREEN_DESKTOP
7)};
8
9int x, y;
10SDL_GetWindowSize(Window, &x, &y);
11std::cout << "Size: " << x << 'x' << y;

1Size: 2560x1440

The window size we specify for a fullscreen desktop window can still be relevant. For example, if we update our window to no longer be fullscreen, it will adopt the size we specified - 1920x1080 in this example. We cover how to change the fullscreen status of a window later in this lesson.

SDL_WINDOW_FULLSCREEN

Exclusive fullscreen windows are configured using the SDL_WINDOW_FULLSCREEN flag:

1SDL_Window* Window{SDL_CreateWindow(
2  "Window",
3  SDL_WINDOWPOS_UNDEFINED,
4  SDL_WINDOWPOS_UNDEFINED,
5  1920, 1080,
6  SDL_WINDOW_FULLSCREEN
7)};
8
9int x, y;
10SDL_GetWindowSize(Window, &x, &y);
11std::cout << "Size: " << x << 'x' << y;

1Size: 1920x1080

With an exclusive fullscreen window, the display the window is created on will be updated to adopt the resolution that matches our window size - 1920x1080 in this example.

If we disable fullscreen mode for this window, our display will revert to its original mode, and we will have a regular 1920x1080 window on that display. We cover display modes in detail in the next lesson.

Changing Fullscreen Mode

We can update the fullscreen mode of an existing window using the SDL_SetWindowFullscreen() function. We pass the SDL_Window pointer as the first argument, and the desired window flag as the second argument. Our options are:

• SDL_WINDOW_FULLSCREEN_DESKTOP: Set the window to be desktop fullscreen
• SDL_WINDOW_FULLSCREEN: Set the window to be exclusive fullscreen
• 0: Disable fullscreen mode for this window

Here’s an example:

1SDL_Window* Window{SDL_CreateWindow(
2  "Window",
3  SDL_WINDOWPOS_UNDEFINED,
4  SDL_WINDOWPOS_UNDEFINED,
5  1920, 1080,
6  0 // Not fullscreen
7)};
8
9// Set window to be desktop fullscreen
10SDL_SetWindowFullscreen(Window,
11  SDL_WINDOW_FULLSCREEN_DESKTOP);
12  
13// Set window to be exclusive fullscreen
14SDL_SetWindowFullscreen(Window,
15  SDL_WINDOW_FULLSCREEN);
16
17// Disable fullscreen
18SDL_SetWindowFullscreen(Window, 0);

Error Handling

The SDL_SetWindowFullscreen() function returns 0 if it was successful, or a negative error code otherwise. We can call SDL_GetError() to retrieve the error message:

1if (SDL_SetWindowFullscreen(nullptr, 0) < 0) {
2  std::cout << "Error changing fullscreen "
3               "mode: " << SDL_GetError();
4}

1Error changing fullscreen mode: Invalid window

Getting Fullscreen Mode

We can check a window's current fullscreen state using SDL_GetWindowFlags(). This function returns a bit field containing all the window's current flags. To check for fullscreen modes, we examine specific bits using bitwise operations. The bitwise AND operator (&) lets us check if specific flags are set:

1SDL_Window* Window{SDL_CreateWindow(
2  "Window",
3  SDL_WINDOWPOS_UNDEFINED,
4  SDL_WINDOWPOS_UNDEFINED,
5  1920, 1080,
6  SDL_WINDOW_FULLSCREEN_DESKTOP
7)};
8
9Uint32 Flags{SDL_GetWindowFlags(Window)};
10
11if (Flags & SDL_WINDOW_FULLSCREEN_DESKTOP) {
12  std::cout << "Desktop fullscreen";
13} else if (Flags & SDL_WINDOW_FULLSCREEN) {
14  std::cout << "Exclusive fullscreen";
15} else {
16  std::cout << "Not fullscreen";
17}

1Desktop fullscreen

Note that the SDL_WINDOW_FULLSCREEN is set if our window is running in either exclusive or desktop fullscreen. As such, the order of our if statements in the previous example is important - specifically the decision to check SDL_WINDOW_FULLSCREEN_DESKTOP before SDL_WINDOW_FULLSCREEN. In other words:

• in desktop fullscreen mode, both SDL_WINDOW_FULLSCREEN and SDL_WINDOW_FULLSCREEN_DESKTOP are set.
• in exclusive fullscreen mode, SDL_WINDOW_FULLSCREEN is set but SDL_WINDOW_FULLSCREEN_DESKTOP is not set.

Summary

In this lesson, we've learned how to implement fullscreen functionality using SDL. We covered both desktop and exclusive fullscreen modes, understanding their benefits and tradeoffs. Key takeaways:

• Use SDL_GetDisplayBounds() to match monitor dimensions
• Use desktop fullscreen - SDL_WINDOW_FULLSCREEN_DESKTOP - for easier multitasking
• Exclusive fullscreen - SDL_WINDOW_FULLSCREEN - may provide better performance
• SDL_SetWindowFullscreen() enables runtime mode changes
• Check window flags to determine current mode
• We can test and validate window operations with error checking

Next Lesson

Display Modes

Learn how to manage screen resolutions and refresh rates in SDL games using display modes.

ContinueView Course