SDL3 programming

Automatic animasyon

In this section, we will examine a program that automatically loads 8 different images of the same human drawing in different stages of walking into the window in order, which is created from a texture file with a .png extension.

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

At the beginning of the program, the following global variables are defined:
- SDL_Texture *texture_back: Background texture
- SDL_Texture *texture_front: Player texture
- unsigned int last_frame_time: Last frame time
- A variable named player is defined from the following structure data type:
```
struct players {
  float x;
  float y;
  float width;
  float height;
  float vel_x;
  float vel_y;
  intframe;
} player;
```
The init_vars() function initializes global variables.
In the load_img() function, a background image and an image for the player animation images are loaded into the texture variables with the IMG_LoadTexture() function.
In the process_event() function, the player.vel_x variable value is increased or decreased by 20 with the up and down arrow keys.
In the update_screen() function,
- The difference between the active time and the previous time of the loop is taken in seconds and assigned to the time_delta variable.
- The active time is taken with the SDL_GetTicks() function and assigned to the last_frame_time variable to be used in the next iteration of the loop.
- The product of player.vel_x and the loop iteration time (time_delta) is given to the move_x variable is assigned
- The player.x value is increased by the move_x value.
- If the sum of player.x and move_x is smaller than the main window width,
  - The move_x variable value is added to the player.x variable.
  - If the player x coordinate value is a multiple of 12, the player.frame value is 0 if it is equal to 7, otherwise it is one more than its own value.
- Otherwise, the player.x and player.frame variables are set to 0.
In the draw_screen() function,
- The texture_back value is copied to the main window with the SDL_RenderTexture() function.
- The image read from the texture_front value according to the player.frame variable value with the SDL_RenderTexture() function is copied to the main window according to the player.x and player.y variable coordinates.
- The x and y coordinates of the player variable and the frame index value and speed value are written to the main window title.

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_back = NULL;  // Background texture
SDL_Texture *texture_front = NULL; // Foreground texture
SDL_Renderer *renderer = NULL;     // Renderer variable
unsigned int last_frame_time;      // Last frame time

// Struct declaration
struct players {
  float x;
  float y;
  float width;
  float height;
  float vel_x;
  float vel_y;
  int frame;
} player;

// Function prototypes
int init_window(void);     // Create window and renderer
void init_vars(void);      // Initialize variables
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 variables
    init_vars();

    // 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("SDL3 window", 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_vars(void)
{
    last_frame_time = 0;

    player.x = 0;
    player.y = 310;
    player.width = 88;
    player.height = 110;
    player.vel_x = 100;
    player.vel_y = 100;
    player.frame = 0;
}

// Load image to texture
void load_img(void)
{
    // Loading image to background texture
 	texture_back = IMG_LoadTexture(renderer, "background.png");

	if(texture_back == NULL) {
       SDL_Log("IMG_LoadTexture error: %s\n", SDL_GetError());
	}
    
	// Loading player images 
	texture_front = IMG_LoadTexture(renderer, "player.png");

	if(texture_front == NULL) {
       SDL_Log("IMG_LoadTexture 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: // Key pressed.
               switch(event.key.key) {
                  case SDLK_UP: if(player.vel_x<1000) player.vel_x += 20; break;
                  case SDLK_DOWN: if(player.vel_x>0) player.vel_x -= 20; break;

                  case SDLK_ESCAPE: is_running = false; break;
               }
               break;
       }
    }
}
// Updates objects in the main window
void update_screen(void)
{
    // Get the difference between the active time and the previous time of loop in seconds
    float time_delta = (SDL_GetTicks() - last_frame_time) / 1000.0;
    // Assign the active time to use in the next iteration of the loop
    last_frame_time = SDL_GetTicks();

    // Calculate moving size
    // player.vel_x assigned to move_x variable.
    float move_x = player.vel_x * time_delta;

    // If player.x plus move_x, player.x increased by move_x
    if(player.x + move_x < WINDOW_WIDTH) {
	   player.x += move_x;
       if((int)player.x%12==0) {
          player.frame = player.frame==7 ? 0 : player.frame+1;
       }
    }
    else {
       player.x = 0;
       player.frame = 0;
    }
}

// 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_RenderTexture(renderer, texture_back, NULL, NULL);

    SDL_FRect frect_src = { player.frame*player.width, 0, player.width, player.height };
    SDL_FRect frect_dst = { (int) player.x, (int) player.y, (int) player.width, (int) player.height };

    SDL_RenderTexture(renderer, texture_front, &frect_src, &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

    char cdizi[100];
    sprintf(cdizi, "x: %d y: %d Frame: %d Speed: %.2f", (int) player.x, (int) player.y, player.frame, player.vel_x);
    SDL_SetWindowTitle(window, cdizi);
}

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