SDL / A pantalla completa

Bienvenidos sean a este post, en este post nos centraremos en una de las caracteristicas que nos brinda SDL_CreateWindow.

Hasta ahora siempre que trabajamos con la funcion que se encarga de crear la ventana no solo definiamos su ancho y su alto, sino tambien mencionamos que el ultimo parametro es una de serie de constantes que podemos usar para definir ciertos aspectos, veamos la siguiente tabla:

Constante	Proposito
SDL_WINDOW_FULLSCREEN	Habilita la pantalla completa
SDL_WINDOW_OPENGL	Habilita a la ventana para ser usada en un contexto de OpenGL
SDL_WINDOW_SHOWN	Hace visible a la ventana
SDL_WINDOW_HIDDEN	Esconde la ventana
SDL_WINDOW_BORDERLESS	Elimina los bordes de la ventana
SDL_WINDOW_RESIZABLE	Permite modificar el tamaño de la ventana
SDL_WINDOW_MINIMIZED	Minimiza la ventana
SDL_WINDOW_MAXIMIZED	Maximiza la ventana
SDL_WINDOW_INPUT_GRABBED	La ventana captura la entrada que esta en foco
SDL_WINDOW_INPUT_FOCUS	La ventana se centra en una entrada
SDL_WINDOW_MOUSE_FOCUS	La ventana se centra en el mouse
SDL_WINDOW_FOREIGN	Cuando la ventana no es creada con SDL

Como pueden ver tenemos una buena variedad de posibilidades, entre ellas tenemos la que hemos usado todo este tiempo (SDL_WINDOW_OPENGL), otras que nos pueden ser muy utiles ya sean para hacer el uso de toda la pantalla, maximizarla (que no es lo msmo), minimizarla o eliminar los bordes, pero vamos a centrarnos en el tema de habilitar la pantalla completa. Para ello, vamos a ver el codigo del proyecto del post anterior y vamos a hacer un par de modificaciones. Si no lo poseen les comparto un link para descargarlo:

Proyecto Juego

Este proyecto no va a funcionar directamente porque el SDL esta implementado para mi equipo. Para corregirlo, les recomiendo, primero quitar al proyecto y luego visitar este post. En este tenemos todos los pasos para repetir o modificar la implementacion de este. Una vez todo modificado y funcionando, lo primero que debemos hacer es ir a Juego.h y modificaremos este prototipo en la clase Juego:

bool iniciar(const char*, int, int, int);

De la siguiente manera:

bool iniciar(const char*, int, int, bool);

Si observan modificamos el ultimo parametro para que ahora sea de tipo bool, booleano, y nuestra siguiente modificacion sera en Juego.cpp donde cambiaremos el inicio de la definicion de la funcion iniciar:

bool Juego::iniciar(const char* titulo, int ancho, int alto, int flags)

De la siguiente manera:

bool Juego::iniciar(const char* titulo, int ancho, int alto, bool pantallaCompleta)

Con esto coincidimos al prototipo con su definicion, nuestra siguiente modificacion sera agregar el siguiente bloque antes del condicional donde verifica si se inicio SDL:

	int flags = 0;
	if (pantallaCompleta)
		flags = SDL_WINDOW_FULLSCREEN;

En este caso primero creamos una variable de tipo int llamada flags, recuerden que desaparecio de los argumentos de la funcion, luego tenemos un condicional donde verifica si el valor de pantallaCompleta es true. En caso de ser verdadero, le asignamos la constante SDL_WINDOW_FULLSCREEN a flags, para que la pase a la funcion SDL_CreateWindow, veamos como quedo nuestra nueva funcion:

bool Juego::iniciar(const char* titulo, int ancho, int alto, bool pantallaCompleta) {
    int flags = 0;
    if (pantallaCompleta)
        flags = SDL_WINDOW_FULLSCREEN;

    if (SDL_Init(SDL_INIT_EVENTS) != 0) {
        OutputDebugStringA("SDL_Init iniciado\n");
        m_pVentana = SDL_CreateWindow(titulo, ancho, alto, flags);

        if (m_pVentana != 0) {
            OutputDebugStringA("Ventana Creada\n");
            m_pRenderer = SDL_CreateRenderer(m_pVentana, NULL);
            if (m_pRenderer != 0) {
                OutputDebugStringA("Render Exitoso\n");
                SDL_SetRenderDrawColor(m_pRenderer, 255, 255, 255, 255);
            }
            else {
                OutputDebugStringA("Render Fallido\n");
                return false;
            }
        }
        else {
            OutputDebugStringA("Ventana no Creada\n");
            return false;
        }
    }
    else {
        OutputDebugStringA("Inicio Fallido\n");
        return false;
    }

    OutputDebugStringA("Inicio Exitoso\n");
    m_bCorriendo = true;
    return true;
}

Pero esto no termina aca, vamos a realizar una modificacion mas en Juego.cpp, para ello buscaremos a la funcion renderizar:

void Juego::renderizar() {
    SDL_RenderClear(m_pRenderer);
    SDL_RenderPresent(m_pRenderer);
}

Y la vamos a modificar de la siguiente manera:

void Juego::renderizar() {
    const char* mensaje = "Hola Mundo!";
    const float scale = 4.0f;
    int w = 0, h = 0;
    float x, y;

    SDL_GetRenderOutputSize(m_pRenderer, &w, &h);
    SDL_SetRenderScale(m_pRenderer, scale, scale);
    x=((w / scale) - SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE * SDL_strlen(mensaje)) / 2;
    y=((h / scale) - SDL_DEBUG_TEXT_FONT_CHARACTER_SIZE) / 2;

    SDL_SetRenderDrawColor(m_pRenderer, 0, 0, 0, 255);
    SDL_RenderClear(m_pRenderer);
    SDL_SetRenderDrawColor(m_pRenderer, 255, 255, 255, 255);
    SDL_RenderDebugText(m_pRenderer, x, y, mensaje);
    SDL_RenderPresent(m_pRenderer);
}

Esta rutina la vimos en este post, donde las primeras lineas seran para almacenar la ubicacion de un texto y el texto a mostrar en la seccion de renderizado. La segunda parte se encarga de obtener la informacion, y calcular lo necesario para almacenarlo en las variables anteriores y por ultimo, hacemos todo el renderizado para cambiar la ventana a un fondo negro y mostrar el mensaje de color blanco. Ahora solo nos resta ir al main.cpp donde modificaremos la linea encargada de crear la ventana. Veamos la original:

g_juego->iniciar("Juego", 320, 240, SDL_WINDOW_OPENGL);

Esta linea la modificaremos de la siguiente forma:

g_juego->iniciar("Juego", 320, 240, true);

Sacamos el valor de cero y le pasamos el true para que realice la ejecucion de la pantalla completa, con todas estas modificaciones podemos pasar a compilarlo y verificar su funcionamiento como se ve en el siguiente video

Como trabajo con una PC Virtual al pasar el juego a Pantalla completa y como definimos que el tamaño del juego es de 320 x 240, ajusta la pantalla de la virtual a ese tamaño, esa es la diferencia entre usar la pantalla completa y la opcion de maximizar. Dado que maximizar se hubiera ajustado a la resolucion del escritorio.

En resumen, hoy hemos visto como trabajar con las constantes que nos permiten establecer otras conductas para nuestras ventanas, hemos visto algunas de las que tenemos disponibles, hemos explicado las mismas, hemos modificado nuestro proyecto anterior con minimos cambios para poder implementarlo, tambien lo hemos probado y hemos podido verificar porque es mas practico hacerlo asi y no usar la opcion maximizar. Espero les haya sido de utilidad y les dejo un link a GitHub donde estan los codigos creados hoy:

A Pantalla Completa / GitHub

Les dejo algunas de mis redes sociales para seguirme o recibir una notificacion cada vez que subo un nuevo post: