SDL3 programming

Particle operations

In this section, we will examine a program that moves a ball in the main window with the arrow keys using a texture created from a .png image file, and creates particles that are randomly selected in four different colors and move continuously around the ball.

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

At the beginning of the program, the following global variables are defined:
- SDL_Texture *texture_ball: Texture for the ball
- SDL_Texture *texture_particles: Particle texture
- unsigned int last_frame_time: Last frame time
- int move_size: Motion size
- int total_particles: Total particle count
- int particle_size: Particle size
- A variable named ball is defined with the following structure data type:
```
struct objects {
  float x;
  float y;
  float width;
  float height;
  float vel_x;
  float vel_y;
} ball;
```
- An array named particles is defined from the following structure data type:
```
struct particle {
  float x;
  float y;
  int frame;
  int texture;
} particles[20];
```
In the init_vars() function,
- Global variables are assigned initial values.
- For each particle, set_particle_vals() is called and initial values are assigned.
In the load_img() function, the image files for the ball and particle are loaded into the texture variables with the IMG_LoadTexture() function.
In the process_event() function,
- When the arrow keys are pressed, the movement size variable value called move_size in the direction indicated by the arrow is added to the ball.vel_x or ball.vel_y variable, which has a value of 0. Thus, movement is achieved.
- When the arrow keys are released, the movement size variable value called move_size in the direction indicated by the arrow is subtracted from the ball.vel_x or ball.vel_y variables, and the value of these variables is equalized to 0. This ends the movement.
In 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 retrieved 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 ball.vel_x and the loop iteration time (time_delta) is assigned to the move_x variable.
- The value of ball.x is incremented by the value of move_x.
- If ball.x is less than 0 or the sum of ball.x and ball.width is greater than the width of the window, ball.x takes its previous value.
- The product of ball.vel_y and the loop iteration time (time_delta) is assigned to the move_y variable.
- The ball.y value is increased by the move_y value.
- If ball.y is less than 0 or the sum of ball.y and ball.height is greater than the height of the window, ball.y takes its previous value.
- The ball's coordinate and speed information is written to the main window title.
- For particles array values whose frame variable value is greater than 10, the set_particle_vals() function is called again.
In the draw_screen() function,
- The ball is displayed in its position in the main window with the SDL_RenderTexture() function.
- The particles images are loaded into the main window with the render_particles() function.

main.c file content will be as follows:


#include <stdio.h>
#include <stdlib.h>
#include <time.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_ball = NULL;      // Texture ball
SDL_Texture *texture_particles = NULL; // Texture particle
SDL_Renderer *renderer = NULL;         // Renderer variable

unsigned int last_frame_time;          // Last frame time
int move_size;                         // Movement size
int total_particles;                   // Number of total particles
int particle_size;                     // Particle size

// Struct declaration
struct objects {
  float x;
  float y;
  float width;
  float height;
  float vel_x;
  float vel_y;
} ball;

struct particle {
  float x;
  float y;
  int frame;
  int texture;
} particles[20];

// 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

void set_particle_vals(int par_ind); // Set particles values
void render_particles(void);         // Render particles

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;
    }

    // SDL_SetRenderVSync(renderer, 1);

    return true;
}

// Initialization function that runs only once at the beginning of the program
void init_vars(void)
{
    last_frame_time = 0;
    move_size = 400;
    total_particles = 20;
    particle_size = 5;

    ball.x = 0;
    ball.y = 0;
    ball.width = 20;
    ball.height = 20;
    ball.vel_x = 0;
    ball.vel_y = 0;

    // Initialize particles
    for(int id=0; id<total_particles; id++) {
        set_particle_vals(id);
    }
}

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

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

    // Loading particles image to texture
	texture_particles = IMG_LoadTexture(renderer, "particles.png");

	if(texture_particles == 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.
               if(event.key.repeat == 0) {
                  switch(event.key.key) {
                     case SDLK_UP: ball.vel_y -= move_size; break;
                     case SDLK_DOWN: ball.vel_y += move_size; break;
                     case SDLK_LEFT: ball.vel_x -= move_size; break;
                     case SDLK_RIGHT: ball.vel_x += move_size; break;
                     case SDLK_ESCAPE: is_running = false; break;
                  }
               }
               break;

          case SDL_EVENT_KEY_UP: // Key released.
               if(event.key.repeat == 0) {
                  switch(event.key.key) {
                     case SDLK_UP: ball.vel_y += move_size; break;
                     case SDLK_DOWN: ball.vel_y -= move_size; break;
                     case SDLK_LEFT: ball.vel_x += move_size; break;
                     case SDLK_RIGHT: ball.vel_x -= move_size; 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
    // Multiplication of ball.vel_x and the loop repeat time (delta time),
    // otherwise ball.vel_x assigned to move_x variable.
    float move_x = ball.vel_x * time_delta;

    // Ball x coordinate increased by move_x
    ball.x += move_x;
    // If ball.x is lower than 0 or, sum of ball.x and ball.width is greater than windows width
    // ball.x gets its previous value.
    if((ball.x<0) || (ball.x + ball.width > WINDOW_WIDTH)) {
	   ball.x -= move_x;
    }

    // Multiplication of ball.vel_y and the loop repeat time (delta time),
    // otherwise ball.vel_y assigned to move_y variable.
    float move_y = ball.vel_y * time_delta;

    // Ball y coordinate increased by move_y
    ball.y += move_y;
    // If ball.yx is lower than 0 or, sum of ball.y and ball.height is greater than windows height
    // ball.y gets its previous value.
    if((ball.y<0) || (ball.y + ball.height > WINDOW_HEIGHT)) {
       ball.y -= move_y;
    }

    char cdizi[100];
    sprintf(cdizi, "ball.x: %.2f ball.y: %.2f ball.vel_x: %.2f ball.vel_y: %.2f",
                    ball.x, ball.y, ball.vel_x, ball.vel_y);
    SDL_SetWindowTitle(window, cdizi);

    // Reset particles
    for(int id=0; id<total_particles; id++) {
        if(particles[id].frame>10) {
           set_particle_vals(id);
        }
    }
}

// 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 = { ball.x, ball.y, 20, 20 };
	SDL_RenderTexture(renderer, texture_ball, NULL, &frect_dst);

    render_particles();

    // 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_ball);
    SDL_DestroyTexture(texture_particles);
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();
}

void set_particle_vals(int par_ind)
{
    // Set offsets
    particles[par_ind].x = ball.x - particle_size + (rand() % 25);
    particles[par_ind].y = ball.y - particle_size + (rand() % 25);

    // Initialize animation
    particles[par_ind].frame = rand() % particle_size;

    // Set type
    switch(rand() % 3) {
       case 0: particles[par_ind].texture = 0; break; // Red
       case 1: particles[par_ind].texture = 1; break; // Green
       case 2: particles[par_ind].texture = 2; break; // Blue
    }
}

void render_particles(void)
{
    // Show particles
    for(int id=0; id<total_particles; id++) {
        SDL_FRect frect_src = { 0, particles[id].texture*particle_size, particle_size, particle_size };
        SDL_FRect frect_dst = { particles[id].x, particles[id].y, particle_size, particle_size };
        SDL_RenderTexture(renderer, texture_particles, &frect_src, &frect_dst);

        if(particles[id].frame % 2 == 0) {
           frect_src.y = 3*particle_size;
           SDL_RenderTexture(renderer, texture_particles, &frect_src, &frect_dst);
        }

        // Animate
        particles[id].frame++;
    }
}