Alpha blending

In this section, we will examine a program that loads one of the textures created from two .png image files into the background and the other into the foreground, and adjusts the transparency of the foreground texture with the up and down arrow keys.

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

1. At the beginning of the program, the following global variables are first defined:
   • SDL_Texture *texture_back: Background texture variable
   • SDL_Texture *texture_front: Foreground texture variable
   • int level_alpha: Alpha level variable
2. In init_vals() function, 255 is assigned to level_alpha variable.
3. In the load_img() function,
   • The background image file is loaded to the texture_back variable with the IMG_LoadTexture() function.
   • The foreground image file is loaded to the texture_front variable with the IMG_LoadTexture() function.
4. In the process_event() function, when the up and down arrow keys are pressed, the level_alpha variable value is increased or decreased by 5.
5. In the update_screen() function, the alpha level is written to the main window title with the SDL_SetWindowTitle() function.
6. In the draw_screen() function,
   • The background texture is transferred to the main window with the SDL_SetTextureBlendMode() function.
   • The foreground texture is set to the main is transferred to the window.
7. Since the default transparency value is 255, the background image is not visible at all. As the transparency value is decreased with the down arrow key, the foreground image becomes transparent and the background image begins to appear.

SDL_SetTextureBlendMode() function

The SDL_SetTextureBlendMode() function sets the blend mode on an SDL_Texture. The blend mode determines how an image will blend with another image or the background. This process affects how the images blend together and how they will appear.

bool SDL_SetTextureBlendMode(SDL_Texture *texture, SDL_BlendMode blendMode); 

SDL_SetTextureAlphaMod() function

The SDL_SetTextureAlphaMod() function sets an additional alpha value on an SDL_Texture. This alpha value is added to the source alpha value used in the rendering process and dynamically changes the opacity of the image.

bool SDL_SetTextureAlphaMod(SDL_Texture *texture, Uint8 alpha);

This function activates the specified color key and this color causes all pixels on the SDL_Surface to be considered transparent. For example, you can use this function to make a blue pixel transparent.

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;  // Texture variable for background image
SDL_Texture *texture_front = NULL; // Texture variable for foreground image
SDL_Renderer *renderer = NULL;     // Renderer variable
int level_alpha;                   // Alpha level variable

// 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("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_vals(void)
{
     level_alpha = 255;
}

// Load image to texture
void load_img(void)
{
     // Load image into a GPU texture.
     texture_back = IMG_LoadTexture(renderer, "image_back.png");

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

     // Load image into a GPU texture.
 	 texture_front = IMG_LoadTexture(renderer, "image_front.png");

	 if(texture_front == 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.
                 switch (event.key.key) {
                     case SDLK_UP:
                          if(level_alpha<255) level_alpha+=5;
                          break;
                     case SDLK_DOWN:
                          if(level_alpha>0) level_alpha-=5;
                          break;
                     case SDLK_ESCAPE:
                          is_running = false;
                          break;
                 }
                 break;
        }
     }
}

// Updates objects in the main window
void update_screen(void)
{
     char cdizi[40];

     sprintf(cdizi, "SDL3 window - Alpha level: %d", level_alpha);
     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.

     // Loading background texture
     SDL_RenderTexture(renderer, texture_back, NULL, NULL);

     // Set the blend mode for the texture
	 SDL_SetTextureBlendMode(texture_front, SDL_BLENDMODE_BLEND);
     // Set an additional alpha value multiplied into render copy operations.
	 SDL_SetTextureAlphaMod(texture_front, level_alpha);
     // Loading foreground texture
     SDL_RenderTexture(renderer, texture_front, NULL, NULL);

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