Slide show with texture

In this section, we will examine a program that loads 5 image files with .png extensions into the main window in order with a slide show.

When the program runs, in addition to the basic operations, the following operations occur:

1. At the beginning of the program, the following global variables are defined:
   • unsigned int last_time: The last time variable that was processed
   • unsigned int current_time: The active time variable
   • int img_index: The index value variable of the loaded image file
2. With the init_vals() function, the value 0 is given to the last_time, current_time and img_index variables is assigned.
3. When the update_screen() function is run,
   • The active time value is taken with the SDL_GetTicks() function and assigned to the current_time variable.
   • If the current_time variable is greater than the sum of the last_time variable and 1000,
     • The current_time variable value is assigned to the last_time variable.
     • If the img_index variable value is equal to 4, it takes 0, otherwise its value is increased by one.
     • The image corresponding to the img_index value is loaded to the texture with the load_img() function.
     • The image sequence number is written to the main window title with the SDL_SetWindowTitle() function.
4. When the draw_screen() function is run,
   • The texture content is copied to the main window with the SDL_RenderTexture() function and the image is displayed in the main window.

The main.c file content will be as follows:

#include <stdio.h>
#include <SDL3/SDL.h>
#include <SDL3_image/SDL_image.h>

// Window width and height
#define WINDOW_WIDTH 640
#define WINDOW_HEIGHT 480

// Global variables
int is_running = false;           // Variable that controls the execution of the main loop of the program
SDL_Window *window = NULL;        // Main window variable
SDL_Texture *texture = NULL;      // Texture variable for image
SDL_Renderer *renderer = NULL;    // Renderer variable
unsigned int last_time;
unsigned int current_time;
int img_index;

// Function prototypes
int init_window(void);            // Create window and renderer
void init_vals(void);             // Initialize values
void load_img(void);              // Load image to texture
void process_event(void);         // Process events
void update_screen();             // Update values
void draw_screen(void);           // Draw screen
void destroy_window(void);        // Destroy window

int main(int argc, char* argv[])
{
    // Create window and renderer
    is_running = init_window();

    // Initialize values
    init_vals();

    // Load .png file to texture
    load_img();

    // Main loop
    while (is_running) {
        process_event();       // Processing SDL events (Here keyboard inputs).
        update_screen();       // Updating variables
        draw_screen();         // Drawing objects on the window (Rendering)
    }

    // Destroy renderer and SDL window
    destroy_window();

    return 0;
}

// Create window and renderer
int init_window(void)
{
    // Initialize the SDL library.
    if(SDL_Init(SDL_INIT_VIDEO) == false) {
       SDL_Log("SDL init error: %s\n", SDL_GetError());
       return false;
    }

    // Create a window and a 2D rendering context for the window.
    if(!SDL_CreateWindowAndRenderer("Load multi png images with texture for slide show - 1.image", WINDOW_WIDTH, WINDOW_HEIGHT, 0, &window, &renderer)) {
       return false;
    }

    return true;
}

// Initialization function that runs only once at the beginning of the program
void init_vals(void)
{
     last_time = 0;
     current_time = 0;
     img_index = 0;
}

// Load image to texture
void load_img(void)
{
	 char file_name[12];

	 switch (img_index) {
         case 0:
              strcpy(file_name, "sample1.png");
              break;
         case 1:
              strcpy(file_name, "sample2.png");
              break;
         case 2:
              strcpy(file_name, "sample3.png");
              break;
         case 3:
              strcpy(file_name, "sample4.png");
              break;
         case 4:
              strcpy(file_name, "sample5.png");
              break;
	 }

     // Load an image into a GPU texture.
     texture = IMG_LoadTexture(renderer, file_name);

	 if(texture == NULL)	{
	    SDL_Log("Load texture error: %s\n", SDL_GetError());
	 }
}

// Function to control SDL events and process keyboard inputs
void process_event(void)
{
     SDL_Event event;

     // Creating a loop to process user inputs
     while (SDL_PollEvent(&event)) {
        switch (event.type) {
            case SDL_EVENT_QUIT: // Logout action by the user (x button at the top right of the window)
                 is_running = false; // Terminates the execution of the program main loop.
                 break;

            case SDL_EVENT_KEY_DOWN: // Indicate that a key was pressed.
                 if(event.key.key==SDLK_ESCAPE) {
                    is_running = false;
                 }
                 break;
        }
     }
}

// Updates objects in the main window
void update_screen(void)
{
     current_time = SDL_GetTicks();

     if(current_time > last_time + 1000) {
        last_time = current_time;
        img_index = img_index==4 ? 0 : img_index+1;
        load_img();
        
        char cdizi[100];
        sprintf(cdizi, "Load multi png images with texture for slide show - %d.image", img_index+1);
        SDL_SetWindowTitle(window, cdizi);
     }
}

// Render function used to draw game objects in the main window
void draw_screen(void)
{
     SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255); // Set the color used for drawing operations.
     SDL_RenderClear(renderer); // Clear the current rendering target with the drawing color.

     SDL_FRect frect_dst = { (WINDOW_WIDTH-400)/2, (WINDOW_HEIGHT-300)/2, 400, 300 };
     // Copy texture to main window
	 SDL_RenderTexture(renderer, texture, NULL, &frect_dst);

     // Loading all objects drawn one by one to the back buffer to the front buffer at once and loading them onto the screen
     // This process prevents each drawn object from being displayed on the screen one by one.
     SDL_RenderPresent(renderer); // Update on screen all operations performed since the previous call
}

// Destroy Renderer and SDL window, exit from SDL3
void destroy_window(void)
{
     SDL_DestroyTexture(texture);
     SDL_DestroyRenderer(renderer);
     SDL_DestroyWindow(window);
     SDL_Quit();
}