Texture clipping

In this section, we will examine a program that loads an image file with the extension .png into the main window piece by piece.

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 first defined:
   • bool clipped: Variable that determines the texture loading method
2. In the load_img() function, the image file is loaded into the texture variable with the IMG_LoadTexture() function.
3. In the process_event() function, when the C key is pressed, the clipped variable takes the opposite of its value.
4. In the draw_screen() function, if the clipped variable is true, each part of the texture, which is divided equally into four, is used in the SDL_RenderTexture() function, and corner, if false, the entire texture is loaded in the middle of the main window.

When the 'C' key is pressed, the image is placed in one piece in the middle of the window. When the 'C' key is pressed again, the window returns to its original state and so on.

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
SDL_Renderer *renderer = NULL;     // Renderer variable
bool clipped = true;               // Texture loading method 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 - Clipping textures", 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)
{

}

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

	 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.
                 switch (event.key.key) {
                     case SDLK_C:
                          clipped = !clipped;
                          break;
                     case SDLK_ESCAPE:
                          is_running = false;
                          break;
                 }
                 break;
        }
     }
}

// Updates objects in the main window
void update_screen(void)
{

}

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

     if(clipped) {
        // Top left of the image
        SDL_FRect rect_src = { 0, 0, 150, 110 };
        SDL_FRect rect_dst = { 0, 0, 150, 110 };
        SDL_RenderTexture(renderer, texture, &rect_src, &rect_dst);

        // Top right of the image
        rect_src.x = 150;
        rect_dst.x = WINDOW_WIDTH-150;
        SDL_RenderTexture(renderer, texture, &rect_src, &rect_dst);

        // Bottom left of the image
        rect_src.x = 0;
        rect_src.y = 110;
        rect_dst.x = 0;
        rect_dst.y = WINDOW_HEIGHT-110;
        SDL_RenderTexture(renderer, texture, &rect_src, &rect_dst);

        // Lower right of the image
        rect_src.x = 150;
        rect_dst.x = WINDOW_WIDTH-150;
        SDL_RenderTexture(renderer, texture, &rect_src, &rect_dst);
     }
     else {
        SDL_FRect rect_center = { (WINDOW_WIDTH-300)/2, (WINDOW_HEIGHT-220)/2, 300, 220 };
        SDL_RenderTexture(renderer, texture, NULL, &rect_center);
     }

     // 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();
}