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 +