diff --git a/Makefile b/Makefile
index 95d19433f1faa8bdec120bf2f1227f6e09c0a5bb..378f29ee876faaf93c6d7d069e0fb5323777d05c 100644
--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,5 @@
 CFLAGS = -O3 -Dmain=SDL_main
-LDFLAGS = -lm -lmingw32 -lSDL2main -lSDL2 -lSDL2_ttf
+LDFLAGS = -lm -lmingw32 -lSDL2main -lSDL2 -lSDL2_ttf -lSDL2_image
 SDL2_INCLUDE_DIR = src/include
 SDL2_LIBRARIES_DIR = src/lib
 
diff --git a/SDL2_image.dll b/SDL2_image.dll
new file mode 100644
index 0000000000000000000000000000000000000000..98566828863cbb98cfd58378dfc0bb9697936eb0
Binary files /dev/null and b/SDL2_image.dll differ
diff --git a/constante.c b/constante.c
index b82d014a6035146ea7a6fba5e602fdddb196da3a..496dcc5dcdc2cdefb1e8787ee635525bb4582b05 100644
--- a/constante.c
+++ b/constante.c
@@ -22,6 +22,7 @@
 
 #define METEORITE_SIZE 32
 
+#define METEORITE_REAL_SIZE 34
 
 /**
  * \brief Hauteur de la ligne d'arrivée
@@ -42,4 +43,16 @@
   * \brief Vitesse initiale de déplacement vertical des éléments du jeu 
 */
 
-#define INITIAL_SPEED 2
\ No newline at end of file
+#define INITIAL_SPEED 2
+
+/**
+ * \brief Nombre de lignes de météorites
+ * 
+ */
+#define MAX_LINES 500
+
+/**
+ * \brief Nombre maximum de météorite par ligne
+ * 
+ */
+#define MAX_LENGTH 28
\ No newline at end of file
diff --git a/library/Display/Display.c b/library/Display/Display.c
index b4476b4c109b8af55ef852ae36a13cc074cfa415..5a97076ff4d4121eefa8933320e1bfd886099a04 100644
--- a/library/Display/Display.c
+++ b/library/Display/Display.c
@@ -4,26 +4,37 @@
 #include <math.h>
 
 void init_ressource(SDL_Renderer *renderer, ressources_t *textures){
-    textures->background = load_image( "ressources/Elements/background2.bmp",renderer);
     textures->bmenu = load_image( "ressources/image-menu.bmp",renderer);
     textures->ship = load_image( "ressources/spaceship.bmp",renderer);
+    textures->background = load_image( "ressources/Elements/backgrounds/1.png",renderer);
+    textures->background2 = load_image( "ressources/Elements/backgrounds/3.png",renderer);
+    textures->background3 = load_image( "ressources/Elements/backgrounds/2.png",renderer);
+    textures->ship = load_image( "ressources/Elements/Ship_1.png",renderer);
     
     textures->finishLine = load_image( "ressources/finish_line.bmp",renderer);
     textures->font = load_font("ressources/font/arial.ttf", 14);
     textures->color = (SDL_Color){255, 255, 255, 255};
 
+    textures->BarreProgression = load_image( "ressources/Elements/BarreProgression.png",renderer);
+    textures->vaisseauMini = textures->ship;
+
+    textures->soleilBarre = load_image( "ressources/Elements/soleil.png",renderer);
+    textures->soleil = load_image( "ressources/Elements/soleil.png",renderer);
+    textures->nb_init = 9;
     init_ressource_element(renderer, textures);
+    
 }
 
 void init_ressource_element(SDL_Renderer *renderer, ressources_t *textures){
     textures->meteorite = load_image( "ressources/meteorite.bmp",renderer);
     textures->e_rotate = load_image("ressources/Elements/reverse.bmp", renderer);
+    textures->coins = load_image("ressources/Elements/coin.png", renderer);
+    textures->nb_init += 3;
 }
 
-void apply_background(SDL_Renderer *renderer, SDL_Texture *texture, world_t *world){
+void apply_background(SDL_Renderer *renderer, SDL_Texture *texture, world_t *world, int parallax){
     if(texture != NULL){
-        //printf("%f %f\n", (SCREEN_WIDTH/2+(0-SCREEN_WIDTH/2)*cos(angle)-(0-SCREEN_HEIGHT/2)*sin(angle)), (SCREEN_HEIGHT/2+(0-SCREEN_WIDTH/2)*sin(angle)+(0-SCREEN_HEIGHT/2)*cos(angle)));
-      apply_texture(texture, renderer, 0, 0, world->angle*180/M_PI);
+        apply_texture(texture, renderer, 0, -1800+world->parallax/parallax, world->angle*180/M_PI);
     }
 }
 
@@ -40,6 +51,19 @@ void apply_sprite(SDL_Renderer * renderer, SDL_Texture *texture, sprite_t *sprit
     }
 }
 
+void apply_sprite_fixed(SDL_Renderer * renderer, SDL_Texture *texture, sprite_t *sprite, world_t *world){
+    if(texture != NULL){
+        SDL_Rect rect;
+        rect.x = sprite->x;
+        rect.y = sprite->y;
+
+        rect.w = sprite->w;
+        rect.h = sprite->h;
+
+        SDL_RenderCopyEx(renderer, texture, NULL, &rect, world->angle*180/M_PI, NULL, SDL_FLIP_NONE);
+    }
+}
+
 void apply_wall(SDL_Renderer * renderer, SDL_Texture *texture, int x, int y,world_t *world){
     if(texture != NULL){
         SDL_Rect rect;
@@ -47,7 +71,6 @@ void apply_wall(SDL_Renderer * renderer, SDL_Texture *texture, int x, int y,worl
         rect.y = SCREEN_HEIGHT/2 + (x - SCREEN_WIDTH/2) * sin(world->angle) + (y - SCREEN_HEIGHT/2) * cos(world->angle);
         rect.w = METEORITE_SIZE;
         rect.h = METEORITE_SIZE;
-        
         if (SDL_RenderCopyEx(renderer, texture, NULL, &rect, world->angle*180/M_PI, NULL, SDL_FLIP_NONE) != 0){
             printf("ok\n");
         }
@@ -62,18 +85,22 @@ void apply_walls(SDL_Renderer * renderer, SDL_Texture *texture, world_t *world,
                     apply_wall(renderer, res->meteorite, world->murs[i]->x+i3*METEORITE_SIZE, world->murs[i]->y+i2*METEORITE_SIZE, world);
                 }else if(strcmp(world->murs[i]->id, "2") == 0){
                     apply_wall(renderer, res->e_rotate, world->murs[i]->x+i3*METEORITE_SIZE, world->murs[i]->y+i2*METEORITE_SIZE, world);
+                }else if(strcmp(world->murs[i]->id, "3") == 0){
+                    apply_wall(renderer, res->coins, world->murs[i]->x+i3*METEORITE_SIZE, world->murs[i]->y+i2*METEORITE_SIZE, world);
                 }
             }
         }
     }
 }
 
-
 void refresh_graphics(SDL_Renderer *renderer, world_t *world,ressources_t *textures){
     //on vide le renderer
     clear_renderer(renderer);
     
-    
+    //application des textures dans le renderer
+    apply_background(renderer, textures->background, world, 7);
+    apply_background(renderer, textures->background2, world, 3);
+    apply_background(renderer, textures->background3, world, 9);
 
     if (world->isMenu == 0){
         ingame(renderer,world,textures);
@@ -88,24 +115,25 @@ void inmenu(SDL_Renderer *renderer, world_t *world,ressources_t *textures){
     apply_background(renderer, textures->bmenu, world);
 }
 void ingame(SDL_Renderer *renderer, world_t *world,ressources_t *textures){
-    apply_background(renderer, textures->background, world);//application des textures dans le renderer
+    if (world->ismenu == 0){
+        apply_background(renderer, textures->background, world);//application des textures dans le renderer
         apply_sprite(renderer, textures->ship, world->vaisseau, world);
         apply_sprite(renderer, textures->finishLine, world->ligneArriver, world);
         apply_walls(renderer, textures->meteorite, world, textures);
-
-        if (timer_update_s(world) != 0){
-            world->str[0] = '\0';
-            world->str = strcats(world->str, 3, "temps: ",int_to_str((int)world->timer/1000), "s");
-        }
+        apply_sprite(renderer, textures->soleil, world->soleil, world);
         apply_text(renderer, 10, 10, 100, 33, world->str, textures->font, textures->color); 
-
-}
-
-int timer_update_s(world_t *world){
-    if (world->timer%1000 <=  110|| world->timer%1000 >= 985){
-        return world->timer%1000;
+        apply_text(renderer, SCREEN_WIDTH-(60+10*number_of_numbers(world->money)), 10, 15*number_of_numbers(world->money), 30, world->coins_str, textures->font, textures->color);
+        apply_sprite_fixed(renderer, textures->BarreProgression, world->BarreProgression, world);
+        apply_sprite_fixed(renderer, textures->vaisseauMini, world->vaisseauMini, world);
+        apply_sprite_fixed(renderer, textures->soleilBarre, world->soleilBarre, world);
+        apply_sprite_fixed(renderer, textures->coins, world->coins, world);
+        
+    }else{
+        apply_text(renderer, 10, 10, 100, 33, "Menu", textures->font, textures->color);
+        printf("aaa");
     }
-    return 0;
+    
+    update_screen(renderer);
 }
 
 void clean(SDL_Window *window, SDL_Renderer * renderer, ressources_t *textures, world_t * world){
diff --git a/library/Display/Display.h b/library/Display/Display.h
index dff9deb9a4afcae81b945062841e32550f6347e2..29d858f3584c7beebfba97eddc55bae64a5829e7 100644
--- a/library/Display/Display.h
+++ b/library/Display/Display.h
@@ -35,13 +35,24 @@
 struct ressources_s{
     SDL_Texture* background; /*!< Texture liée à l'image du fond de l'écran. */
     SDL_Texture* bmenu;/*!< Texture liée à l'image du fond du menu. */
+    SDL_Texture* background2; /*!< Texture liée à l'image du fond de l'écran. (effet parallax) */
+    SDL_Texture* background3; /*!< Texture liée à l'image du fond de l'écran. (effet parallax) */
     SDL_Texture* ship; /*!< Texture liée à l'image du vaisseau. */
+
     SDL_Texture* meteorite; /*!< Texture liée à l'image du météorite. */
     SDL_Texture* e_rotate; /*!< Texture liée à l'image de l'élément de rotation. */
+    SDL_Texture* coins; /*!< Texture liée à l'image des pièces. */
     SDL_Texture* finishLine; /*!< Texture liée à l'image de la ligne d'arrivée. */
+    SDL_Texture* BarreProgression; /*!< Texture liée à l'image de l'air. */
+    SDL_Texture* vaisseauMini; /*!< Texture liée à l'image du vaisseau. */
+
+    SDL_Texture* soleilBarre; /*!< Texture liée à l'image du soleil. */
+    SDL_Texture* soleil; /*!< Texture liée à l'image du soleil. */
+
     TTF_Font *font; // Font
     SDL_Color color; // Color
     long double angle; /*!< Angle de rotation de l'image. */
+    int nb_init; /*!< Nombre d'initialisation. */
 };
 
 typedef struct ressources_s ressources_t;
@@ -67,10 +78,10 @@ void init_ressource_element(SDL_Renderer *renderer, ressources_t *textures);
  * \param renderer le renderer
  * \param texture la texture liée au fond
 */
-void apply_background(SDL_Renderer *renderer, SDL_Texture *texture, world_t *world);
+void apply_background(SDL_Renderer *renderer, SDL_Texture *texture, world_t *world, int parallax);
 
 /**
- * \brief La fonction qui applique la texture \a texture sur le renderer \a renderer en fonction des données du sprite \a sprite
+ * \brief La fonction qui applique la texture \a texture sur le renderer \a renderer en fonction des données du sprite \a sprite (avec rotation)
  * 
  * \param texture
  * \param renderer 
@@ -78,6 +89,15 @@ void apply_background(SDL_Renderer *renderer, SDL_Texture *texture, world_t *wor
  */
 void apply_sprite(SDL_Renderer * renderer, SDL_Texture *texture, sprite_t *sprite, world_t *world);
 
+/**
+ * @brief La fonction qui applique la texture \a texture sur le renderer \a renderer en fonction des données du sprite \a sprite (sans rotation)
+ * 
+ * @param renderer 
+ * @param texture 
+ * @param sprite 
+ * @param world 
+ */
+void apply_sprite_fixed(SDL_Renderer * renderer, SDL_Texture *texture, sprite_t *sprite, world_t *world);
 /**
  * \brief La fonction qui applique la texture \a texture sur le renderer \a renderer en fonction des coordonnées \a x et \a y
  * 
@@ -121,14 +141,6 @@ void clean_textures(ressources_t *textures);
 */
 void clean(SDL_Window *window, SDL_Renderer * renderer, ressources_t *textures, world_t * world);
 
-/**
- * \brief La fonction qui affiche le temps restant sur l'écran
- * 
- * \param world 
- * \return int 
- */
-int timer_update_s(world_t *world);
-
 void ingame(SDL_Renderer *renderer, world_t *world,ressources_t *textures);
 
 void inmenu(SDL_Renderer *renderer, world_t *world,ressources_t *textures);
diff --git a/library/Display/Display.o b/library/Display/Display.o
index 9b226f40de633a9cf10e3effc1e611b310319f67..c04feae259ff2f07116c47263f6dc1fff53a8a8d 100644
Binary files a/library/Display/Display.o and b/library/Display/Display.o differ
diff --git a/library/Sprites/sprites.c b/library/Sprites/sprites.c
index d67d4f56e46892f7bb6115fd89461616bb2275a9..c7e81706a2b7a851a349101f2d90677263c84d9f 100644
--- a/library/Sprites/sprites.c
+++ b/library/Sprites/sprites.c
@@ -13,15 +13,16 @@ void print_sprite(sprite_t *sprite){
 }
 
 
-sprite_t *init_sprite(sprite_t *sprite, int x, int y, int w, int h, char id){
+sprite_t *init_sprite(sprite_t *sprite, int x, int y, int w, int h, char id, int indice){
     sprite = malloc(sizeof(sprite_t));
     sprite->x = x;
     sprite->y = y;
     sprite->w = w;
     sprite->h = h;
     sprite->id = malloc(sizeof(char) * 10);
+    sprite->dy = 0.0;
     strcpy(sprite->id, &id);
-
+    sprite->indice = indice;
     return sprite;
 }
 
diff --git a/library/Sprites/sprites.h b/library/Sprites/sprites.h
index 3436a48d94baba387e6fb17b80b0d4e195947f76..229ba63824fac19852759f4b444bace98ae35264 100644
--- a/library/Sprites/sprites.h
+++ b/library/Sprites/sprites.h
@@ -28,7 +28,9 @@ struct sprite_s{
     int y;
     int w;
     int h;
+    float dy;
     char * id;
+    int indice;
 };
 
 typedef struct sprite_s sprite_t;
@@ -58,7 +60,7 @@ void print_sprite(sprite_t *sprite);
  * \param h 
  * \return sprite_t* 
  */
-sprite_t *init_sprite(sprite_t *sprite, int x, int y, int w, int h, char id);
+sprite_t *init_sprite(sprite_t *sprite, int x, int y, int w, int h, char id, int indice);
 
 /**
  * \brief La fonction indique si les sprites se touchent
diff --git a/library/Sprites/sprites.o b/library/Sprites/sprites.o
index 46ee4bbdcc1413870abfd802be54e04b3c974c27..b52ea3ebefe689154a5a3a0a5f5135bf17bea7df 100644
Binary files a/library/Sprites/sprites.o and b/library/Sprites/sprites.o differ
diff --git a/library/World/world.c b/library/World/world.c
index 248a4fdde2f13d9b081b75c52074c2a3dafb4b8a..c1687ac580067b7b499fb6b14c533bcfb2d47f15 100644
--- a/library/World/world.c
+++ b/library/World/world.c
@@ -32,21 +32,91 @@ void init_data(world_t * world){
     //on n'est pas à la fin du jeu
     world->gameover = 0;
     world->speed_h = (float)INITIAL_SPEED;
-    // Initialisation du vaisseau
-    world->vaisseau = init_sprite(world->vaisseau, SCREEN_WIDTH/2 - SHIP_SIZE/2, SCREEN_HEIGHT - SHIP_SIZE, SHIP_SIZE, SHIP_SIZE, '0');
     init_walls(world);
     world->ligneArriver = init_sprite(world->ligneArriver, 0, -world->nb_lines_murs*METEORITE_SIZE-30 , SCREEN_WIDTH, FINISH_LINE_HEIGHT, 'z');
     InitMenu(world);
     print_sprite(world->vaisseau);
+    // Initialisation du vaisseau
+    world->vaisseau = init_sprite(world->vaisseau, SCREEN_WIDTH/2 - SHIP_SIZE/2, SCREEN_HEIGHT - SHIP_SIZE-15, SHIP_SIZE, SHIP_SIZE, '0', 0);
+    world->ligneArriver = init_sprite(world->ligneArriver, 0, -world->nb_lines_murs*METEORITE_REAL_SIZE-30 , SCREEN_WIDTH, FINISH_LINE_HEIGHT, 'z', 0);
+    world->BarreProgression = init_sprite(world->BarreProgression, 10, SCREEN_HEIGHT - 500, 50, 400, 'y', 0);
+    world->vaisseauMini = init_sprite(world->vaisseauMini, 10, SCREEN_HEIGHT - 130, 20, 20, 'x', 0);
+    world->soleilBarre = init_sprite(world->soleilBarre, 0, SCREEN_HEIGHT - 510, 40, 40, 'x', 0);
+    world->soleil = init_sprite(world->soleil, SCREEN_WIDTH/2-1800/2, -world->nb_lines_murs*METEORITE_REAL_SIZE-1400, 1800, 1800, 'z', 0);
+    world->air = init_sprite(world->air, -2000, -2000, 0, 0, 'x', 0);
+    world->coins = init_sprite(world->coins, SCREEN_WIDTH-40, 10, 30, 30, 'x', 0);
+
+    world->vaisseauMini->y = SCREEN_HEIGHT - (110);
+    world->vaisseauMini->dy = SCREEN_HEIGHT - (110);
     world->startTimer = SDL_GetTicks();
     world->timer = SDL_GetTicks();
-    world->str = malloc(sizeof(char)*100);
+    world->str = malloc(sizeof(char)*100); // Allocation de la mémoire pour le string temps
+
+
+    world->coins_str = malloc(sizeof(char)*100); // Allocation de la mémoire pour le string coins
+    world->coins_str[0] = '\0';
+    world->coins_str = strcats(world->coins_str, 1, "0");
+
     world->angle = 0.0;
     world->isFlipping = 0;
     world->isMenu = 1;
 
     world->mouseX = 0;
     world->mouseY = 0;
+    world->isMenu = false; 
+    world->money = 0;
+    world->parallax = 0;
+    world->invicibility = false;
+}
+
+void update_data(world_t *world){
+    if (!world->isMenu){
+        world->ligneArriver->y += (int)world->speed_h;
+        world->soleil->y += (int)world->speed_h;
+
+        world->vaisseauMini->dy -= world->speed_h/(MAX_LINES*METEORITE_REAL_SIZE+700)*400;
+        world->vaisseauMini->y = (int)world->vaisseauMini->dy;
+
+        outBorder(world);
+
+        world->parallax += (int)world->speed_h;
+        update_walls(world);
+        world->money2 = world->money;
+        if (!world->invicibility){
+            for(int i = 0; i < world->nb_murs; i++){
+                collide(world->vaisseau, world->murs[i], world);
+            }
+        }
+        
+
+        if (timer_update_s(world) != 0){
+            world->str[0] = '\0';
+            world->str = strcats(world->str, 3, "temps: ",int_to_str((int)world->timer/1000), "s");
+        }
+        collide(world->vaisseau, world->ligneArriver, world); // Collision avec la ligne d'arriver   
+        allEvents(world);
+        world->timer = SDL_GetTicks(); 
+    }
+}
+
+void outBorder(world_t *world){
+    if (isOverScreen(world->vaisseau)){
+                if (world->vaisseau->x < 0) world->vaisseau->x = 0;
+                if (world->vaisseau->x + world->vaisseau->w > SCREEN_WIDTH) world->vaisseau->x = SCREEN_WIDTH - world->vaisseau->w;
+                if (world->vaisseau->y < 0) world->vaisseau->y = 0;
+                if (world->vaisseau->y + world->vaisseau->h > SCREEN_HEIGHT) world->vaisseau->y = SCREEN_HEIGHT - world->vaisseau->h;
+    }
+}
+
+int is_game_over(world_t *world){
+    return world->gameover;
+}
+
+int timer_update_s(world_t *world){
+    if (world->timer%1000 <=  110|| world->timer%1000 >= 985){
+        return world->timer%1000;
+    }
+    return 0;
 }
 
 void InitMenu(world_t * world){
@@ -56,18 +126,10 @@ void InitMenu(world_t * world){
     world->sound = init_btn(0, 0, 100, 100);
 }
 
-void clean_data(world_t *world){
-    /* utile uniquement si vous avez fait de l'allocation dynamique (malloc); la fonction ici doit permettre de libérer la mémoire (free) */
-    free(world->vaisseau);
-    free(world->ligneArriver);
-    free(world->murs);
-    free(world->str);
-    printf("clean_data");   
-}
 
-void collide(sprite_t *sp1, sprite_t *sp2, world_t *world, int make_disappear){
+void collide(sprite_t *sp1, sprite_t *sp2, world_t *world){
     if (sprites_collide(sp1, sp2)){
-        printf("%s\n", sp2->id);
+        printf("aaa: %s\n", sp2->id);
         if (strcmp(sp2->id, "1") == 0){
             world->gameover = 1;
         }else if(strcmp(sp2->id, "2") == 0){
@@ -78,6 +140,9 @@ void collide(sprite_t *sp1, sprite_t *sp2, world_t *world, int make_disappear){
             }
         }else if(strcmp(sp2->id, "z") == 0){
             world->gameover = 1;
+        }else if(strcmp(sp2->id, "3") == 0){
+            world->money += 1;
+            remove_wall(world, sp2->indice);
         }
     }
 }
@@ -109,17 +174,10 @@ void init_walls(world_t *world){
     int nb_elements = 0;
     char **txt = lirefile("maps/default.txt", &world->nb_lines_murs);
 
-    // for (int i = 0; i < world->nb_lines_murs; i++) {
-    //     for (int j = 0; j < MAX_LENGTH; j++) {
-    //         murs2[nb_elements] = txt[i][j];
-    //         nb_elements++;
-    //     }
-    // }
-
     for (int i = 0; i < world->nb_lines_murs; i++) {
         for (int j = 0; j < MAX_LENGTH; j++) {
             if (txt[i][j] != '0'){
-                world->murs[world->nb_murs] = init_sprite(world->murs[world->nb_murs], j*METEORITE_SIZE+2, (i*METEORITE_SIZE)-(METEORITE_SIZE*world->nb_lines_murs), METEORITE_SIZE, METEORITE_SIZE, txt[i][j]);
+                world->murs[world->nb_murs] = init_sprite(world->murs[world->nb_murs], j*METEORITE_SIZE+2, (i*METEORITE_SIZE)-(METEORITE_SIZE*world->nb_lines_murs), METEORITE_SIZE, METEORITE_SIZE, txt[i][j], world->nb_murs);
                 world->nb_murs++;
             }
         }
@@ -136,8 +194,36 @@ void update_walls(world_t *world){
     }
 }
 
+void remove_wall(world_t *world, int index){
+    free(world->murs[index]);
+    world->murs[index] = world->air;
+    world->murs[index]->indice = index;
+}
+
 void allEvents(world_t *world){
+    if (world->money2 != world->money){
+        world->coins_str[0] = '\0'; // On vide le string
+        world->coins_str = strcat(world->coins_str, int_to_str(world->money));
+    }
+
     if (world->isFlipping != 0){
         flipScreen(world);
     }
 }
+
+void clean_data(world_t *world){
+    /* utile uniquement si vous avez fait de l'allocation dynamique (malloc); la fonction ici doit permettre de libérer la mémoire (free) */
+    free(world->vaisseau);
+    free(world->ligneArriver);
+    free(world->murs);
+    free(world->str);
+    free(world->vaisseauMini);
+    free(world->soleilBarre);
+    free(world->soleil);
+    free(world->BarreProgression);
+    free(world->coins);
+    free(world->coins_str);
+    free(world->air);
+
+    printf("clean_data");   
+}
\ No newline at end of file
diff --git a/library/World/world.h b/library/World/world.h
index b5e364a224d0ec1049a48cc4a7a94ee83ad65f7c..18c176ef85c655795048c82f106f83d99a6dc0dd 100644
--- a/library/World/world.h
+++ b/library/World/world.h
@@ -44,6 +44,12 @@ struct world_s{
     btn_t *magasin;
     btn_t *sound;
     
+    sprite_t *BarreProgression;
+    sprite_t *vaisseauMini;
+    sprite_t *soleilBarre;
+    sprite_t *soleil;
+    sprite_t *air;
+    sprite_t *coins;
     int nb_murs; // Nombre de météorites
     int nb_lines_murs; // Nombre de lignes de météorites
     sprite_t *ligneArriver;
@@ -52,12 +58,20 @@ struct world_s{
     unsigned int startTimer; /*!< Timer de départ */
     unsigned int timer; /*!< Timer de jeu */
     char * str; // String affichant le temps sur le jeu
+    char * coins_str;
+
     double angle; // Angle de rotation de la map
     int isFlipping; // Indique si l'on est en train de faire une rotation de l'écran et dans quelle sens (0 : non droite, 1 : vers la droite, -1 : vers la gauche, -2 : non gauche)
     int isMenu;
 
     int mouseX;
     int mouseY;
+    bool isMenu;
+    int money;
+    int money2;
+
+    int parallax;
+    bool invicibility;
 };
 typedef struct world_s world_t;
 
@@ -74,6 +88,20 @@ void update_data(world_t *world);
 
 int is_game_over(world_t *world);
 
+/**
+ * @brief Detecte si le vaisseau va en dehors de l'écran
+ * 
+ * @param world 
+ */
+void outBorder(world_t *world);
+
+/**
+ * @brief Actualise le timer de jeu
+ * 
+ * @param world 
+ * @return int 
+ */
+int timer_update_s(world_t *world);
 
 /**
  * \brief La fonction initialise les données du monde du jeu
@@ -104,7 +132,7 @@ void flipScreen(world_t *world);
  * \param world Le monde
  * \param make_disappear Indique si l'on doit faire disparaître les sprites en cas de collision 
  */
-void collide(sprite_t *sp1, sprite_t *sp2, world_t *world, int make_disappear);
+void collide(sprite_t *sp1, sprite_t *sp2, world_t *world);
 
 
 /**
@@ -121,6 +149,8 @@ void init_walls(world_t *world);
  */
 void update_walls(world_t *world);
 
+void remove_wall(world_t *world, int index);
+
 /**
  * \brief La fonction qui execute toutes les actions du jeu
  * 
diff --git a/library/World/world.o b/library/World/world.o
index 223692b0303653d56a81b57c4a53c878f08ecf16..bed725f70d951aa874e65dcf01f1deb1b6267f03 100644
Binary files a/library/World/world.o and b/library/World/world.o differ
diff --git a/library/utility/utility.c b/library/utility/utility.c
index 74927a35b85c22d9bfdd1d9a1e3e092bd14b8260..492d747cf9b3e2d9e91b255de3007dcaf3ebf525 100644
--- a/library/utility/utility.c
+++ b/library/utility/utility.c
@@ -41,4 +41,13 @@ char **lirefile(char *filename, int *num_lines) {
 
     fclose(file);
     return lines;
+}
+
+int number_of_numbers(int n){
+    int count = 0;
+    while (n != 0){
+        n /= 10;
+        count++;
+    }
+    return count;
 }
\ No newline at end of file
diff --git a/library/utility/utility.h b/library/utility/utility.h
index 5913cf6999d2e8213d463875dfccd4d8f95a3552..5d6567d9a9dedac457be3144ff8a079c51ab90f6 100644
--- a/library/utility/utility.h
+++ b/library/utility/utility.h
@@ -9,11 +9,10 @@
  * 
  */
 #include <stdarg.h>
-
+#include "../../constante.c"
 #ifndef Utility_h
 #define Utility_h
-#define MAX_LINES 500
-#define MAX_LENGTH 28
+
 
 /**
  * \brief Concatène plusieurs chaines de caractères
@@ -43,4 +42,5 @@ char * int_to_str(int n);
 
 char ** lirefile(char *filename, int *num_lines);
 
+int number_of_numbers(int n);
 #endif
\ No newline at end of file
diff --git a/library/utility/utility.o b/library/utility/utility.o
index 4003e8a3c416de54297d07174af1bd67c9aee735..7133de4d09f644f9a7255773bb41e3367c335008 100644
Binary files a/library/utility/utility.o and b/library/utility/utility.o differ
diff --git a/main.c b/main.c
index ba1c9b59a301792ae5132958f37d2872cdaee2e2..7f7045d4e68a67cf9acb39f546a1d698f4821948 100644
--- a/main.c
+++ b/main.c
@@ -50,8 +50,6 @@ void handle_events(SDL_Event *event,world_t *world){
                 switch (event->key.keysym.sym){
                     case SDLK_z:
                         world->speed_h = 4;
-
-                        printf("%f\n", world->speed_h);
                         break;
                     case SDLK_s:
                         world->speed_h = INITIAL_SPEED;
diff --git a/main.o b/main.o
index 1297e3a4694d1456ac735299520d83446907d63f..8b76c46dce9498fb4c8f9694e369af6bd6752e7b 100644
Binary files a/main.o and b/main.o differ
diff --git a/maps/default.txt b/maps/default.txt
index ce994eba6d194b527aab953e914baac1ae24660a..1b75ca18ad9c23cdf647f4984a1930e8e2203767 100644
--- a/maps/default.txt
+++ b/maps/default.txt
@@ -3,9 +3,9 @@
 00000000000000000000000000
 00000000000000000000000000
 00000000000000000000000000
-00000000000000000000000000
-00000000000011000000000001
-00000000011111100000000001
+00000000000000000033300000
+00000000000011000330030001
+00000000011111100003030001
 10000000111111110000000001
 10000000111111111111000001
 11000001111111111111000001
@@ -14,15 +14,15 @@
 11000011111111111111100001
 11000011111111111111100001
 10000011111111111111000001
-10000011111111111111000001
-10000001111111111111000001
-00000001111111111111000000
-00020000011111111110000000
-00000000001111111100000000
-00000000001111111000000000
-00000000001111000000000000
-00000110001110000000000000
-00000000000110000000000000
+10000011111111111111000301
+10000001111111111111003301
+00000001111111111111003300
+00020000011111111110003300
+00000000001111111100003300
+00000000001111111000003000
+00000000001111000000033000
+00000110001110000000030000
+00000000000110000000030000
 00000000000110000000000000
 00000000000000000000000000
 00000000000000000000000000
@@ -35,7 +35,7 @@
 00000000000000000000011110
 00000000000000000000011110
 00011000000000000000011110
-00011000022000000000111110
+00011000020000000000111110
 00000000000000000000111110
 00000000000000000001111110
 00000000000000000001111110
@@ -48,20 +48,20 @@
 11110000000110011111111111
 11111000000000011111111111
 11111000000000011111111111
-11111000000000011111111111
+11111000000030011111111111
 11111100000000011111111111
-11111100000000001111111111
-11111110000000000011111111
+11111100030000001111111111
+11111110000030000011111111
 11111110000000000001111111
-11111111000000000001111111
-11111111000000000011111111
-11111111100000000011111111
+11111111003000000001111111
+11111111003030300011111111
 11111111100000000011111111
+11111111100300000011111111
 11111111100000000011111111
-11111111100000000001111111
-11111111100000000001111111
+11111111100000300001111111
+11111111103300000001111111
 11111111100000000000111111
-11111111100000000000011111
+11111111100003000000011111
 11111111100000000000001111
 11111111100000000000001111
 11111111100000000000000111
@@ -73,29 +73,29 @@
 11111000000000000000000001
 11111000000000000000000001
 11110000000000000000000001
-11100000000000000000000001
-11100000000000000000000001
-11000000000000000000000001
-11000000000000000000000001
-10000000000000000000000001
+11100000000033000000000001
+11100000000333300000000001
+11000000000333300000000001
+11000000000033000000000001
+10000033000000000000000001
 10000000000000000000000001
 10000000000010000000000001
-10000000000010000000000001
+10003000033000000000000001
 00000000000000000000000001
 00000000000000000000000000
-00000000000000000000000000
-00000000000000100000000000
-00000000000000000000000000
-00000000000000000000000000
-00000000000000000000000000
-00000000000000000000000000
-00001100000100000000000000
-00000000000110000000111110
+00300000003000000000000000
+00000330300000100000000000
+00000000000030000000000000
+00300000000000000000000000
+00000000300000000000000000
+00000000300000000000000000
+00001000000000000000000000
+00000000000100000000111110
 00000000000000000001111110
-00000000000000000111111110
-00000000000000001111111110
-00000000000000001111111110
-00000000000000011111111110
+00330000000000000111111110
+03333000000000001111111110
+03333000000000001111111110
+00330000000000011111111110
 00000000000000111111111110
 00000000000100111111111110
 00000000001110111111111110
@@ -103,10 +103,10 @@
 00000000001101111111111110
 00000000000001111111111110
 00000000000001111111111110
-00000000000001111111111110
-01100000000000111111111110
-11100000000000111111111110
-11100000000000111111111110
+00000000330001111111111110
+00000003333000111111111110
+11100003333000111111111110
+11100000330000111111111110
 11100000000001111111111110
 00000000000001111111111110
 00000000000001111111111110
@@ -115,15 +115,15 @@
 00020000000011111111111110
 00000000000111111111111110
 00000000000111111111111110
+00000000000111111111111110
 00000000001111111111111110
 00000000001111111111111110
 00000000001111111111111110
 00000000001111111111111110
 00000000001111111111111110
-00000000001111111111111110
-00110000001111111111111110
-01110000001111111111111110
-00110000001111111111111110
+00100000001111111111111110
+01100000001111111111111110
+00100000001111111111111110
 00000000000111111111111110
 00000000000111111111111110
 00000000000011111111111110
@@ -152,17 +152,17 @@
 00000011111111111111000000
 00000011111111111111000000
 00000011111111111111000000
-00000001111111111111000000
-00000001111111111111000000
-00000001111111111111000000
-00000000111111111111000000
-00000000111111111110000000
-00000000111111111100000000
-00000000111111111100000000
-00000000111111111000000000
-00000000111111111000000000
+00030001111111111111000000
+00003001111111111111000000
+00333001111111111111000000
+00003000111111111111000000
+00333300111111111110000000
+00330000111111111100000000
+00333300111111111100000000
+00300000111111111000000000
+00303030111111111000000000
 00000000111111110000000000
-00000000011111110000000000
+00033000011111110000000000
 00000000000011000000000000
 00000000000000000000000000
 00000000000000000000000000
@@ -183,28 +183,28 @@
 00001111000000000000000000
 00011111000000000000000000
 00011111000000000000000000
-00111111111110000000000000
+00111111111110000300030000
 00111111111111000000000000
 00111111111111100000000000
 00111111111111100000000000
-00111111111111100000000000
-00111111111111100000000000
+00111111111111100003000000
+00111111111111103000033000
 01111111111111100000000000
-01111111111111100000000000
-11111111111111100000000000
-11111111111111000000000000
-11111111111110000000000001
+01111111111111100003000000
+11111111111111100003000000
+11111111111111003000003000
 11111111111110000000000001
+11111111111110000303003001
+11111111111100030000000001
+11111111111103300000030001
+11111111111100000300030001
+11111111111100300000000001
 11111111111100000000000001
-11111111111100000000000001
-11111111111100000000000001
-11111111111100000000000001
-11111111111100000000000001
-11111111111100000000001101
+11111111111100330300001101
 11111111111100000000011111
+11111111111000300000111110
 11111111111000000000111110
-11111111111000000000111110
-01111111110000000000011110
+01111111110000003300011110
 00011111100000000000011100
 00000000000000000000000000
 00000000000000000000000000
@@ -216,13 +216,13 @@
 00000000000000000000000110
 00000000000000000000001110
 00000000000000000000011110
-00001100000000000000111110
-00011110000000000001111110
-00011110000000000001111110
-00011100000000000001111100
-00000000000000000001111100
-00000000000000000001111100
-00000000000000000001111110
+03301100000000000000111110
+03311110000000000001111110
+33311110000000000001111110
+33311100000000000001111100
+03333000000000000001111100
+03333000000000000001111100
+00333000000000000001111110
 00000000000000000001111100
 00000000000000000011111100
 00000000000000000111111100
@@ -239,10 +239,10 @@
 00000111111000111111100000
 00000111111000111111110000
 00000111111000111111110000
-00000111110000111111111000
-00011111110000011111111000
-00111111110000011111111000
-01111111100000001111110000
+00000111110330111111111000
+00011111110330011111111000
+00111111110330011111111000
+01111111100330001111110000
 01111111100000000111110000
 11111111100000000111110000
 11111111100000000111100000
@@ -256,12 +256,12 @@
 11111100000000000110000000
 11111000000000001110000000
 00000000000000011110000000
-00000000000000011110000000
-00000000000000011110000000
-00000000000000000000000000
-00000000000000000000000000
-00000000000000000000000000
-00000000000000000000000000
+00000000033000011110000000
+00000000333300011110000000
+00000003333330000000000000
+00000003333330000000000000
+00000000333300000000000000
+00000000033000000000000000
 00000000000000000000000000
 00000000000000000000000000
 00000000000000000000000000
@@ -277,16 +277,16 @@
 00000000000111111111111100
 00000000000111111111111120
 00000000000111111111111100
-00000000000111111111111100
-00000000000111111111111000
-00000000000111111111111000
-00000000000111111111111000
-00000000001111111111110000
-00000000001111111111110001
-11000000011111111111100001
-11000000011111111111100001
-11000000011111111111000001
-11000000011111111110000001
+00330000000111111111111100
+00030000000111111111111000
+00033000000111111111111000
+00003000000111111111111000
+00003000001111111111110000
+00003000001111111111110001
+11003300011111111111100001
+11003300011111111111100001
+11003000011111111111000001
+11003000011111111110000001
 10000000011111111110000001
 10000000011111111100000000
 00000000011111111100000000
@@ -330,12 +330,12 @@
 11111111111100000000000001
 11111111111100000000000001
 11111111111100000000000001
-11111111111100000000000001
-11111111111100000000000001
-11111111111100000000000001
-11111111111100000000000001
-11111111111000000000000001
-11111111111000000000000001
+11111111111100003000000001
+11111111111100030300000001
+11111111111100303030000001
+11111111111103030303000001
+11111111111000300030000001
+11111111111003000003000001
 11111111111000000000000001
 11111111110000000000000001
 11111111110000000000000001
@@ -369,11 +369,11 @@
 00000000000000000000111110
 00000020000000000001111110
 00000000000000000001111110
-00000000000000000001111110
-10000000000000000001111111
-11000000000000000001111111
-11000000000011000001111111
-11000000000111000001111110
+00000000330000000001111110
+10000003300000000001111111
+11000033000000000001111111
+11000330000011000001111111
+11000300000111000001111110
 00000000000011000001111110
 00000000000000000011111110
 00000000000000000011111110
@@ -404,21 +404,21 @@
 11110000000000011111111111
 11110000000000011111111111
 11111000000000011111111111
-11111000000000011111111111
-11111000000000111111111111
-11111100000000111111111111
-11111100000000111111111111
-11111100000000111111111111
-11111110000000111111111111
-11111110000000111111111111
-11111110000000111111111111
-11111111000000111111111111
-11111111000000111111111111
-11111111100000011111111111
-11111111100000001111111111
-11111111110000001111111111
-11111111110000000111111111
-11111111110000000011111111
+11111000030000011111111111
+11111000030000111111111111
+11111100030000111111111111
+11111100030000111111111111
+11111100030000111111111111
+11111110030000111111111111
+11111110003000111111111111
+11111110003000111111111111
+11111111003300111111111111
+11111111000300111111111111
+11111111100300011111111111
+11111111100300001111111111
+11111111110300001111111111
+11111111110330000111111111
+11111111110030000011111111
 11111111110000000001111111
 11111111110000000000111111
 11111111111000000000001111
@@ -441,27 +441,27 @@
 11111100010000000110000001
 11111100010000000110000001
 11111100000000000110000001
-11111100000000000000000001
-11111100000000000000000001
+11111100000000000000003301
+11111100000000000000003301
 11111100000000000000000001
 11111100000000000000000001
 11111110000000000000000001
-11111110000000000000000001
-11111110000000000000000001
-11111110000000000000110001
-11111110000000000000010001
-11111110000000000000000001
-11111111000000000000000001
-11111111000000000000000001
-11111111100000000000000001
+11111110300000000000000001
+11111110330000000000000001
+11111110330000000000110001
+11111110330000000000010001
+11111110330000000000000001
+11111111033000000000000001
+11111111003300000000000001
+11111111100000000000003001
 11111111110000000000000001
 11111111111000000000000001
+11111111111100000000003001
 11111111111100000000000001
-11111111111100000000000001
-11111111111110000000000001
-11111111111110000000000001
-11111111111110000000000001
 11111111111110000000000001
+11111111111110000030000001
+11111111111110003000000001
+11111111111110000003000001
 11111111111110000000000001
 11111111111110000000000001
 11111111111110000000000001
@@ -479,14 +479,14 @@
 00000000000000000000000000
 00000000000000000000000000
 00000000000000000000000000
-00000000000000000000000000
-00000000000000000000000000
-00000000000000000000000000
-00000000000000000000000000
-00000000000000000000000000
-00000000000000000000000000
-00000000000000000000000000
-00000000000000000000000000
+00000000000300033000000000
+00000000000330333300000000
+00000000003330303300000000
+00000000003033303300000000
+00000000033003003300000000
+00000000033000003300000000
+00000000030000003000000000
+00000000000000033000000000
 00000000000000000000000000
 00000000000000000000000000
 00000000000000000000000000
diff --git a/maps/map.png b/maps/map.png
index 1dac74b5485d2314aa88a36e64b2ea148154927c..b21af76dc937c5ca07016d7ac6d62c971a9382fb 100644
Binary files a/maps/map.png and b/maps/map.png differ
diff --git a/maps/map.py b/maps/map.py
index f66f221243337b16418bf29cd5a3eec3a6967061..d93a10dd7704aeefad8769dd8439c107863a5b40 100644
--- a/maps/map.py
+++ b/maps/map.py
@@ -21,6 +21,8 @@ for pixel in pixels:
         file.write("1")
     elif pixel[0] == 255 and pixel[1] == 0 and pixel[2] == 0:
         file.write("2")
+    elif pixel[0] == 0 and pixel[1] == 255 and pixel[2] == 0 and pixel[3] > 80:
+        file.write("3")
     else:
         file.write("0")
     compteur += 1
diff --git a/ressources/Elements/BarreProgression.png b/ressources/Elements/BarreProgression.png
new file mode 100644
index 0000000000000000000000000000000000000000..0c3c7d810386ab2a144fe94efa4334a347bbb63a
Binary files /dev/null and b/ressources/Elements/BarreProgression.png differ
diff --git a/ressources/Elements/backgrounds/1.png b/ressources/Elements/backgrounds/1.png
new file mode 100644
index 0000000000000000000000000000000000000000..029df89f00bb1e1788d025a2bead39b5169c9439
Binary files /dev/null and b/ressources/Elements/backgrounds/1.png differ
diff --git a/ressources/Elements/backgrounds/2.png b/ressources/Elements/backgrounds/2.png
new file mode 100644
index 0000000000000000000000000000000000000000..bb5b5ddcced18c6f29ea655e8c43f26c5aba25c3
Binary files /dev/null and b/ressources/Elements/backgrounds/2.png differ
diff --git a/ressources/Elements/backgrounds/3.png b/ressources/Elements/backgrounds/3.png
new file mode 100644
index 0000000000000000000000000000000000000000..abc609b3040121aceca46421b02d7007ff869fc1
Binary files /dev/null and b/ressources/Elements/backgrounds/3.png differ
diff --git a/ressources/Elements/backgrounds/4.png b/ressources/Elements/backgrounds/4.png
new file mode 100644
index 0000000000000000000000000000000000000000..e1730944ff0b944da44eefa955d7399de4cbf861
Binary files /dev/null and b/ressources/Elements/backgrounds/4.png differ
diff --git a/ressources/Elements/backgrounds/5.png b/ressources/Elements/backgrounds/5.png
new file mode 100644
index 0000000000000000000000000000000000000000..32adaff732422bf4235e48c71ba58894c597d3bd
Binary files /dev/null and b/ressources/Elements/backgrounds/5.png differ
diff --git a/ressources/Elements/coin.png b/ressources/Elements/coin.png
new file mode 100644
index 0000000000000000000000000000000000000000..565021cf74044c3c3a634d5ff5585adbb3c797f5
Binary files /dev/null and b/ressources/Elements/coin.png differ
diff --git a/ressources/Elements/soleil.png b/ressources/Elements/soleil.png
new file mode 100644
index 0000000000000000000000000000000000000000..0407d3ee7c7e409e84152914c8383b5f86e56774
Binary files /dev/null and b/ressources/Elements/soleil.png differ
diff --git a/sdl2-light.c b/sdl2-light.c
index 1d64ca87d4155e0a7803d223bb4657bf2189f1b0..30f73e7568874854e90ed0bb4f063828b11efe15 100644
--- a/sdl2-light.c
+++ b/sdl2-light.c
@@ -9,7 +9,7 @@
 #include "sdl2-light.h"
 #include <stdio.h>
 #include <stdlib.h>
-
+#include <SDL2/SDL_image.h>
 
 
 int init_sdl(SDL_Window **window, SDL_Renderer **renderer, int width, int height)
@@ -37,8 +37,11 @@ SDL_Texture *load_image(const char path[], SDL_Renderer *renderer)
     tmp = SDL_LoadBMP(path);
     if(NULL == tmp)
     {
-        fprintf(stderr, "Erreur pendant chargement image BMP: %s", SDL_GetError());
-        return NULL;
+        tmp = IMG_Load(path);
+        if (NULL == tmp){
+            fprintf(stderr, "Erreur pendant chargement image BMP: %s", SDL_GetError());
+            return NULL;
+        }
     }
     SDL_SetColorKey(tmp, SDL_TRUE, SDL_MapRGB(tmp->format, 255, 0, 255));
     texture = SDL_CreateTextureFromSurface(renderer, tmp);
diff --git a/sdl2-light.o b/sdl2-light.o
index b77493b616a056721eb6cd89aa736e0c13fda74b..b1fb73d0112d9feb208a755bbcb6b2a0571606ef 100644
Binary files a/sdl2-light.o and b/sdl2-light.o differ
diff --git a/spacecorridor.exe b/spacecorridor.exe
index b50007bf515cdd9601205ffd3e3363a273fb8114..9696efa1b4499fdb9bfb129f27a8dc8cb086ce0f 100644
Binary files a/spacecorridor.exe and b/spacecorridor.exe differ
diff --git a/src/include/SDL2/SDL_image.h b/src/include/SDL2/SDL_image.h
new file mode 100644
index 0000000000000000000000000000000000000000..cc4a2f6606912a3e223b04070d621f2de8124aba
--- /dev/null
+++ b/src/include/SDL2/SDL_image.h
@@ -0,0 +1,2173 @@
+/*
+  SDL_image:  An example image loading library for use with SDL
+  Copyright (C) 1997-2023 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+/**
+ *  \file SDL_image.h
+ *
+ *  Header file for SDL_image library
+ *
+ * A simple library to load images of various formats as SDL surfaces
+ */
+#ifndef SDL_IMAGE_H_
+#define SDL_IMAGE_H_
+
+#include "SDL.h"
+#include "SDL_version.h"
+#include "begin_code.h"
+
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL
+ */
+#define SDL_IMAGE_MAJOR_VERSION 2
+#define SDL_IMAGE_MINOR_VERSION 6
+#define SDL_IMAGE_PATCHLEVEL    3
+
+/**
+ * This macro can be used to fill a version structure with the compile-time
+ * version of the SDL_image library.
+ */
+#define SDL_IMAGE_VERSION(X)                        \
+{                                                   \
+    (X)->major = SDL_IMAGE_MAJOR_VERSION;           \
+    (X)->minor = SDL_IMAGE_MINOR_VERSION;           \
+    (X)->patch = SDL_IMAGE_PATCHLEVEL;              \
+}
+
+#if SDL_IMAGE_MAJOR_VERSION < 3 && SDL_MAJOR_VERSION < 3
+/**
+ *  This is the version number macro for the current SDL_image version.
+ *
+ *  In versions higher than 2.9.0, the minor version overflows into
+ *  the thousands digit: for example, 2.23.0 is encoded as 4300.
+ *  This macro will not be available in SDL 3.x or SDL_image 3.x.
+ *
+ *  Deprecated, use SDL_IMAGE_VERSION_ATLEAST or SDL_IMAGE_VERSION instead.
+ */
+#define SDL_IMAGE_COMPILEDVERSION \
+    SDL_VERSIONNUM(SDL_IMAGE_MAJOR_VERSION, SDL_IMAGE_MINOR_VERSION, SDL_IMAGE_PATCHLEVEL)
+#endif /* SDL_IMAGE_MAJOR_VERSION < 3 && SDL_MAJOR_VERSION < 3 */
+
+/**
+ *  This macro will evaluate to true if compiled with SDL_image at least X.Y.Z.
+ */
+#define SDL_IMAGE_VERSION_ATLEAST(X, Y, Z) \
+    ((SDL_IMAGE_MAJOR_VERSION >= X) && \
+     (SDL_IMAGE_MAJOR_VERSION > X || SDL_IMAGE_MINOR_VERSION >= Y) && \
+     (SDL_IMAGE_MAJOR_VERSION > X || SDL_IMAGE_MINOR_VERSION > Y || SDL_IMAGE_PATCHLEVEL >= Z))
+
+/**
+ * This function gets the version of the dynamically linked SDL_image library.
+ *
+ * it should NOT be used to fill a version structure, instead you should use
+ * the SDL_IMAGE_VERSION() macro.
+ *
+ * \returns SDL_image version
+ */
+extern DECLSPEC const SDL_version * SDLCALL IMG_Linked_Version(void);
+
+/**
+ * Initialization flags
+ */
+typedef enum
+{
+    IMG_INIT_JPG    = 0x00000001,
+    IMG_INIT_PNG    = 0x00000002,
+    IMG_INIT_TIF    = 0x00000004,
+    IMG_INIT_WEBP   = 0x00000008,
+    IMG_INIT_JXL    = 0x00000010,
+    IMG_INIT_AVIF   = 0x00000020
+} IMG_InitFlags;
+
+/**
+ * Initialize SDL_image.
+ *
+ * This function loads dynamic libraries that SDL_image needs, and prepares
+ * them for use. This must be the first function you call in SDL_image, and if
+ * it fails you should not continue with the library.
+ *
+ * Flags should be one or more flags from IMG_InitFlags OR'd together. It
+ * returns the flags successfully initialized, or 0 on failure.
+ *
+ * Currently, these flags are:
+ *
+ * - `_INIT_JPG`
+ * - `_INIT_PNG`
+ * - `_INIT_TIF`
+ * - `_INIT_WEBP`
+ * - `_INIT_JXL`
+ * - `_INIT_AVIF`
+ *
+ * More flags may be added in a future SDL_image release.
+ *
+ * This function may need to load external shared libraries to support various
+ * codecs, which means this function can fail to initialize that support on an
+ * otherwise-reasonable system if the library isn't available; this is not
+ * just a question of exceptional circumstances like running out of memory at
+ * startup!
+ *
+ * Note that you may call this function more than once to initialize with
+ * additional flags. The return value will reflect both new flags that
+ * successfully initialized, and also include flags that had previously been
+ * initialized as well.
+ *
+ * As this will return previously-initialized flags, it's legal to call this
+ * with zero (no flags set). This is a safe no-op that can be used to query
+ * the current initialization state without changing it at all.
+ *
+ * Since this returns previously-initialized flags as well as new ones, and
+ * you can call this with zero, you should not check for a zero return value
+ * to determine an error condition. Instead, you should check to make sure all
+ * the flags you require are set in the return value. If you have a game with
+ * data in a specific format, this might be a fatal error. If you're a generic
+ * image displaying app, perhaps you are fine with only having JPG and PNG
+ * support and can live without WEBP, even if you request support for
+ * everything.
+ *
+ * Unlike other SDL satellite libraries, calls to IMG_Init do not stack; a
+ * single call to IMG_Quit() will deinitialize everything and does not have to
+ * be paired with a matching IMG_Init call. For that reason, it's considered
+ * best practices to have a single IMG_Init and IMG_Quit call in your program.
+ * While this isn't required, be aware of the risks of deviating from that
+ * behavior.
+ *
+ * After initializing SDL_image, the app may begin to load images into
+ * SDL_Surfaces or SDL_Textures.
+ *
+ * \param flags initialization flags, OR'd together.
+ * \returns all currently initialized flags.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_Quit
+ */
+extern DECLSPEC int SDLCALL IMG_Init(int flags);
+
+/**
+ * Deinitialize SDL_image.
+ *
+ * This should be the last function you call in SDL_image, after freeing all
+ * other resources. This will unload any shared libraries it is using for
+ * various codecs.
+ *
+ * After this call, a call to IMG_Init(0) will return 0 (no codecs loaded).
+ *
+ * You can safely call IMG_Init() to reload various codec support after this
+ * call.
+ *
+ * Unlike other SDL satellite libraries, calls to IMG_Init do not stack; a
+ * single call to IMG_Quit() will deinitialize everything and does not have to
+ * be paired with a matching IMG_Init call. For that reason, it's considered
+ * best practices to have a single IMG_Init and IMG_Quit call in your program.
+ * While this isn't required, be aware of the risks of deviating from that
+ * behavior.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_Init
+ */
+extern DECLSPEC void SDLCALL IMG_Quit(void);
+
+/**
+ * Load an image from an SDL data source into a software surface.
+ *
+ * An SDL_Surface is a buffer of pixels in memory accessible by the CPU. Use
+ * this if you plan to hand the data to something else or manipulate it
+ * further in code.
+ *
+ * There are no guarantees about what format the new SDL_Surface data will be;
+ * in many cases, SDL_image will attempt to supply a surface that exactly
+ * matches the provided image, but in others it might have to convert (either
+ * because the image is in a format that SDL doesn't directly support or
+ * because it's compressed data that could reasonably uncompress to various
+ * formats and SDL_image had to pick one). You can inspect an SDL_Surface for
+ * its specifics, and use SDL_ConvertSurface to then migrate to any supported
+ * format.
+ *
+ * If the image format supports a transparent pixel, SDL will set the colorkey
+ * for the surface. You can enable RLE acceleration on the surface afterwards
+ * by calling: SDL_SetColorKey(image, SDL_RLEACCEL, image->format->colorkey);
+ *
+ * If `freesrc` is non-zero, the RWops will be closed before returning,
+ * whether this function succeeds or not. SDL_image reads everything it needs
+ * from the RWops during this call in any case.
+ *
+ * Even though this function accepts a file type, SDL_image may still try
+ * other decoders that are capable of detecting file type from the contents of
+ * the image data, but may rely on the caller-provided type string for formats
+ * that it cannot autodetect. If `type` is NULL, SDL_image will rely solely on
+ * its ability to guess the format.
+ *
+ * There is a separate function to read files from disk without having to deal
+ * with SDL_RWops: `IMG_Load("filename.jpg")` will call this function and
+ * manage those details for you, determining the file type from the filename's
+ * extension.
+ *
+ * There is also IMG_Load_RW(), which is equivalent to this function except
+ * that it will rely on SDL_image to determine what type of data it is
+ * loading, much like passing a NULL for type.
+ *
+ * If you are using SDL's 2D rendering API, there is an equivalent call to
+ * load images directly into an SDL_Texture for use by the GPU without using a
+ * software surface: call IMG_LoadTextureTyped_RW() instead.
+ *
+ * When done with the returned surface, the app should dispose of it with a
+ * call to SDL_FreeSurface().
+ *
+ * \param src an SDL_RWops that data will be read from.
+ * \param freesrc non-zero to close/free the SDL_RWops before returning, zero
+ *                to leave it open.
+ * \param type a filename extension that represent this data ("BMP", "GIF",
+ *             "PNG", etc).
+ * \returns a new SDL surface, or NULL on error.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_Load
+ * \sa IMG_Load_RW
+ * \sa SDL_FreeSurface
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadTyped_RW(SDL_RWops *src, int freesrc, const char *type);
+
+/**
+ * Load an image from a filesystem path into a software surface.
+ *
+ * An SDL_Surface is a buffer of pixels in memory accessible by the CPU. Use
+ * this if you plan to hand the data to something else or manipulate it
+ * further in code.
+ *
+ * There are no guarantees about what format the new SDL_Surface data will be;
+ * in many cases, SDL_image will attempt to supply a surface that exactly
+ * matches the provided image, but in others it might have to convert (either
+ * because the image is in a format that SDL doesn't directly support or
+ * because it's compressed data that could reasonably uncompress to various
+ * formats and SDL_image had to pick one). You can inspect an SDL_Surface for
+ * its specifics, and use SDL_ConvertSurface to then migrate to any supported
+ * format.
+ *
+ * If the image format supports a transparent pixel, SDL will set the colorkey
+ * for the surface. You can enable RLE acceleration on the surface afterwards
+ * by calling: SDL_SetColorKey(image, SDL_RLEACCEL, image->format->colorkey);
+ *
+ * There is a separate function to read files from an SDL_RWops, if you need
+ * an i/o abstraction to provide data from anywhere instead of a simple
+ * filesystem read; that function is IMG_Load_RW().
+ *
+ * If you are using SDL's 2D rendering API, there is an equivalent call to
+ * load images directly into an SDL_Texture for use by the GPU without using a
+ * software surface: call IMG_LoadTexture() instead.
+ *
+ * When done with the returned surface, the app should dispose of it with a
+ * call to SDL_FreeSurface().
+ *
+ * \param file a path on the filesystem to load an image from.
+ * \returns a new SDL surface, or NULL on error.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_LoadTyped_RW
+ * \sa IMG_Load_RW
+ * \sa SDL_FreeSurface
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_Load(const char *file);
+
+/**
+ * Load an image from an SDL data source into a software surface.
+ *
+ * An SDL_Surface is a buffer of pixels in memory accessible by the CPU. Use
+ * this if you plan to hand the data to something else or manipulate it
+ * further in code.
+ *
+ * There are no guarantees about what format the new SDL_Surface data will be;
+ * in many cases, SDL_image will attempt to supply a surface that exactly
+ * matches the provided image, but in others it might have to convert (either
+ * because the image is in a format that SDL doesn't directly support or
+ * because it's compressed data that could reasonably uncompress to various
+ * formats and SDL_image had to pick one). You can inspect an SDL_Surface for
+ * its specifics, and use SDL_ConvertSurface to then migrate to any supported
+ * format.
+ *
+ * If the image format supports a transparent pixel, SDL will set the colorkey
+ * for the surface. You can enable RLE acceleration on the surface afterwards
+ * by calling: SDL_SetColorKey(image, SDL_RLEACCEL, image->format->colorkey);
+ *
+ * If `freesrc` is non-zero, the RWops will be closed before returning,
+ * whether this function succeeds or not. SDL_image reads everything it needs
+ * from the RWops during this call in any case.
+ *
+ * There is a separate function to read files from disk without having to deal
+ * with SDL_RWops: `IMG_Load("filename.jpg")` will call this function and
+ * manage those details for you, determining the file type from the filename's
+ * extension.
+ *
+ * There is also IMG_LoadTyped_RW(), which is equivalent to this function
+ * except a file extension (like "BMP", "JPG", etc) can be specified, in case
+ * SDL_image cannot autodetect the file format.
+ *
+ * If you are using SDL's 2D rendering API, there is an equivalent call to
+ * load images directly into an SDL_Texture for use by the GPU without using a
+ * software surface: call IMG_LoadTexture_RW() instead.
+ *
+ * When done with the returned surface, the app should dispose of it with a
+ * call to SDL_FreeSurface().
+ *
+ * \param src an SDL_RWops that data will be read from.
+ * \param freesrc non-zero to close/free the SDL_RWops before returning, zero
+ *                to leave it open.
+ * \returns a new SDL surface, or NULL on error.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_Load
+ * \sa IMG_LoadTyped_RW
+ * \sa SDL_FreeSurface
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_Load_RW(SDL_RWops *src, int freesrc);
+
+#if SDL_VERSION_ATLEAST(2,0,0)
+
+/**
+ * Load an image from a filesystem path into a GPU texture.
+ *
+ * An SDL_Texture represents an image in GPU memory, usable by SDL's 2D Render
+ * API. This can be significantly more efficient than using a CPU-bound
+ * SDL_Surface if you don't need to manipulate the image directly after
+ * loading it.
+ *
+ * If the loaded image has transparency or a colorkey, a texture with an alpha
+ * channel will be created. Otherwise, SDL_image will attempt to create an
+ * SDL_Texture in the most format that most reasonably represents the image
+ * data (but in many cases, this will just end up being 32-bit RGB or 32-bit
+ * RGBA).
+ *
+ * There is a separate function to read files from an SDL_RWops, if you need
+ * an i/o abstraction to provide data from anywhere instead of a simple
+ * filesystem read; that function is IMG_LoadTexture_RW().
+ *
+ * If you would rather decode an image to an SDL_Surface (a buffer of pixels
+ * in CPU memory), call IMG_Load() instead.
+ *
+ * When done with the returned texture, the app should dispose of it with a
+ * call to SDL_DestroyTexture().
+ *
+ * \param renderer the SDL_Renderer to use to create the GPU texture.
+ * \param file a path on the filesystem to load an image from.
+ * \returns a new texture, or NULL on error.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_LoadTextureTyped_RW
+ * \sa IMG_LoadTexture_RW
+ * \sa SDL_DestroyTexture
+ */
+extern DECLSPEC SDL_Texture * SDLCALL IMG_LoadTexture(SDL_Renderer *renderer, const char *file);
+
+/**
+ * Load an image from an SDL data source into a GPU texture.
+ *
+ * An SDL_Texture represents an image in GPU memory, usable by SDL's 2D Render
+ * API. This can be significantly more efficient than using a CPU-bound
+ * SDL_Surface if you don't need to manipulate the image directly after
+ * loading it.
+ *
+ * If the loaded image has transparency or a colorkey, a texture with an alpha
+ * channel will be created. Otherwise, SDL_image will attempt to create an
+ * SDL_Texture in the most format that most reasonably represents the image
+ * data (but in many cases, this will just end up being 32-bit RGB or 32-bit
+ * RGBA).
+ *
+ * If `freesrc` is non-zero, the RWops will be closed before returning,
+ * whether this function succeeds or not. SDL_image reads everything it needs
+ * from the RWops during this call in any case.
+ *
+ * There is a separate function to read files from disk without having to deal
+ * with SDL_RWops: `IMG_LoadTexture(renderer, "filename.jpg")` will call this
+ * function and manage those details for you, determining the file type from
+ * the filename's extension.
+ *
+ * There is also IMG_LoadTextureTyped_RW(), which is equivalent to this
+ * function except a file extension (like "BMP", "JPG", etc) can be specified,
+ * in case SDL_image cannot autodetect the file format.
+ *
+ * If you would rather decode an image to an SDL_Surface (a buffer of pixels
+ * in CPU memory), call IMG_Load() instead.
+ *
+ * When done with the returned texture, the app should dispose of it with a
+ * call to SDL_DestroyTexture().
+ *
+ * \param renderer the SDL_Renderer to use to create the GPU texture.
+ * \param src an SDL_RWops that data will be read from.
+ * \param freesrc non-zero to close/free the SDL_RWops before returning, zero
+ *                to leave it open.
+ * \returns a new texture, or NULL on error.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_LoadTexture
+ * \sa IMG_LoadTextureTyped_RW
+ * \sa SDL_DestroyTexture
+ */
+extern DECLSPEC SDL_Texture * SDLCALL IMG_LoadTexture_RW(SDL_Renderer *renderer, SDL_RWops *src, int freesrc);
+
+/**
+ * Load an image from an SDL data source into a GPU texture.
+ *
+ * An SDL_Texture represents an image in GPU memory, usable by SDL's 2D Render
+ * API. This can be significantly more efficient than using a CPU-bound
+ * SDL_Surface if you don't need to manipulate the image directly after
+ * loading it.
+ *
+ * If the loaded image has transparency or a colorkey, a texture with an alpha
+ * channel will be created. Otherwise, SDL_image will attempt to create an
+ * SDL_Texture in the most format that most reasonably represents the image
+ * data (but in many cases, this will just end up being 32-bit RGB or 32-bit
+ * RGBA).
+ *
+ * If `freesrc` is non-zero, the RWops will be closed before returning,
+ * whether this function succeeds or not. SDL_image reads everything it needs
+ * from the RWops during this call in any case.
+ *
+ * Even though this function accepts a file type, SDL_image may still try
+ * other decoders that are capable of detecting file type from the contents of
+ * the image data, but may rely on the caller-provided type string for formats
+ * that it cannot autodetect. If `type` is NULL, SDL_image will rely solely on
+ * its ability to guess the format.
+ *
+ * There is a separate function to read files from disk without having to deal
+ * with SDL_RWops: `IMG_LoadTexture("filename.jpg")` will call this function
+ * and manage those details for you, determining the file type from the
+ * filename's extension.
+ *
+ * There is also IMG_LoadTexture_RW(), which is equivalent to this function
+ * except that it will rely on SDL_image to determine what type of data it is
+ * loading, much like passing a NULL for type.
+ *
+ * If you would rather decode an image to an SDL_Surface (a buffer of pixels
+ * in CPU memory), call IMG_LoadTyped_RW() instead.
+ *
+ * When done with the returned texture, the app should dispose of it with a
+ * call to SDL_DestroyTexture().
+ *
+ * \param renderer the SDL_Renderer to use to create the GPU texture.
+ * \param src an SDL_RWops that data will be read from.
+ * \param freesrc non-zero to close/free the SDL_RWops before returning, zero
+ *                to leave it open.
+ * \param type a filename extension that represent this data ("BMP", "GIF",
+ *             "PNG", etc).
+ * \returns a new texture, or NULL on error.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_LoadTexture
+ * \sa IMG_LoadTexture_RW
+ * \sa SDL_DestroyTexture
+ */
+extern DECLSPEC SDL_Texture * SDLCALL IMG_LoadTextureTyped_RW(SDL_Renderer *renderer, SDL_RWops *src, int freesrc, const char *type);
+#endif /* SDL 2.0 */
+
+/**
+ * Detect AVIF image data on a readable/seekable SDL_RWops.
+ *
+ * This function attempts to determine if a file is a given filetype, reading
+ * the least amount possible from the SDL_RWops (usually a few bytes).
+ *
+ * There is no distinction made between "not the filetype in question" and
+ * basic i/o errors.
+ *
+ * This function will always attempt to seek the RWops back to where it
+ * started when this function was called, but it will not report any errors in
+ * doing so, but assuming seeking works, this means you can immediately use
+ * this with a different IMG_isTYPE function, or load the image without
+ * further seeking.
+ *
+ * You do not need to call this function to load data; SDL_image can work to
+ * determine file type in many cases in its standard load functions.
+ *
+ * \param src a seekable/readable SDL_RWops to provide image data.
+ * \returns non-zero if this is AVIF data, zero otherwise.
+ *
+ * \since This function is available since SDL_image 2.6.0.
+ *
+ * \sa IMG_isAVIF
+ * \sa IMG_isICO
+ * \sa IMG_isCUR
+ * \sa IMG_isBMP
+ * \sa IMG_isGIF
+ * \sa IMG_isJPG
+ * \sa IMG_isJXL
+ * \sa IMG_isLBM
+ * \sa IMG_isPCX
+ * \sa IMG_isPNG
+ * \sa IMG_isPNM
+ * \sa IMG_isSVG
+ * \sa IMG_isQOI
+ * \sa IMG_isTIF
+ * \sa IMG_isXCF
+ * \sa IMG_isXPM
+ * \sa IMG_isXV
+ * \sa IMG_isWEBP
+ */
+extern DECLSPEC int SDLCALL IMG_isAVIF(SDL_RWops *src);
+
+/**
+ * Detect ICO image data on a readable/seekable SDL_RWops.
+ *
+ * This function attempts to determine if a file is a given filetype, reading
+ * the least amount possible from the SDL_RWops (usually a few bytes).
+ *
+ * There is no distinction made between "not the filetype in question" and
+ * basic i/o errors.
+ *
+ * This function will always attempt to seek the RWops back to where it
+ * started when this function was called, but it will not report any errors in
+ * doing so, but assuming seeking works, this means you can immediately use
+ * this with a different IMG_isTYPE function, or load the image without
+ * further seeking.
+ *
+ * You do not need to call this function to load data; SDL_image can work to
+ * determine file type in many cases in its standard load functions.
+ *
+ * \param src a seekable/readable SDL_RWops to provide image data.
+ * \returns non-zero if this is ICO data, zero otherwise.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_isAVIF
+ * \sa IMG_isCUR
+ * \sa IMG_isBMP
+ * \sa IMG_isGIF
+ * \sa IMG_isJPG
+ * \sa IMG_isJXL
+ * \sa IMG_isLBM
+ * \sa IMG_isPCX
+ * \sa IMG_isPNG
+ * \sa IMG_isPNM
+ * \sa IMG_isSVG
+ * \sa IMG_isQOI
+ * \sa IMG_isTIF
+ * \sa IMG_isXCF
+ * \sa IMG_isXPM
+ * \sa IMG_isXV
+ * \sa IMG_isWEBP
+ */
+extern DECLSPEC int SDLCALL IMG_isICO(SDL_RWops *src);
+
+/**
+ * Detect CUR image data on a readable/seekable SDL_RWops.
+ *
+ * This function attempts to determine if a file is a given filetype, reading
+ * the least amount possible from the SDL_RWops (usually a few bytes).
+ *
+ * There is no distinction made between "not the filetype in question" and
+ * basic i/o errors.
+ *
+ * This function will always attempt to seek the RWops back to where it
+ * started when this function was called, but it will not report any errors in
+ * doing so, but assuming seeking works, this means you can immediately use
+ * this with a different IMG_isTYPE function, or load the image without
+ * further seeking.
+ *
+ * You do not need to call this function to load data; SDL_image can work to
+ * determine file type in many cases in its standard load functions.
+ *
+ * \param src a seekable/readable SDL_RWops to provide image data.
+ * \returns non-zero if this is CUR data, zero otherwise.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_isAVIF
+ * \sa IMG_isICO
+ * \sa IMG_isBMP
+ * \sa IMG_isGIF
+ * \sa IMG_isJPG
+ * \sa IMG_isJXL
+ * \sa IMG_isLBM
+ * \sa IMG_isPCX
+ * \sa IMG_isPNG
+ * \sa IMG_isPNM
+ * \sa IMG_isSVG
+ * \sa IMG_isQOI
+ * \sa IMG_isTIF
+ * \sa IMG_isXCF
+ * \sa IMG_isXPM
+ * \sa IMG_isXV
+ * \sa IMG_isWEBP
+ */
+extern DECLSPEC int SDLCALL IMG_isCUR(SDL_RWops *src);
+
+/**
+ * Detect BMP image data on a readable/seekable SDL_RWops.
+ *
+ * This function attempts to determine if a file is a given filetype, reading
+ * the least amount possible from the SDL_RWops (usually a few bytes).
+ *
+ * There is no distinction made between "not the filetype in question" and
+ * basic i/o errors.
+ *
+ * This function will always attempt to seek the RWops back to where it
+ * started when this function was called, but it will not report any errors in
+ * doing so, but assuming seeking works, this means you can immediately use
+ * this with a different IMG_isTYPE function, or load the image without
+ * further seeking.
+ *
+ * You do not need to call this function to load data; SDL_image can work to
+ * determine file type in many cases in its standard load functions.
+ *
+ * \param src a seekable/readable SDL_RWops to provide image data.
+ * \returns non-zero if this is BMP data, zero otherwise.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_isAVIF
+ * \sa IMG_isICO
+ * \sa IMG_isCUR
+ * \sa IMG_isGIF
+ * \sa IMG_isJPG
+ * \sa IMG_isJXL
+ * \sa IMG_isLBM
+ * \sa IMG_isPCX
+ * \sa IMG_isPNG
+ * \sa IMG_isPNM
+ * \sa IMG_isSVG
+ * \sa IMG_isQOI
+ * \sa IMG_isTIF
+ * \sa IMG_isXCF
+ * \sa IMG_isXPM
+ * \sa IMG_isXV
+ * \sa IMG_isWEBP
+ */
+extern DECLSPEC int SDLCALL IMG_isBMP(SDL_RWops *src);
+
+/**
+ * Detect GIF image data on a readable/seekable SDL_RWops.
+ *
+ * This function attempts to determine if a file is a given filetype, reading
+ * the least amount possible from the SDL_RWops (usually a few bytes).
+ *
+ * There is no distinction made between "not the filetype in question" and
+ * basic i/o errors.
+ *
+ * This function will always attempt to seek the RWops back to where it
+ * started when this function was called, but it will not report any errors in
+ * doing so, but assuming seeking works, this means you can immediately use
+ * this with a different IMG_isTYPE function, or load the image without
+ * further seeking.
+ *
+ * You do not need to call this function to load data; SDL_image can work to
+ * determine file type in many cases in its standard load functions.
+ *
+ * \param src a seekable/readable SDL_RWops to provide image data.
+ * \returns non-zero if this is GIF data, zero otherwise.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_isAVIF
+ * \sa IMG_isICO
+ * \sa IMG_isCUR
+ * \sa IMG_isBMP
+ * \sa IMG_isJPG
+ * \sa IMG_isJXL
+ * \sa IMG_isLBM
+ * \sa IMG_isPCX
+ * \sa IMG_isPNG
+ * \sa IMG_isPNM
+ * \sa IMG_isSVG
+ * \sa IMG_isQOI
+ * \sa IMG_isTIF
+ * \sa IMG_isXCF
+ * \sa IMG_isXPM
+ * \sa IMG_isXV
+ * \sa IMG_isWEBP
+ */
+extern DECLSPEC int SDLCALL IMG_isGIF(SDL_RWops *src);
+
+/**
+ * Detect JPG image data on a readable/seekable SDL_RWops.
+ *
+ * This function attempts to determine if a file is a given filetype, reading
+ * the least amount possible from the SDL_RWops (usually a few bytes).
+ *
+ * There is no distinction made between "not the filetype in question" and
+ * basic i/o errors.
+ *
+ * This function will always attempt to seek the RWops back to where it
+ * started when this function was called, but it will not report any errors in
+ * doing so, but assuming seeking works, this means you can immediately use
+ * this with a different IMG_isTYPE function, or load the image without
+ * further seeking.
+ *
+ * You do not need to call this function to load data; SDL_image can work to
+ * determine file type in many cases in its standard load functions.
+ *
+ * \param src a seekable/readable SDL_RWops to provide image data.
+ * \returns non-zero if this is JPG data, zero otherwise.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_isAVIF
+ * \sa IMG_isICO
+ * \sa IMG_isCUR
+ * \sa IMG_isBMP
+ * \sa IMG_isGIF
+ * \sa IMG_isJXL
+ * \sa IMG_isLBM
+ * \sa IMG_isPCX
+ * \sa IMG_isPNG
+ * \sa IMG_isPNM
+ * \sa IMG_isSVG
+ * \sa IMG_isQOI
+ * \sa IMG_isTIF
+ * \sa IMG_isXCF
+ * \sa IMG_isXPM
+ * \sa IMG_isXV
+ * \sa IMG_isWEBP
+ */
+extern DECLSPEC int SDLCALL IMG_isJPG(SDL_RWops *src);
+
+/**
+ * Detect JXL image data on a readable/seekable SDL_RWops.
+ *
+ * This function attempts to determine if a file is a given filetype, reading
+ * the least amount possible from the SDL_RWops (usually a few bytes).
+ *
+ * There is no distinction made between "not the filetype in question" and
+ * basic i/o errors.
+ *
+ * This function will always attempt to seek the RWops back to where it
+ * started when this function was called, but it will not report any errors in
+ * doing so, but assuming seeking works, this means you can immediately use
+ * this with a different IMG_isTYPE function, or load the image without
+ * further seeking.
+ *
+ * You do not need to call this function to load data; SDL_image can work to
+ * determine file type in many cases in its standard load functions.
+ *
+ * \param src a seekable/readable SDL_RWops to provide image data.
+ * \returns non-zero if this is JXL data, zero otherwise.
+ *
+ * \since This function is available since SDL_image 2.6.0.
+ *
+ * \sa IMG_isAVIF
+ * \sa IMG_isICO
+ * \sa IMG_isCUR
+ * \sa IMG_isBMP
+ * \sa IMG_isGIF
+ * \sa IMG_isJPG
+ * \sa IMG_isLBM
+ * \sa IMG_isPCX
+ * \sa IMG_isPNG
+ * \sa IMG_isPNM
+ * \sa IMG_isSVG
+ * \sa IMG_isQOI
+ * \sa IMG_isTIF
+ * \sa IMG_isXCF
+ * \sa IMG_isXPM
+ * \sa IMG_isXV
+ * \sa IMG_isWEBP
+ */
+extern DECLSPEC int SDLCALL IMG_isJXL(SDL_RWops *src);
+
+/**
+ * Detect LBM image data on a readable/seekable SDL_RWops.
+ *
+ * This function attempts to determine if a file is a given filetype, reading
+ * the least amount possible from the SDL_RWops (usually a few bytes).
+ *
+ * There is no distinction made between "not the filetype in question" and
+ * basic i/o errors.
+ *
+ * This function will always attempt to seek the RWops back to where it
+ * started when this function was called, but it will not report any errors in
+ * doing so, but assuming seeking works, this means you can immediately use
+ * this with a different IMG_isTYPE function, or load the image without
+ * further seeking.
+ *
+ * You do not need to call this function to load data; SDL_image can work to
+ * determine file type in many cases in its standard load functions.
+ *
+ * \param src a seekable/readable SDL_RWops to provide image data.
+ * \returns non-zero if this is LBM data, zero otherwise.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_isAVIF
+ * \sa IMG_isICO
+ * \sa IMG_isCUR
+ * \sa IMG_isBMP
+ * \sa IMG_isGIF
+ * \sa IMG_isJPG
+ * \sa IMG_isJXL
+ * \sa IMG_isPCX
+ * \sa IMG_isPNG
+ * \sa IMG_isPNM
+ * \sa IMG_isSVG
+ * \sa IMG_isQOI
+ * \sa IMG_isTIF
+ * \sa IMG_isXCF
+ * \sa IMG_isXPM
+ * \sa IMG_isXV
+ * \sa IMG_isWEBP
+ */
+extern DECLSPEC int SDLCALL IMG_isLBM(SDL_RWops *src);
+
+/**
+ * Detect PCX image data on a readable/seekable SDL_RWops.
+ *
+ * This function attempts to determine if a file is a given filetype, reading
+ * the least amount possible from the SDL_RWops (usually a few bytes).
+ *
+ * There is no distinction made between "not the filetype in question" and
+ * basic i/o errors.
+ *
+ * This function will always attempt to seek the RWops back to where it
+ * started when this function was called, but it will not report any errors in
+ * doing so, but assuming seeking works, this means you can immediately use
+ * this with a different IMG_isTYPE function, or load the image without
+ * further seeking.
+ *
+ * You do not need to call this function to load data; SDL_image can work to
+ * determine file type in many cases in its standard load functions.
+ *
+ * \param src a seekable/readable SDL_RWops to provide image data.
+ * \returns non-zero if this is PCX data, zero otherwise.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_isAVIF
+ * \sa IMG_isICO
+ * \sa IMG_isCUR
+ * \sa IMG_isBMP
+ * \sa IMG_isGIF
+ * \sa IMG_isJPG
+ * \sa IMG_isJXL
+ * \sa IMG_isLBM
+ * \sa IMG_isPNG
+ * \sa IMG_isPNM
+ * \sa IMG_isSVG
+ * \sa IMG_isQOI
+ * \sa IMG_isTIF
+ * \sa IMG_isXCF
+ * \sa IMG_isXPM
+ * \sa IMG_isXV
+ * \sa IMG_isWEBP
+ */
+extern DECLSPEC int SDLCALL IMG_isPCX(SDL_RWops *src);
+
+/**
+ * Detect PNG image data on a readable/seekable SDL_RWops.
+ *
+ * This function attempts to determine if a file is a given filetype, reading
+ * the least amount possible from the SDL_RWops (usually a few bytes).
+ *
+ * There is no distinction made between "not the filetype in question" and
+ * basic i/o errors.
+ *
+ * This function will always attempt to seek the RWops back to where it
+ * started when this function was called, but it will not report any errors in
+ * doing so, but assuming seeking works, this means you can immediately use
+ * this with a different IMG_isTYPE function, or load the image without
+ * further seeking.
+ *
+ * You do not need to call this function to load data; SDL_image can work to
+ * determine file type in many cases in its standard load functions.
+ *
+ * \param src a seekable/readable SDL_RWops to provide image data.
+ * \returns non-zero if this is PNG data, zero otherwise.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_isAVIF
+ * \sa IMG_isICO
+ * \sa IMG_isCUR
+ * \sa IMG_isBMP
+ * \sa IMG_isGIF
+ * \sa IMG_isJPG
+ * \sa IMG_isJXL
+ * \sa IMG_isLBM
+ * \sa IMG_isPCX
+ * \sa IMG_isPNM
+ * \sa IMG_isSVG
+ * \sa IMG_isQOI
+ * \sa IMG_isTIF
+ * \sa IMG_isXCF
+ * \sa IMG_isXPM
+ * \sa IMG_isXV
+ * \sa IMG_isWEBP
+ */
+extern DECLSPEC int SDLCALL IMG_isPNG(SDL_RWops *src);
+
+/**
+ * Detect PNM image data on a readable/seekable SDL_RWops.
+ *
+ * This function attempts to determine if a file is a given filetype, reading
+ * the least amount possible from the SDL_RWops (usually a few bytes).
+ *
+ * There is no distinction made between "not the filetype in question" and
+ * basic i/o errors.
+ *
+ * This function will always attempt to seek the RWops back to where it
+ * started when this function was called, but it will not report any errors in
+ * doing so, but assuming seeking works, this means you can immediately use
+ * this with a different IMG_isTYPE function, or load the image without
+ * further seeking.
+ *
+ * You do not need to call this function to load data; SDL_image can work to
+ * determine file type in many cases in its standard load functions.
+ *
+ * \param src a seekable/readable SDL_RWops to provide image data.
+ * \returns non-zero if this is PNM data, zero otherwise.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_isAVIF
+ * \sa IMG_isICO
+ * \sa IMG_isCUR
+ * \sa IMG_isBMP
+ * \sa IMG_isGIF
+ * \sa IMG_isJPG
+ * \sa IMG_isJXL
+ * \sa IMG_isLBM
+ * \sa IMG_isPCX
+ * \sa IMG_isPNG
+ * \sa IMG_isSVG
+ * \sa IMG_isQOI
+ * \sa IMG_isTIF
+ * \sa IMG_isXCF
+ * \sa IMG_isXPM
+ * \sa IMG_isXV
+ * \sa IMG_isWEBP
+ */
+extern DECLSPEC int SDLCALL IMG_isPNM(SDL_RWops *src);
+
+/**
+ * Detect SVG image data on a readable/seekable SDL_RWops.
+ *
+ * This function attempts to determine if a file is a given filetype, reading
+ * the least amount possible from the SDL_RWops (usually a few bytes).
+ *
+ * There is no distinction made between "not the filetype in question" and
+ * basic i/o errors.
+ *
+ * This function will always attempt to seek the RWops back to where it
+ * started when this function was called, but it will not report any errors in
+ * doing so, but assuming seeking works, this means you can immediately use
+ * this with a different IMG_isTYPE function, or load the image without
+ * further seeking.
+ *
+ * You do not need to call this function to load data; SDL_image can work to
+ * determine file type in many cases in its standard load functions.
+ *
+ * \param src a seekable/readable SDL_RWops to provide image data.
+ * \returns non-zero if this is SVG data, zero otherwise.
+ *
+ * \since This function is available since SDL_image 2.0.2.
+ *
+ * \sa IMG_isAVIF
+ * \sa IMG_isICO
+ * \sa IMG_isCUR
+ * \sa IMG_isBMP
+ * \sa IMG_isGIF
+ * \sa IMG_isJPG
+ * \sa IMG_isJXL
+ * \sa IMG_isLBM
+ * \sa IMG_isPCX
+ * \sa IMG_isPNG
+ * \sa IMG_isPNM
+ * \sa IMG_isQOI
+ * \sa IMG_isTIF
+ * \sa IMG_isXCF
+ * \sa IMG_isXPM
+ * \sa IMG_isXV
+ * \sa IMG_isWEBP
+ */
+extern DECLSPEC int SDLCALL IMG_isSVG(SDL_RWops *src);
+
+/**
+ * Detect QOI image data on a readable/seekable SDL_RWops.
+ *
+ * This function attempts to determine if a file is a given filetype, reading
+ * the least amount possible from the SDL_RWops (usually a few bytes).
+ *
+ * There is no distinction made between "not the filetype in question" and
+ * basic i/o errors.
+ *
+ * This function will always attempt to seek the RWops back to where it
+ * started when this function was called, but it will not report any errors in
+ * doing so, but assuming seeking works, this means you can immediately use
+ * this with a different IMG_isTYPE function, or load the image without
+ * further seeking.
+ *
+ * You do not need to call this function to load data; SDL_image can work to
+ * determine file type in many cases in its standard load functions.
+ *
+ * \param src a seekable/readable SDL_RWops to provide image data.
+ * \returns non-zero if this is QOI data, zero otherwise.
+ *
+ * \since This function is available since SDL_image 2.6.0.
+ *
+ * \sa IMG_isAVIF
+ * \sa IMG_isICO
+ * \sa IMG_isCUR
+ * \sa IMG_isBMP
+ * \sa IMG_isGIF
+ * \sa IMG_isJPG
+ * \sa IMG_isJXL
+ * \sa IMG_isLBM
+ * \sa IMG_isPCX
+ * \sa IMG_isPNG
+ * \sa IMG_isPNM
+ * \sa IMG_isSVG
+ * \sa IMG_isTIF
+ * \sa IMG_isXCF
+ * \sa IMG_isXPM
+ * \sa IMG_isXV
+ * \sa IMG_isWEBP
+ */
+extern DECLSPEC int SDLCALL IMG_isQOI(SDL_RWops *src);
+
+/**
+ * Detect TIFF image data on a readable/seekable SDL_RWops.
+ *
+ * This function attempts to determine if a file is a given filetype, reading
+ * the least amount possible from the SDL_RWops (usually a few bytes).
+ *
+ * There is no distinction made between "not the filetype in question" and
+ * basic i/o errors.
+ *
+ * This function will always attempt to seek the RWops back to where it
+ * started when this function was called, but it will not report any errors in
+ * doing so, but assuming seeking works, this means you can immediately use
+ * this with a different IMG_isTYPE function, or load the image without
+ * further seeking.
+ *
+ * You do not need to call this function to load data; SDL_image can work to
+ * determine file type in many cases in its standard load functions.
+ *
+ * \param src a seekable/readable SDL_RWops to provide image data.
+ * \returns non-zero if this is TIFF data, zero otherwise.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_isAVIF
+ * \sa IMG_isICO
+ * \sa IMG_isCUR
+ * \sa IMG_isBMP
+ * \sa IMG_isGIF
+ * \sa IMG_isJPG
+ * \sa IMG_isJXL
+ * \sa IMG_isLBM
+ * \sa IMG_isPCX
+ * \sa IMG_isPNG
+ * \sa IMG_isPNM
+ * \sa IMG_isSVG
+ * \sa IMG_isQOI
+ * \sa IMG_isXCF
+ * \sa IMG_isXPM
+ * \sa IMG_isXV
+ * \sa IMG_isWEBP
+ */
+extern DECLSPEC int SDLCALL IMG_isTIF(SDL_RWops *src);
+
+/**
+ * Detect XCF image data on a readable/seekable SDL_RWops.
+ *
+ * This function attempts to determine if a file is a given filetype, reading
+ * the least amount possible from the SDL_RWops (usually a few bytes).
+ *
+ * There is no distinction made between "not the filetype in question" and
+ * basic i/o errors.
+ *
+ * This function will always attempt to seek the RWops back to where it
+ * started when this function was called, but it will not report any errors in
+ * doing so, but assuming seeking works, this means you can immediately use
+ * this with a different IMG_isTYPE function, or load the image without
+ * further seeking.
+ *
+ * You do not need to call this function to load data; SDL_image can work to
+ * determine file type in many cases in its standard load functions.
+ *
+ * \param src a seekable/readable SDL_RWops to provide image data.
+ * \returns non-zero if this is XCF data, zero otherwise.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_isAVIF
+ * \sa IMG_isICO
+ * \sa IMG_isCUR
+ * \sa IMG_isBMP
+ * \sa IMG_isGIF
+ * \sa IMG_isJPG
+ * \sa IMG_isJXL
+ * \sa IMG_isLBM
+ * \sa IMG_isPCX
+ * \sa IMG_isPNG
+ * \sa IMG_isPNM
+ * \sa IMG_isSVG
+ * \sa IMG_isQOI
+ * \sa IMG_isTIF
+ * \sa IMG_isXPM
+ * \sa IMG_isXV
+ * \sa IMG_isWEBP
+ */
+extern DECLSPEC int SDLCALL IMG_isXCF(SDL_RWops *src);
+
+/**
+ * Detect XPM image data on a readable/seekable SDL_RWops.
+ *
+ * This function attempts to determine if a file is a given filetype, reading
+ * the least amount possible from the SDL_RWops (usually a few bytes).
+ *
+ * There is no distinction made between "not the filetype in question" and
+ * basic i/o errors.
+ *
+ * This function will always attempt to seek the RWops back to where it
+ * started when this function was called, but it will not report any errors in
+ * doing so, but assuming seeking works, this means you can immediately use
+ * this with a different IMG_isTYPE function, or load the image without
+ * further seeking.
+ *
+ * You do not need to call this function to load data; SDL_image can work to
+ * determine file type in many cases in its standard load functions.
+ *
+ * \param src a seekable/readable SDL_RWops to provide image data.
+ * \returns non-zero if this is XPM data, zero otherwise.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_isAVIF
+ * \sa IMG_isICO
+ * \sa IMG_isCUR
+ * \sa IMG_isBMP
+ * \sa IMG_isGIF
+ * \sa IMG_isJPG
+ * \sa IMG_isJXL
+ * \sa IMG_isLBM
+ * \sa IMG_isPCX
+ * \sa IMG_isPNG
+ * \sa IMG_isPNM
+ * \sa IMG_isSVG
+ * \sa IMG_isQOI
+ * \sa IMG_isTIF
+ * \sa IMG_isXCF
+ * \sa IMG_isXV
+ * \sa IMG_isWEBP
+ */
+extern DECLSPEC int SDLCALL IMG_isXPM(SDL_RWops *src);
+
+/**
+ * Detect XV image data on a readable/seekable SDL_RWops.
+ *
+ * This function attempts to determine if a file is a given filetype, reading
+ * the least amount possible from the SDL_RWops (usually a few bytes).
+ *
+ * There is no distinction made between "not the filetype in question" and
+ * basic i/o errors.
+ *
+ * This function will always attempt to seek the RWops back to where it
+ * started when this function was called, but it will not report any errors in
+ * doing so, but assuming seeking works, this means you can immediately use
+ * this with a different IMG_isTYPE function, or load the image without
+ * further seeking.
+ *
+ * You do not need to call this function to load data; SDL_image can work to
+ * determine file type in many cases in its standard load functions.
+ *
+ * \param src a seekable/readable SDL_RWops to provide image data.
+ * \returns non-zero if this is XV data, zero otherwise.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_isAVIF
+ * \sa IMG_isICO
+ * \sa IMG_isCUR
+ * \sa IMG_isBMP
+ * \sa IMG_isGIF
+ * \sa IMG_isJPG
+ * \sa IMG_isJXL
+ * \sa IMG_isLBM
+ * \sa IMG_isPCX
+ * \sa IMG_isPNG
+ * \sa IMG_isPNM
+ * \sa IMG_isSVG
+ * \sa IMG_isQOI
+ * \sa IMG_isTIF
+ * \sa IMG_isXCF
+ * \sa IMG_isXPM
+ * \sa IMG_isWEBP
+ */
+extern DECLSPEC int SDLCALL IMG_isXV(SDL_RWops *src);
+
+/**
+ * Detect WEBP image data on a readable/seekable SDL_RWops.
+ *
+ * This function attempts to determine if a file is a given filetype, reading
+ * the least amount possible from the SDL_RWops (usually a few bytes).
+ *
+ * There is no distinction made between "not the filetype in question" and
+ * basic i/o errors.
+ *
+ * This function will always attempt to seek the RWops back to where it
+ * started when this function was called, but it will not report any errors in
+ * doing so, but assuming seeking works, this means you can immediately use
+ * this with a different IMG_isTYPE function, or load the image without
+ * further seeking.
+ *
+ * You do not need to call this function to load data; SDL_image can work to
+ * determine file type in many cases in its standard load functions.
+ *
+ * \param src a seekable/readable SDL_RWops to provide image data.
+ * \returns non-zero if this is WEBP data, zero otherwise.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_isAVIF
+ * \sa IMG_isICO
+ * \sa IMG_isCUR
+ * \sa IMG_isBMP
+ * \sa IMG_isGIF
+ * \sa IMG_isJPG
+ * \sa IMG_isJXL
+ * \sa IMG_isLBM
+ * \sa IMG_isPCX
+ * \sa IMG_isPNG
+ * \sa IMG_isPNM
+ * \sa IMG_isSVG
+ * \sa IMG_isQOI
+ * \sa IMG_isTIF
+ * \sa IMG_isXCF
+ * \sa IMG_isXPM
+ * \sa IMG_isXV
+ */
+extern DECLSPEC int SDLCALL IMG_isWEBP(SDL_RWops *src);
+
+/**
+ * Load a AVIF image directly.
+ *
+ * If you know you definitely have a AVIF image, you can call this function,
+ * which will skip SDL_image's file format detection routines. Generally it's
+ * better to use the abstract interfaces; also, there is only an SDL_RWops
+ * interface available here.
+ *
+ * \param src an SDL_RWops to load image data from.
+ * \returns SDL surface, or NULL on error
+ *
+ * \since This function is available since SDL_image 2.6.0.
+ *
+ * \sa IMG_LoadICO_RW
+ * \sa IMG_LoadCUR_RW
+ * \sa IMG_LoadBMP_RW
+ * \sa IMG_LoadGIF_RW
+ * \sa IMG_LoadJPG_RW
+ * \sa IMG_LoadJXL_RW
+ * \sa IMG_LoadLBM_RW
+ * \sa IMG_LoadPCX_RW
+ * \sa IMG_LoadPNG_RW
+ * \sa IMG_LoadPNM_RW
+ * \sa IMG_LoadSVG_RW
+ * \sa IMG_LoadQOI_RW
+ * \sa IMG_LoadTGA_RW
+ * \sa IMG_LoadTIF_RW
+ * \sa IMG_LoadXCF_RW
+ * \sa IMG_LoadXPM_RW
+ * \sa IMG_LoadXV_RW
+ * \sa IMG_LoadWEBP_RW
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadAVIF_RW(SDL_RWops *src);
+
+/**
+ * Load a ICO image directly.
+ *
+ * If you know you definitely have a ICO image, you can call this function,
+ * which will skip SDL_image's file format detection routines. Generally it's
+ * better to use the abstract interfaces; also, there is only an SDL_RWops
+ * interface available here.
+ *
+ * \param src an SDL_RWops to load image data from.
+ * \returns SDL surface, or NULL on error
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_LoadAVIF_RW
+ * \sa IMG_LoadCUR_RW
+ * \sa IMG_LoadBMP_RW
+ * \sa IMG_LoadGIF_RW
+ * \sa IMG_LoadJPG_RW
+ * \sa IMG_LoadJXL_RW
+ * \sa IMG_LoadLBM_RW
+ * \sa IMG_LoadPCX_RW
+ * \sa IMG_LoadPNG_RW
+ * \sa IMG_LoadPNM_RW
+ * \sa IMG_LoadSVG_RW
+ * \sa IMG_LoadQOI_RW
+ * \sa IMG_LoadTGA_RW
+ * \sa IMG_LoadTIF_RW
+ * \sa IMG_LoadXCF_RW
+ * \sa IMG_LoadXPM_RW
+ * \sa IMG_LoadXV_RW
+ * \sa IMG_LoadWEBP_RW
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadICO_RW(SDL_RWops *src);
+
+/**
+ * Load a CUR image directly.
+ *
+ * If you know you definitely have a CUR image, you can call this function,
+ * which will skip SDL_image's file format detection routines. Generally it's
+ * better to use the abstract interfaces; also, there is only an SDL_RWops
+ * interface available here.
+ *
+ * \param src an SDL_RWops to load image data from.
+ * \returns SDL surface, or NULL on error
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_LoadAVIF_RW
+ * \sa IMG_LoadICO_RW
+ * \sa IMG_LoadBMP_RW
+ * \sa IMG_LoadGIF_RW
+ * \sa IMG_LoadJPG_RW
+ * \sa IMG_LoadJXL_RW
+ * \sa IMG_LoadLBM_RW
+ * \sa IMG_LoadPCX_RW
+ * \sa IMG_LoadPNG_RW
+ * \sa IMG_LoadPNM_RW
+ * \sa IMG_LoadSVG_RW
+ * \sa IMG_LoadQOI_RW
+ * \sa IMG_LoadTGA_RW
+ * \sa IMG_LoadTIF_RW
+ * \sa IMG_LoadXCF_RW
+ * \sa IMG_LoadXPM_RW
+ * \sa IMG_LoadXV_RW
+ * \sa IMG_LoadWEBP_RW
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadCUR_RW(SDL_RWops *src);
+
+/**
+ * Load a BMP image directly.
+ *
+ * If you know you definitely have a BMP image, you can call this function,
+ * which will skip SDL_image's file format detection routines. Generally it's
+ * better to use the abstract interfaces; also, there is only an SDL_RWops
+ * interface available here.
+ *
+ * \param src an SDL_RWops to load image data from.
+ * \returns SDL surface, or NULL on error
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_LoadAVIF_RW
+ * \sa IMG_LoadICO_RW
+ * \sa IMG_LoadCUR_RW
+ * \sa IMG_LoadGIF_RW
+ * \sa IMG_LoadJPG_RW
+ * \sa IMG_LoadJXL_RW
+ * \sa IMG_LoadLBM_RW
+ * \sa IMG_LoadPCX_RW
+ * \sa IMG_LoadPNG_RW
+ * \sa IMG_LoadPNM_RW
+ * \sa IMG_LoadSVG_RW
+ * \sa IMG_LoadQOI_RW
+ * \sa IMG_LoadTGA_RW
+ * \sa IMG_LoadTIF_RW
+ * \sa IMG_LoadXCF_RW
+ * \sa IMG_LoadXPM_RW
+ * \sa IMG_LoadXV_RW
+ * \sa IMG_LoadWEBP_RW
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadBMP_RW(SDL_RWops *src);
+
+/**
+ * Load a GIF image directly.
+ *
+ * If you know you definitely have a GIF image, you can call this function,
+ * which will skip SDL_image's file format detection routines. Generally it's
+ * better to use the abstract interfaces; also, there is only an SDL_RWops
+ * interface available here.
+ *
+ * \param src an SDL_RWops to load image data from.
+ * \returns SDL surface, or NULL on error
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_LoadAVIF_RW
+ * \sa IMG_LoadICO_RW
+ * \sa IMG_LoadCUR_RW
+ * \sa IMG_LoadBMP_RW
+ * \sa IMG_LoadJPG_RW
+ * \sa IMG_LoadJXL_RW
+ * \sa IMG_LoadLBM_RW
+ * \sa IMG_LoadPCX_RW
+ * \sa IMG_LoadPNG_RW
+ * \sa IMG_LoadPNM_RW
+ * \sa IMG_LoadSVG_RW
+ * \sa IMG_LoadQOI_RW
+ * \sa IMG_LoadTGA_RW
+ * \sa IMG_LoadTIF_RW
+ * \sa IMG_LoadXCF_RW
+ * \sa IMG_LoadXPM_RW
+ * \sa IMG_LoadXV_RW
+ * \sa IMG_LoadWEBP_RW
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadGIF_RW(SDL_RWops *src);
+
+/**
+ * Load a JPG image directly.
+ *
+ * If you know you definitely have a JPG image, you can call this function,
+ * which will skip SDL_image's file format detection routines. Generally it's
+ * better to use the abstract interfaces; also, there is only an SDL_RWops
+ * interface available here.
+ *
+ * \param src an SDL_RWops to load image data from.
+ * \returns SDL surface, or NULL on error
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_LoadAVIF_RW
+ * \sa IMG_LoadICO_RW
+ * \sa IMG_LoadCUR_RW
+ * \sa IMG_LoadBMP_RW
+ * \sa IMG_LoadGIF_RW
+ * \sa IMG_LoadJXL_RW
+ * \sa IMG_LoadLBM_RW
+ * \sa IMG_LoadPCX_RW
+ * \sa IMG_LoadPNG_RW
+ * \sa IMG_LoadPNM_RW
+ * \sa IMG_LoadSVG_RW
+ * \sa IMG_LoadQOI_RW
+ * \sa IMG_LoadTGA_RW
+ * \sa IMG_LoadTIF_RW
+ * \sa IMG_LoadXCF_RW
+ * \sa IMG_LoadXPM_RW
+ * \sa IMG_LoadXV_RW
+ * \sa IMG_LoadWEBP_RW
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadJPG_RW(SDL_RWops *src);
+
+/**
+ * Load a JXL image directly.
+ *
+ * If you know you definitely have a JXL image, you can call this function,
+ * which will skip SDL_image's file format detection routines. Generally it's
+ * better to use the abstract interfaces; also, there is only an SDL_RWops
+ * interface available here.
+ *
+ * \param src an SDL_RWops to load image data from.
+ * \returns SDL surface, or NULL on error
+ *
+ * \since This function is available since SDL_image 2.6.0.
+ *
+ * \sa IMG_LoadAVIF_RW
+ * \sa IMG_LoadICO_RW
+ * \sa IMG_LoadCUR_RW
+ * \sa IMG_LoadBMP_RW
+ * \sa IMG_LoadGIF_RW
+ * \sa IMG_LoadJPG_RW
+ * \sa IMG_LoadLBM_RW
+ * \sa IMG_LoadPCX_RW
+ * \sa IMG_LoadPNG_RW
+ * \sa IMG_LoadPNM_RW
+ * \sa IMG_LoadSVG_RW
+ * \sa IMG_LoadQOI_RW
+ * \sa IMG_LoadTGA_RW
+ * \sa IMG_LoadTIF_RW
+ * \sa IMG_LoadXCF_RW
+ * \sa IMG_LoadXPM_RW
+ * \sa IMG_LoadXV_RW
+ * \sa IMG_LoadWEBP_RW
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadJXL_RW(SDL_RWops *src);
+
+/**
+ * Load a LBM image directly.
+ *
+ * If you know you definitely have a LBM image, you can call this function,
+ * which will skip SDL_image's file format detection routines. Generally it's
+ * better to use the abstract interfaces; also, there is only an SDL_RWops
+ * interface available here.
+ *
+ * \param src an SDL_RWops to load image data from.
+ * \returns SDL surface, or NULL on error
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_LoadAVIF_RW
+ * \sa IMG_LoadICO_RW
+ * \sa IMG_LoadCUR_RW
+ * \sa IMG_LoadBMP_RW
+ * \sa IMG_LoadGIF_RW
+ * \sa IMG_LoadJPG_RW
+ * \sa IMG_LoadJXL_RW
+ * \sa IMG_LoadPCX_RW
+ * \sa IMG_LoadPNG_RW
+ * \sa IMG_LoadPNM_RW
+ * \sa IMG_LoadSVG_RW
+ * \sa IMG_LoadQOI_RW
+ * \sa IMG_LoadTGA_RW
+ * \sa IMG_LoadTIF_RW
+ * \sa IMG_LoadXCF_RW
+ * \sa IMG_LoadXPM_RW
+ * \sa IMG_LoadXV_RW
+ * \sa IMG_LoadWEBP_RW
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadLBM_RW(SDL_RWops *src);
+
+/**
+ * Load a PCX image directly.
+ *
+ * If you know you definitely have a PCX image, you can call this function,
+ * which will skip SDL_image's file format detection routines. Generally it's
+ * better to use the abstract interfaces; also, there is only an SDL_RWops
+ * interface available here.
+ *
+ * \param src an SDL_RWops to load image data from.
+ * \returns SDL surface, or NULL on error
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_LoadAVIF_RW
+ * \sa IMG_LoadICO_RW
+ * \sa IMG_LoadCUR_RW
+ * \sa IMG_LoadBMP_RW
+ * \sa IMG_LoadGIF_RW
+ * \sa IMG_LoadJPG_RW
+ * \sa IMG_LoadJXL_RW
+ * \sa IMG_LoadLBM_RW
+ * \sa IMG_LoadPNG_RW
+ * \sa IMG_LoadPNM_RW
+ * \sa IMG_LoadSVG_RW
+ * \sa IMG_LoadQOI_RW
+ * \sa IMG_LoadTGA_RW
+ * \sa IMG_LoadTIF_RW
+ * \sa IMG_LoadXCF_RW
+ * \sa IMG_LoadXPM_RW
+ * \sa IMG_LoadXV_RW
+ * \sa IMG_LoadWEBP_RW
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadPCX_RW(SDL_RWops *src);
+
+/**
+ * Load a PNG image directly.
+ *
+ * If you know you definitely have a PNG image, you can call this function,
+ * which will skip SDL_image's file format detection routines. Generally it's
+ * better to use the abstract interfaces; also, there is only an SDL_RWops
+ * interface available here.
+ *
+ * \param src an SDL_RWops to load image data from.
+ * \returns SDL surface, or NULL on error
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_LoadAVIF_RW
+ * \sa IMG_LoadICO_RW
+ * \sa IMG_LoadCUR_RW
+ * \sa IMG_LoadBMP_RW
+ * \sa IMG_LoadGIF_RW
+ * \sa IMG_LoadJPG_RW
+ * \sa IMG_LoadJXL_RW
+ * \sa IMG_LoadLBM_RW
+ * \sa IMG_LoadPCX_RW
+ * \sa IMG_LoadPNM_RW
+ * \sa IMG_LoadSVG_RW
+ * \sa IMG_LoadQOI_RW
+ * \sa IMG_LoadTGA_RW
+ * \sa IMG_LoadTIF_RW
+ * \sa IMG_LoadXCF_RW
+ * \sa IMG_LoadXPM_RW
+ * \sa IMG_LoadXV_RW
+ * \sa IMG_LoadWEBP_RW
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadPNG_RW(SDL_RWops *src);
+
+/**
+ * Load a PNM image directly.
+ *
+ * If you know you definitely have a PNM image, you can call this function,
+ * which will skip SDL_image's file format detection routines. Generally it's
+ * better to use the abstract interfaces; also, there is only an SDL_RWops
+ * interface available here.
+ *
+ * \param src an SDL_RWops to load image data from.
+ * \returns SDL surface, or NULL on error
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_LoadAVIF_RW
+ * \sa IMG_LoadICO_RW
+ * \sa IMG_LoadCUR_RW
+ * \sa IMG_LoadBMP_RW
+ * \sa IMG_LoadGIF_RW
+ * \sa IMG_LoadJPG_RW
+ * \sa IMG_LoadJXL_RW
+ * \sa IMG_LoadLBM_RW
+ * \sa IMG_LoadPCX_RW
+ * \sa IMG_LoadPNG_RW
+ * \sa IMG_LoadSVG_RW
+ * \sa IMG_LoadQOI_RW
+ * \sa IMG_LoadTGA_RW
+ * \sa IMG_LoadTIF_RW
+ * \sa IMG_LoadXCF_RW
+ * \sa IMG_LoadXPM_RW
+ * \sa IMG_LoadXV_RW
+ * \sa IMG_LoadWEBP_RW
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadPNM_RW(SDL_RWops *src);
+
+/**
+ * Load a SVG image directly.
+ *
+ * If you know you definitely have a SVG image, you can call this function,
+ * which will skip SDL_image's file format detection routines. Generally it's
+ * better to use the abstract interfaces; also, there is only an SDL_RWops
+ * interface available here.
+ *
+ * \param src an SDL_RWops to load image data from.
+ * \returns SDL surface, or NULL on error
+ *
+ * \since This function is available since SDL_image 2.0.2.
+ *
+ * \sa IMG_LoadAVIF_RW
+ * \sa IMG_LoadICO_RW
+ * \sa IMG_LoadCUR_RW
+ * \sa IMG_LoadBMP_RW
+ * \sa IMG_LoadGIF_RW
+ * \sa IMG_LoadJPG_RW
+ * \sa IMG_LoadJXL_RW
+ * \sa IMG_LoadLBM_RW
+ * \sa IMG_LoadPCX_RW
+ * \sa IMG_LoadPNG_RW
+ * \sa IMG_LoadPNM_RW
+ * \sa IMG_LoadQOI_RW
+ * \sa IMG_LoadTGA_RW
+ * \sa IMG_LoadTIF_RW
+ * \sa IMG_LoadXCF_RW
+ * \sa IMG_LoadXPM_RW
+ * \sa IMG_LoadXV_RW
+ * \sa IMG_LoadWEBP_RW
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadSVG_RW(SDL_RWops *src);
+
+/**
+ * Load a QOI image directly.
+ *
+ * If you know you definitely have a QOI image, you can call this function,
+ * which will skip SDL_image's file format detection routines. Generally it's
+ * better to use the abstract interfaces; also, there is only an SDL_RWops
+ * interface available here.
+ *
+ * \param src an SDL_RWops to load image data from.
+ * \returns SDL surface, or NULL on error
+ *
+ * \since This function is available since SDL_image 2.6.0.
+ *
+ * \sa IMG_LoadAVIF_RW
+ * \sa IMG_LoadICO_RW
+ * \sa IMG_LoadCUR_RW
+ * \sa IMG_LoadBMP_RW
+ * \sa IMG_LoadGIF_RW
+ * \sa IMG_LoadJPG_RW
+ * \sa IMG_LoadJXL_RW
+ * \sa IMG_LoadLBM_RW
+ * \sa IMG_LoadPCX_RW
+ * \sa IMG_LoadPNG_RW
+ * \sa IMG_LoadPNM_RW
+ * \sa IMG_LoadSVG_RW
+ * \sa IMG_LoadTGA_RW
+ * \sa IMG_LoadTIF_RW
+ * \sa IMG_LoadXCF_RW
+ * \sa IMG_LoadXPM_RW
+ * \sa IMG_LoadXV_RW
+ * \sa IMG_LoadWEBP_RW
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadQOI_RW(SDL_RWops *src);
+
+/**
+ * Load a TGA image directly.
+ *
+ * If you know you definitely have a TGA image, you can call this function,
+ * which will skip SDL_image's file format detection routines. Generally it's
+ * better to use the abstract interfaces; also, there is only an SDL_RWops
+ * interface available here.
+ *
+ * \param src an SDL_RWops to load image data from.
+ * \returns SDL surface, or NULL on error
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_LoadAVIF_RW
+ * \sa IMG_LoadICO_RW
+ * \sa IMG_LoadCUR_RW
+ * \sa IMG_LoadBMP_RW
+ * \sa IMG_LoadGIF_RW
+ * \sa IMG_LoadJPG_RW
+ * \sa IMG_LoadJXL_RW
+ * \sa IMG_LoadLBM_RW
+ * \sa IMG_LoadPCX_RW
+ * \sa IMG_LoadPNG_RW
+ * \sa IMG_LoadPNM_RW
+ * \sa IMG_LoadSVG_RW
+ * \sa IMG_LoadQOI_RW
+ * \sa IMG_LoadTIF_RW
+ * \sa IMG_LoadXCF_RW
+ * \sa IMG_LoadXPM_RW
+ * \sa IMG_LoadXV_RW
+ * \sa IMG_LoadWEBP_RW
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadTGA_RW(SDL_RWops *src);
+
+/**
+ * Load a TIFF image directly.
+ *
+ * If you know you definitely have a TIFF image, you can call this function,
+ * which will skip SDL_image's file format detection routines. Generally it's
+ * better to use the abstract interfaces; also, there is only an SDL_RWops
+ * interface available here.
+ *
+ * \param src an SDL_RWops to load image data from.
+ * \returns SDL surface, or NULL on error
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_LoadAVIF_RW
+ * \sa IMG_LoadICO_RW
+ * \sa IMG_LoadCUR_RW
+ * \sa IMG_LoadBMP_RW
+ * \sa IMG_LoadGIF_RW
+ * \sa IMG_LoadJPG_RW
+ * \sa IMG_LoadJXL_RW
+ * \sa IMG_LoadLBM_RW
+ * \sa IMG_LoadPCX_RW
+ * \sa IMG_LoadPNG_RW
+ * \sa IMG_LoadPNM_RW
+ * \sa IMG_LoadSVG_RW
+ * \sa IMG_LoadQOI_RW
+ * \sa IMG_LoadTGA_RW
+ * \sa IMG_LoadXCF_RW
+ * \sa IMG_LoadXPM_RW
+ * \sa IMG_LoadXV_RW
+ * \sa IMG_LoadWEBP_RW
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadTIF_RW(SDL_RWops *src);
+
+/**
+ * Load a XCF image directly.
+ *
+ * If you know you definitely have a XCF image, you can call this function,
+ * which will skip SDL_image's file format detection routines. Generally it's
+ * better to use the abstract interfaces; also, there is only an SDL_RWops
+ * interface available here.
+ *
+ * \param src an SDL_RWops to load image data from.
+ * \returns SDL surface, or NULL on error
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_LoadAVIF_RW
+ * \sa IMG_LoadICO_RW
+ * \sa IMG_LoadCUR_RW
+ * \sa IMG_LoadBMP_RW
+ * \sa IMG_LoadGIF_RW
+ * \sa IMG_LoadJPG_RW
+ * \sa IMG_LoadJXL_RW
+ * \sa IMG_LoadLBM_RW
+ * \sa IMG_LoadPCX_RW
+ * \sa IMG_LoadPNG_RW
+ * \sa IMG_LoadPNM_RW
+ * \sa IMG_LoadSVG_RW
+ * \sa IMG_LoadQOI_RW
+ * \sa IMG_LoadTGA_RW
+ * \sa IMG_LoadTIF_RW
+ * \sa IMG_LoadXPM_RW
+ * \sa IMG_LoadXV_RW
+ * \sa IMG_LoadWEBP_RW
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadXCF_RW(SDL_RWops *src);
+
+/**
+ * Load a XPM image directly.
+ *
+ * If you know you definitely have a XPM image, you can call this function,
+ * which will skip SDL_image's file format detection routines. Generally it's
+ * better to use the abstract interfaces; also, there is only an SDL_RWops
+ * interface available here.
+ *
+ * \param src an SDL_RWops to load image data from.
+ * \returns SDL surface, or NULL on error
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_LoadAVIF_RW
+ * \sa IMG_LoadICO_RW
+ * \sa IMG_LoadCUR_RW
+ * \sa IMG_LoadBMP_RW
+ * \sa IMG_LoadGIF_RW
+ * \sa IMG_LoadJPG_RW
+ * \sa IMG_LoadJXL_RW
+ * \sa IMG_LoadLBM_RW
+ * \sa IMG_LoadPCX_RW
+ * \sa IMG_LoadPNG_RW
+ * \sa IMG_LoadPNM_RW
+ * \sa IMG_LoadSVG_RW
+ * \sa IMG_LoadQOI_RW
+ * \sa IMG_LoadTGA_RW
+ * \sa IMG_LoadTIF_RW
+ * \sa IMG_LoadXCF_RW
+ * \sa IMG_LoadXV_RW
+ * \sa IMG_LoadWEBP_RW
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadXPM_RW(SDL_RWops *src);
+
+/**
+ * Load a XV image directly.
+ *
+ * If you know you definitely have a XV image, you can call this function,
+ * which will skip SDL_image's file format detection routines. Generally it's
+ * better to use the abstract interfaces; also, there is only an SDL_RWops
+ * interface available here.
+ *
+ * \param src an SDL_RWops to load image data from.
+ * \returns SDL surface, or NULL on error
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_LoadAVIF_RW
+ * \sa IMG_LoadICO_RW
+ * \sa IMG_LoadCUR_RW
+ * \sa IMG_LoadBMP_RW
+ * \sa IMG_LoadGIF_RW
+ * \sa IMG_LoadJPG_RW
+ * \sa IMG_LoadJXL_RW
+ * \sa IMG_LoadLBM_RW
+ * \sa IMG_LoadPCX_RW
+ * \sa IMG_LoadPNG_RW
+ * \sa IMG_LoadPNM_RW
+ * \sa IMG_LoadSVG_RW
+ * \sa IMG_LoadQOI_RW
+ * \sa IMG_LoadTGA_RW
+ * \sa IMG_LoadTIF_RW
+ * \sa IMG_LoadXCF_RW
+ * \sa IMG_LoadXPM_RW
+ * \sa IMG_LoadWEBP_RW
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadXV_RW(SDL_RWops *src);
+
+/**
+ * Load a WEBP image directly.
+ *
+ * If you know you definitely have a WEBP image, you can call this function,
+ * which will skip SDL_image's file format detection routines. Generally it's
+ * better to use the abstract interfaces; also, there is only an SDL_RWops
+ * interface available here.
+ *
+ * \param src an SDL_RWops to load image data from.
+ * \returns SDL surface, or NULL on error
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_LoadAVIF_RW
+ * \sa IMG_LoadICO_RW
+ * \sa IMG_LoadCUR_RW
+ * \sa IMG_LoadBMP_RW
+ * \sa IMG_LoadGIF_RW
+ * \sa IMG_LoadJPG_RW
+ * \sa IMG_LoadJXL_RW
+ * \sa IMG_LoadLBM_RW
+ * \sa IMG_LoadPCX_RW
+ * \sa IMG_LoadPNG_RW
+ * \sa IMG_LoadPNM_RW
+ * \sa IMG_LoadSVG_RW
+ * \sa IMG_LoadQOI_RW
+ * \sa IMG_LoadTGA_RW
+ * \sa IMG_LoadTIF_RW
+ * \sa IMG_LoadXCF_RW
+ * \sa IMG_LoadXPM_RW
+ * \sa IMG_LoadXV_RW
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadWEBP_RW(SDL_RWops *src);
+
+/**
+ * Load an SVG image, scaled to a specific size.
+ *
+ * Since SVG files are resolution-independent, you specify the size you would
+ * like the output image to be and it will be generated at those dimensions.
+ *
+ * Either width or height may be 0 and the image will be auto-sized to
+ * preserve aspect ratio.
+ *
+ * When done with the returned surface, the app should dispose of it with a
+ * call to SDL_FreeSurface().
+ *
+ * \param src an SDL_RWops to load SVG data from.
+ * \param width desired width of the generated surface, in pixels.
+ * \param height desired height of the generated surface, in pixels.
+ * \returns a new SDL surface, or NULL on error.
+ *
+ * \since This function is available since SDL_image 2.6.0.
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_LoadSizedSVG_RW(SDL_RWops *src, int width, int height);
+
+/**
+ * Load an XPM image from a memory array.
+ *
+ * The returned surface will be an 8bpp indexed surface, if possible,
+ * otherwise it will be 32bpp. If you always want 32-bit data, use
+ * IMG_ReadXPMFromArrayToRGB888() instead.
+ *
+ * When done with the returned surface, the app should dispose of it with a
+ * call to SDL_FreeSurface().
+ *
+ * \param xpm a null-terminated array of strings that comprise XPM data.
+ * \returns a new SDL surface, or NULL on error.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_ReadXPMFromArrayToRGB888
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_ReadXPMFromArray(char **xpm);
+
+/**
+ * Load an XPM image from a memory array.
+ *
+ * The returned surface will always be a 32-bit RGB surface. If you want 8-bit
+ * indexed colors (and the XPM data allows it), use IMG_ReadXPMFromArray()
+ * instead.
+ *
+ * When done with the returned surface, the app should dispose of it with a
+ * call to SDL_FreeSurface().
+ *
+ * \param xpm a null-terminated array of strings that comprise XPM data.
+ * \returns a new SDL surface, or NULL on error.
+ *
+ * \since This function is available since SDL_image 2.6.0.
+ *
+ * \sa IMG_ReadXPMFromArray
+ */
+extern DECLSPEC SDL_Surface * SDLCALL IMG_ReadXPMFromArrayToRGB888(char **xpm);
+
+/**
+ * Save an SDL_Surface into a PNG image file.
+ *
+ * If the file already exists, it will be overwritten.
+ *
+ * \param surface the SDL surface to save
+ * \param file path on the filesystem to write new file to.
+ * \returns 0 if successful, -1 on error
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_SavePNG_RW
+ * \sa IMG_SaveJPG
+ * \sa IMG_SaveJPG_RW
+ */
+extern DECLSPEC int SDLCALL IMG_SavePNG(SDL_Surface *surface, const char *file);
+
+/**
+ * Save an SDL_Surface into PNG image data, via an SDL_RWops.
+ *
+ * If you just want to save to a filename, you can use IMG_SavePNG() instead.
+ *
+ * \param surface the SDL surface to save
+ * \param dst the SDL_RWops to save the image data to.
+ * \returns 0 if successful, -1 on error.
+ *
+ * \since This function is available since SDL_image 2.0.0.
+ *
+ * \sa IMG_SavePNG
+ * \sa IMG_SaveJPG
+ * \sa IMG_SaveJPG_RW
+ */
+extern DECLSPEC int SDLCALL IMG_SavePNG_RW(SDL_Surface *surface, SDL_RWops *dst, int freedst);
+
+/**
+ * Save an SDL_Surface into a JPEG image file.
+ *
+ * If the file already exists, it will be overwritten.
+ *
+ * \param surface the SDL surface to save
+ * \param file path on the filesystem to write new file to.
+ * \param quality [0; 33] is Lowest quality, [34; 66] is Middle quality, [67;
+ *                100] is Highest quality
+ * \returns 0 if successful, -1 on error
+ *
+ * \since This function is available since SDL_image 2.0.2.
+ *
+ * \sa IMG_SaveJPG_RW
+ * \sa IMG_SavePNG
+ * \sa IMG_SavePNG_RW
+ */
+extern DECLSPEC int SDLCALL IMG_SaveJPG(SDL_Surface *surface, const char *file, int quality);
+
+/**
+ * Save an SDL_Surface into JPEG image data, via an SDL_RWops.
+ *
+ * If you just want to save to a filename, you can use IMG_SaveJPG() instead.
+ *
+ * \param surface the SDL surface to save
+ * \param dst the SDL_RWops to save the image data to.
+ * \returns 0 if successful, -1 on error.
+ *
+ * \since This function is available since SDL_image 2.0.2.
+ *
+ * \sa IMG_SaveJPG
+ * \sa IMG_SavePNG
+ * \sa IMG_SavePNG_RW
+ */
+extern DECLSPEC int SDLCALL IMG_SaveJPG_RW(SDL_Surface *surface, SDL_RWops *dst, int freedst, int quality);
+
+/**
+ * Animated image support
+ * Currently only animated GIFs are supported.
+ */
+typedef struct
+{
+	int w, h;
+	int count;
+	SDL_Surface **frames;
+	int *delays;
+} IMG_Animation;
+
+/**
+ * Load an animation from a file.
+ *
+ * When done with the returned animation, the app should dispose of it with a
+ * call to IMG_FreeAnimation().
+ *
+ * \param file path on the filesystem containing an animated image.
+ * \returns a new IMG_Animation, or NULL on error.
+ *
+ * \since This function is available since SDL_image 2.6.0.
+ *
+ * \sa IMG_FreeAnimation
+ */
+extern DECLSPEC IMG_Animation * SDLCALL IMG_LoadAnimation(const char *file);
+
+/**
+ * Load an animation from an SDL_RWops.
+ *
+ * If `freesrc` is non-zero, the RWops will be closed before returning,
+ * whether this function succeeds or not. SDL_image reads everything it needs
+ * from the RWops during this call in any case.
+ *
+ * When done with the returned animation, the app should dispose of it with a
+ * call to IMG_FreeAnimation().
+ *
+ * \param src an SDL_RWops that data will be read from.
+ * \param freesrc non-zero to close/free the SDL_RWops before returning, zero
+ *                to leave it open.
+ * \returns a new IMG_Animation, or NULL on error.
+ *
+ * \since This function is available since SDL_image 2.6.0.
+ *
+ * \sa IMG_FreeAnimation
+ */
+extern DECLSPEC IMG_Animation * SDLCALL IMG_LoadAnimation_RW(SDL_RWops *src, int freesrc);
+
+/**
+ * Load an animation from an SDL datasource
+ *
+ * Even though this function accepts a file type, SDL_image may still try
+ * other decoders that are capable of detecting file type from the contents of
+ * the image data, but may rely on the caller-provided type string for formats
+ * that it cannot autodetect. If `type` is NULL, SDL_image will rely solely on
+ * its ability to guess the format.
+ *
+ * If `freesrc` is non-zero, the RWops will be closed before returning,
+ * whether this function succeeds or not. SDL_image reads everything it needs
+ * from the RWops during this call in any case.
+ *
+ * When done with the returned animation, the app should dispose of it with a
+ * call to IMG_FreeAnimation().
+ *
+ * \param src an SDL_RWops that data will be read from.
+ * \param freesrc non-zero to close/free the SDL_RWops before returning, zero
+ *                to leave it open.
+ * \param type a filename extension that represent this data ("GIF", etc).
+ * \returns a new IMG_Animation, or NULL on error.
+ *
+ * \since This function is available since SDL_image 2.6.0.
+ *
+ * \sa IMG_LoadAnimation
+ * \sa IMG_LoadAnimation_RW
+ * \sa IMG_FreeAnimation
+ */
+extern DECLSPEC IMG_Animation * SDLCALL IMG_LoadAnimationTyped_RW(SDL_RWops *src, int freesrc, const char *type);
+
+/**
+ * Dispose of an IMG_Animation and free its resources.
+ *
+ * The provided `anim` pointer is not valid once this call returns.
+ *
+ * \param anim IMG_Animation to dispose of.
+ *
+ * \since This function is available since SDL_image 2.6.0.
+ *
+ * \sa IMG_LoadAnimation
+ * \sa IMG_LoadAnimation_RW
+ * \sa IMG_LoadAnimationTyped_RW
+ */
+extern DECLSPEC void SDLCALL IMG_FreeAnimation(IMG_Animation *anim);
+
+/**
+ * Load a GIF animation directly.
+ *
+ * If you know you definitely have a GIF image, you can call this function,
+ * which will skip SDL_image's file format detection routines. Generally it's
+ * better to use the abstract interfaces; also, there is only an SDL_RWops
+ * interface available here.
+ *
+ * \param src an SDL_RWops that data will be read from.
+ * \returns a new IMG_Animation, or NULL on error.
+ *
+ * \since This function is available since SDL_image 2.6.0.
+ *
+ * \sa IMG_LoadAnimation
+ * \sa IMG_LoadAnimation_RW
+ * \sa IMG_LoadAnimationTyped_RW
+ * \sa IMG_FreeAnimation
+ */
+extern DECLSPEC IMG_Animation * SDLCALL IMG_LoadGIFAnimation_RW(SDL_RWops *src);
+
+/**
+ * Report SDL_image errors
+ *
+ * \sa IMG_GetError
+ */
+#define IMG_SetError    SDL_SetError
+
+/**
+ * Get last SDL_image error
+ *
+ * \sa IMG_SetError
+ */
+#define IMG_GetError    SDL_GetError
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+
+#endif /* SDL_IMAGE_H_ */
diff --git a/src/lib/cmake/SDL2_image/sdl2_image-config-version.cmake b/src/lib/cmake/SDL2_image/sdl2_image-config-version.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..f1c018fb1c05b8bba2e554a96fe729cc553c4586
--- /dev/null
+++ b/src/lib/cmake/SDL2_image/sdl2_image-config-version.cmake
@@ -0,0 +1,13 @@
+# sdl2_image cmake project-config-version input for ./configure scripts
+
+set(PACKAGE_VERSION "@MAJOR_VERSION_MACRO@.@MINOR_VERSION_MACRO@.@MICRO_VERSION_MACRO@")
+
+if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
+  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+  set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+    set(PACKAGE_VERSION_EXACT TRUE)
+  endif()
+endif()
+
diff --git a/src/lib/cmake/SDL2_image/sdl2_image-config.cmake b/src/lib/cmake/SDL2_image/sdl2_image-config.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..b44f780871e7ac9f35d12ca79de28344247cc051
--- /dev/null
+++ b/src/lib/cmake/SDL2_image/sdl2_image-config.cmake
@@ -0,0 +1,99 @@
+# sdl2_image cmake project-config input for ./configure scripts
+
+include(FeatureSummary)
+set_package_properties(SDL2_image PROPERTIES
+    URL "https://www.libsdl.org/projects/SDL_image/"
+    DESCRIPTION "SDL_image is an image file loading library"
+)
+
+set(SDL2_image_FOUND TRUE)
+
+set(SDL2IMAGE_AVIF  0)
+set(SDL2IMAGE_BMP   1)
+set(SDL2IMAGE_GIF   1)
+set(SDL2IMAGE_JPG   1)
+set(SDL2IMAGE_JXL   0)
+set(SDL2IMAGE_LBM   1)
+set(SDL2IMAGE_PCX   1)
+set(SDL2IMAGE_PNG   1)
+set(SDL2IMAGE_PNM   1)
+set(SDL2IMAGE_QOI   1)
+set(SDL2IMAGE_SVG   1)
+set(SDL2IMAGE_TGA   1)
+set(SDL2IMAGE_TIF   0)
+set(SDL2IMAGE_XCF   1)
+set(SDL2IMAGE_XPM   1)
+set(SDL2IMAGE_XV    1)
+set(SDL2IMAGE_WEBP  0)
+
+set(SDL2IMAGE_JPG_SAVE 1)
+set(SDL2IMAGE_PNG_SAVE 1)
+
+set(SDL2IMAGE_VENDORED  FALSE)
+
+set(SDL2IMAGE_BACKEND_IMAGEIO   0)
+set(SDL2IMAGE_BACKEND_STB       1)
+set(SDL2IMAGE_BACKEND_WIC       0)
+
+get_filename_component(prefix "${CMAKE_CURRENT_LIST_DIR}/../../.." ABSOLUTE)
+set(exec_prefix "${prefix}")
+set(bindir "${exec_prefix}/bin")
+set(includedir "${prefix}/include")
+set(libdir "${exec_prefix}/lib")
+set(_sdl2image_extra_static_libraries " ")
+string(STRIP "${_sdl2image_extra_static_libraries}" _sdl2image_extra_static_libraries)
+
+set(_sdl2image_bindir   "${bindir}")
+set(_sdl2image_libdir   "${libdir}")
+set(_sdl2image_incdir   "${includedir}/SDL2")
+
+# Convert _sdl2image_extra_static_libraries to list and keep only libraries
+string(REGEX MATCHALL "(-[lm]([-a-zA-Z0-9._]+))|(-Wl,[^ ]*framework[^ ]*)" _sdl2image_extra_static_libraries "${_sdl2image_extra_static_libraries}")
+string(REGEX REPLACE "^-l" "" _sdl2image_extra_static_libraries "${_sdl2image_extra_static_libraries}")
+string(REGEX REPLACE ";-l" ";" _sdl2image_extra_static_libraries "${_sdl2image_extra_static_libraries}")
+
+unset(prefix)
+unset(exec_prefix)
+unset(bindir)
+unset(includedir)
+unset(libdir)
+
+include(CMakeFindDependencyMacro)
+
+if(NOT TARGET SDL2_image::SDL2_image)
+    add_library(SDL2_image::SDL2_image SHARED IMPORTED)
+    set_target_properties(SDL2_image::SDL2_image
+        PROPERTIES
+            INTERFACE_INCLUDE_DIRECTORIES "${_sdl2image_incdir}"
+            COMPATIBLE_INTERFACE_BOOL "SDL2_SHARED"
+            INTERFACE_SDL2_SHARED "ON"
+    )
+    if(WIN32)
+        set_target_properties(SDL2_image::SDL2_image
+            PROPERTIES
+                IMPORTED_LOCATION "${_sdl2image_bindir}/SDL2_image.dll"
+                IMPORTED_IMPLIB "${_sdl2image_libdir}/${CMAKE_STATIC_LIBRARY_PREFIX}SDL2_image.dll${CMAKE_STATIC_LIBRARY_SUFFIX}"
+        )
+    else()
+        set_target_properties(SDL2_image::SDL2_image
+            PROPERTIES
+                IMPORTED_LOCATION "${_sdl2image_libdir}/${CMAKE_SHARED_LIBRARY_PREFIX}SDL2_image${CMAKE_SHARED_LIBRARY_SUFFIX}"
+        )
+    endif()
+endif()
+
+if(NOT TARGET SDL2_image::SDL2_image-static)
+    add_library(SDL2_image::SDL2_image-static STATIC IMPORTED)
+
+    set_target_properties(SDL2_image::SDL2_image-static
+        PROPERTIES
+            INTERFACE_INCLUDE_DIRECTORIES "${_sdl2image_incdir}"
+            IMPORTED_LOCATION "${_sdl2image_libdir}/${CMAKE_STATIC_LIBRARY_PREFIX}SDL2_image${CMAKE_STATIC_LIBRARY_SUFFIX}"
+            INTERFACE_LINK_LIBRARIES "${_sdl2image_extra_static_libraries}"
+    )
+endif()
+
+unset(_sdl2image_extra_static_libraries)
+unset(_sdl2image_bindir)
+unset(_sdl2image_libdir)
+unset(_sdl2image_incdir)
diff --git a/src/lib/libSDL2_image.a b/src/lib/libSDL2_image.a
new file mode 100644
index 0000000000000000000000000000000000000000..cb70378e264389b84af5a37b9fa74e40e7032761
Binary files /dev/null and b/src/lib/libSDL2_image.a differ
diff --git a/src/lib/libSDL2_image.dll.a b/src/lib/libSDL2_image.dll.a
new file mode 100644
index 0000000000000000000000000000000000000000..457287c3c424e752d1aafdbb8f4cb1c84778dbaa
Binary files /dev/null and b/src/lib/libSDL2_image.dll.a differ
diff --git a/src/lib/libSDL2_image.la b/src/lib/libSDL2_image.la
new file mode 100644
index 0000000000000000000000000000000000000000..e6e7747880d99954f7a5d122290f7ebcc5948b2c
--- /dev/null
+++ b/src/lib/libSDL2_image.la
@@ -0,0 +1,41 @@
+# libSDL2_image.la - a libtool library file
+# Generated by ltmain.sh (GNU libtool) 2.2.6
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# The name that we can dlopen(3).
+dlname='../bin/SDL2_image.dll'
+
+# Names of this library.
+library_names='libSDL2_image.dll.a'
+
+# The name of the static archive.
+old_library='libSDL2_image.a'
+
+# Linker flags that can not go in dependency_libs.
+inherited_linker_flags=''
+
+# Libraries that this one depends upon.
+dependency_libs=' -L/usr/local/x86_64-w64-mingw32/lib -lmingw32 /usr/local/x86_64-w64-mingw32/lib/libSDL2.la -ldinput8 -ldxguid -ldxerr8 -luser32 -lgdi32 -lwinmm -limm32 -lole32 -loleaut32 -lshell32 -lsetupapi -lversion -luuid'
+
+# Names of additional weak libraries provided by this library
+weak_library_names=''
+
+# Version information for libSDL2_image.
+current=600
+age=600
+revision=3
+
+# Is this an already installed library?
+installed=yes
+
+# Should we warn about portability when linking against -modules?
+shouldnotlink=no
+
+# Files to dlopen/dlpreopen
+dlopen=''
+dlpreopen=''
+
+# Directory that this library needs to be installed in:
+libdir='/Users/valve/release/SDL_image/SDL2_image-2.6.3/x86_64-w64-mingw32/lib'
diff --git a/src/lib/pkgconfig/SDL2_image.pc b/src/lib/pkgconfig/SDL2_image.pc
new file mode 100644
index 0000000000000000000000000000000000000000..6061761c7eef669fc6cd31a0bb19c6f120b63618
--- /dev/null
+++ b/src/lib/pkgconfig/SDL2_image.pc
@@ -0,0 +1,14 @@
+prefix=/x86_64-w64-mingw32
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: SDL2_image
+Description: image loading library for Simple DirectMedia Layer
+Version: 2.6.3
+Requires: sdl2 >= 2.0.9
+Libs: -L${libdir} -lSDL2_image
+Requires.private: 
+Libs.private: 
+Cflags: -I${includedir}/SDL2
+