Bonjour à tous, je suis actuellement en train d'essayer de créer un mini-jeu grâce à la SDL2.
J'ai choisi cette bibliothèque car j'ai des petites connaissances en c++ console et en terme d'optimisation et performances, le c/c++ est ce qu'il y a de mieux (de ce que j'ai vu sur beaucoup de forums...)
Le problème, c'est l'affichage d'image et les tout ce qui est SDL_Surface, SDL_Renderer, SDL_Textures, c'est quoi exactement, des couches ?
Pour afficher les images, j'utilise bien sûr SDL2image car créer des images de merde en bmp, hahaha qui utilise ce format de merde !!!
Fond d'écran -> .jpg / Transparence -> .png
Voici tout mon code :
#include <SDL.h>
#include <SDL_image.h>
#include <iostream>
#include <cstring>
using namespace std;
unsigned short int a = 0, b = 0;
char *un;
int main(int argc, char *argv[]) {
SDL_Init(SDL_INIT_VIDEO);
IMG_Init(IMG_INIT_JPG);
SDL_Window *load = SDL_CreateWindow("Load", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 400, 50, SDL_WINDOW_SHOWN | SDL_WINDOW_BORDERLESS);
SDL_Window *menu = SDL_CreateWindow("Menu", 5, 35, 0, 0, SDL_WINDOW_SHOWN);
SDL_Renderer *rendu = SDL_CreateRenderer(load, -1, SDL_RENDERER_ACCELERATED || SDL_RENDERER_PRESENTVSYNC);
SDL_SetWindowFullscreen(load, SDL_FALSE);
SDL_SetWindowResizable(load, SDL_FALSE);
SDL_SetRenderDrawColor(rendu, 255, 0, 0, 255);
SDL_Event ev;
bool actived = false;
while (!actived) {
while (SDL_PollEvent(&ev) != 0) {
SDL_Rect pb = { 0, 0, a, 50 };
SDL_RenderFillRect(rendu, &pb);
SDL_RenderPresent(rendu);
SDL_Delay(35);
if (a < 400)
a = a + b + 1;
b++;
if (a > 400) {
SDL_DestroyWindow(load);
SDL_SetWindowSize(menu, 1280, 720);
string type = "Ice";
string pos = "10";
SDL_Renderer *sprite = SDL_CreateRenderer(menu, -1, SDL_RENDERER_ACCELERATED || SDL_RENDERER_PRESENTVSYNC);
SDL_Rect img = { 0, 0, 121, 121 };
SDL_RenderPresent(sprite);
string localisation = "runes/support/" + type + "/" + type + pos + ".png";
char *un = new char[localisation.size() + 1]; //Convertion string to char
std::strncpy(un, localisation.c_str(), localisation.size()); // Convertion string to char
cout << un << endl; // Ecrit dans la console : runes/support/Ice/Ice10.png═2222 (pourquoi les =2222, allez savoir !!)
SDL_Surface *image = IMG_Load(un);
delete[] un; // Sert à libérer de la place ?
SDL_BlitSurface(image, NULL, image, &img);
if (!image) {
cout << "Erreur de chargement de l'image : " << SDL_GetError(); // affiche l'erreur classique présente dans tous les forums : Erreur de chargement de l'image : SDL_UpperBlit: passed a NULL surface
system("pause");
}
SDL_UpdateWindowSurface(menu);
}
switch (ev.type) {
case SDL_QUIT: actived = true;
break;
case SDL_KEYDOWN:
switch (ev.key.keysym.sym) {
case SDLK_0: actived = true;
break;
case SDLK_1: b = 500;
break;
}
}
}
}
SDL_DestroyRenderer(rendu);
SDL_DestroyWindow(load);
SDL_DestroyWindow(menu);
IMG_Quit();
SDL_Quit();
return 1;
}
Bien sûr certaines variables ont été créé pour la suite, elle ne sont pas encore utilisées.
Cette erreur est présente dans de nombreux forums mais les pages de codes étaient complètement différentes et les explications étaient des jeux de pistes, qui ne m'ont pas amené au trésor...
Je vois pas trop pourquoi tu t'emmerdes à copier ça dans un char* (beurk). Pour le =2222, n'est-ce pas parce que ton pointeur ne se termine pas par '\0' ?
Sinon, beaucoup de petites "erreurs" :
SDL_RENDERER_ACCELERATED || SDL_RENDERER_PRESENTVSYNC => Remplace || par | (c'est un flag) ;
Pas de variables globales ;
Ton main beaucoup trop long ;
Évite au maximum d'utiliser des pointeurs (Quitte à utiliser une lib C++ et pas une lib C ) ;
Merci pour tous tes conseils, j'ai changé mon code et voila le résultat :
#include <SDL.h>
#include <SDL_image.h>
#include <iostream>
using namespace std;
void winopenned(SDL_Window *, SDL_Window *, SDL_Renderer *, int, int, char *, bool);
int main(int argc, char *argv[]) {
SDL_Init(SDL_INIT_VIDEO);
IMG_Init(IMG_INIT_JPG);
SDL_Window *load = SDL_CreateWindow("Load", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 400, 50, SDL_WINDOW_SHOWN | SDL_WINDOW_BORDERLESS);
SDL_Window *menu = SDL_CreateWindow("Menu", 5, 35, 0, 0, SDL_WINDOW_SHOWN);
SDL_Renderer *rendu = SDL_CreateRenderer(load, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
SDL_SetWindowFullscreen(load, SDL_FALSE);
SDL_SetWindowResizable(load, SDL_FALSE);
SDL_SetRenderDrawColor(rendu, 255, 0, 0, 255);
winopenned(load, menu, rendu, 0, 0, 0, false);
SDL_DestroyRenderer(rendu);
SDL_DestroyWindow(load);
SDL_DestroyWindow(menu);
IMG_Quit();
SDL_Quit();
return 1;
}
void winopenned(SDL_Window *fenetre1, SDL_Window *fenetre2, SDL_Renderer *rendu1, int a, int b, char *un, bool actived) {
SDL_Event ev;
while (!actived) {
while (SDL_PollEvent(&ev) != 0) {
SDL_Rect pb = { 0, 0, a, 50 };
SDL_RenderFillRect(rendu1, &pb);
SDL_RenderPresent(rendu1);
SDL_Delay(35);
if (a < 400)
a = a + b + 1;
b++;
if (a > 400) {
SDL_DestroyWindow(fenetre1);
SDL_SetWindowSize(fenetre2, 1280, 720);
string type = "Ice";
string pos = "10";
SDL_Renderer *sprite = SDL_CreateRenderer(fenetre2, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
SDL_Rect img = { 0, 0, 121, 121 };
SDL_RenderPresent(sprite);
string localisation = "runes/support/" + type + "/" + type + pos + ".png";
SDL_Surface *image = IMG_Load(localisation.c_str());
SDL_BlitSurface(image, NULL, image, &img);
if (!image) {
cout << "Erreur de chargement de l'image : " << SDL_GetError(); // affiche toujours l'erreur : SDL_UpperBlit: passed a NULL surface
system("pause");
}
SDL_UpdateWindowSurface(fenetre2);
}
switch (ev.type) {
case SDL_QUIT: actived = true;
break;
case SDL_KEYDOWN:
switch (ev.key.keysym.sym) {
case SDLK_0: actived = true;
break;
case SDLK_1: b = 500;
break;
}
}
}
}
}
Plus de variables globales, séparation en 2 fonctions, rectification || -> |, par contre pour limiter les pointeurs, je ne vois pas comment faire, passer d'une lib c++ à c ?
Il me semble que la SDL et iostream sont des lib c++ non ?
Le plus gros problème c'est qu'il affiche toujours la même erreur et l'image ne s'affiche donc pas...
Je ne pourrai pas t'aider sur l'erreur que tu rencontres, mais puisque tu parles d'optimisation, tu a malheureusement adopté la pire façon de faire. Je m'explique: - Tu crées une fenetre. - Tu entre dans la boucle de jeux. - Dans la boucle, tu charge ton image. - Encore dans la boucle, tu l'affiches. - Toujours dans la boucle, tu test si l'image à bien été chargée.
Bref, le chargement et test de chargement des ressource est au mauvais endroit. Le chargement des ressources est coûteux, et il est inutile de les recharger à chaque tour de boucle (en plus, c'est une fuite de memoire car tu ne libères jamais la ressource). Le chargement des ressources doit être fait une seule fois et en amont, avant même d'entrer dans la boucle de jeux.
Enfin, utiliser une librairie C en C++ sans l'encapsuler dans des capsules conformes RAII, c'est se tirer une balle dans le pied. SFML est plus recommandée que SDL, tu n'auras pas ce boulot d'encapsulation préalable à faire vu que c'est une librairie C++.
En fait Deedolith, le programme ne prendra pas cette forme à la fin (il y aura plusieurs class pour int, acitve, ...)
Cependant, je prends note de tes remarques qui me seront je pense utilise par le suite
En fait, mon gros problème c'est que je sais pas afficher une image en SDL, après quand je serais faire cela je serais posey.
Pour ce qui est de rejoindre le mouvement SFML j'ai vu que tu spamais cela sur le forum mais en fait j'ai testé facilement une dizaine de librairie pour dev des apps (logiciels ou jeu) comme wx, qt, SFML, Electron, API, ..., et même le VULKAN (oui c'est les moments où je suis taré...) et "la meilleure au niveau qualité prix" (complexité, poids en Mo du résultat) la SDL m'a séduit...
Je pense que tu dois me prendre pour un gros Jean-Kevin, mais je préfère apprendre "correctement" la SDL même si je dois passer plus de temps à comprendre et à faire des programmes d'entrainement...
Pour ce qui est du RAII, je me suis documenté dessus et si j'ai bien compris, cela consiste en gros à écrire les logs dans un fichier pour évité son stockage dans la mémoire vive, mais est-ce vraiment utile pour un si petit programme ? En tout cas, si mon projet prend de l’ampleur, je penserais à toi et j’essayerais ta technique.
Merci quand même pour ton commentaire, cela m'a appris des choses (et j'en ai bien besoin) même si cela ne résout pas mon problème
Pour ce qui est du RAII, je me suis documenté dessus et si j'ai bien compris, cela consiste en gros à écrire les logs dans un fichier pour évité son stockage dans la mémoire vive, mais est-ce vraiment utile pour un si petit programme ? En tout cas, si mon projet prend de l’ampleur, je penserais à toi et j’essayerais ta technique.
Tu n'y es pas du tout !! Les capsules RAII (Ressource Acquisition Is Initialisation) existent pour faciliter l'allocation dynamique des ressources, et libérer automatiquement ces dernières sans fuites de memoire, déchargeant ainsi le programmeur de la gestion manuelle de la memoire et tous les inconveniants qui vont avec.
Considère l'exemples ci-dessous:
int main()
{
int* val1 = new int;
*val1 = 5;
int* val2 = new int;
val2 = 8;
delete val2;
delete val1;
}
Pour un débutant, rien d'anormal, on alloue 2 dynamiquement 2 variables (donc des ressources), que l'on libère quand on en a plus besoin. Sauf que l'operateur new peut lancer une exception. Si l'allocation de val2 echoue, le programme se termine immediatement, et val1 n'est jamais libéré.
Considère maintenant l'exemple suivant:
class Capsule
{
private:
int* mData;
public:
Capsule(int value)
{
mData = new int;
*mData = value;
}
~Capsule()
{
delete mData;
}
int get() const
{
return *mData;
}
};
int main()
{
Capsule val1{5};
Capsule val2{8};
}
La construction des objets fais appel à l'allocation dynamique, mais val1 et val2 sont des variables automatiques, qui seront detruites automatiquement en cas de problème.
J'ai essayé de comprendre ce que tu as dis Emrak pour l'idée du wrapper SDL mais je n'y comprends vraiment rien car je suis débutant (ton truc relate de la fonction enum non ?)
Voici mon code après les conseils de Deedolith :
#include <SDL.h>
#include <SDL_image.h>
#include <iostream>
using namespace std;
void winopenned(SDL_Window *, SDL_Window *, SDL_Renderer *, SDL_Renderer *, SDL_Surface *, SDL_Rect, SDL_Rect, int, int, char *, bool);
int main(int argc, char *argv[]) {
SDL_Init(SDL_INIT_VIDEO);
IMG_Init(IMG_INIT_JPG);
SDL_Window *load = SDL_CreateWindow("Load", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 400, 50, SDL_WINDOW_SHOWN | SDL_WINDOW_BORDERLESS);
SDL_SetWindowFullscreen(load, SDL_FALSE);
SDL_SetWindowResizable(load, SDL_FALSE);
SDL_Window *menu = SDL_CreateWindow("Menu", 5, 35, 0, 0, SDL_WINDOW_SHOWN);
SDL_Renderer *renduload = SDL_CreateRenderer(load, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
SDL_Renderer *rendumenu = SDL_CreateRenderer(menu, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
SDL_Surface *image;
SDL_Rect progressbar;
SDL_Rect rectangleimage = { 0, 0, 121, 121 };
SDL_RenderFillRect(renduload, &progressbar);
SDL_SetRenderDrawColor(renduload, 255, 0, 0, 255);
winopenned(load, menu, renduload, rendumenu, image, progressbar, rectangleimage, 0, 0, 0, false);
SDL_FreeSurface(image);
SDL_DestroyRenderer(renduload);
SDL_DestroyRenderer(rendumenu);
SDL_DestroyWindow(menu);
IMG_Quit();
SDL_Quit();
return 1;
}
void winopenned(SDL_Window *fenetre1, SDL_Window *fenetre2, SDL_Renderer *rendu1, SDL_Renderer *rendu2, SDL_Surface *surface1, SDL_Rect rectangle1, SDL_Rect rectangle2, int a, int b, char *un, bool actived) {
SDL_Event ev;
string type = "Ice", pos = "10", localisation;
while (!actived) {
while (SDL_PollEvent(&ev) != 0) {
rectangle2 = { 0, 0, a, 50 };
SDL_RenderPresent(rendu1);
SDL_Delay(35);
if (a < 400)
a = a + b + 1;
b++;
if (a > 400) {
SDL_DestroyWindow(fenetre1);
SDL_SetWindowSize(fenetre2, 1280, 720);
SDL_RenderPresent(rendu2);
localisation = "runes/support/" + type + "/" + type + pos + ".png";
surface1 = IMG_Load(localisation.c_str());
SDL_BlitSurface(surface1, NULL, surface1, &rectangle2);
if (!surface1) {
cout << "Erreur de chargement de l'image : " << SDL_GetError(); // affiche toujours l'erreur : SDL_UpperBlit: passed a NULL surface
system("pause");
actived = true;
}
SDL_UpdateWindowSurface(fenetre2);
}
switch (ev.type) {
case SDL_QUIT: actived = true;
break;
case SDL_KEYDOWN:
switch (ev.key.keysym.sym) {
case SDLK_0: actived = true;
break;
case SDLK_1: b = 500;
break;
}
}
}
}
}
Après, je trouve qu'il y à beaucoup de paramètres dans la fonction void donc il faut créer d'autre fonctions (je pense).
Cependant je me trouve maintenant face à deux problèmes :
- Le problème de départ (qui est le thème de se blog)
- Une erreur à la ligne 27 : Run-Time Check Failure #3 - The variable 'image' is being used without being initialized. Il arrive à lancer l'application mais sa crash après (erreur exception).
Merci de répondre en priorité au premier problème
Pour se qui est de ton histoire de ~Capsule (je l'ai vu que après), je dois le faire à tous mes pointeurs (SDL_Renderer, SDL_Surface, etc) ?
Je sais ce que ça fait de voir un programme moche et mal optimisé mais, SVP POUVEZ VOUS ME DIRE COMMENT AFFICHER UNE IMAGE DE FACON BASIQUE.
Par la suite, je pourrais m'améliorer mais si j'ai pas les bases ça ne sert à rien (c'est comme connaître tous le voc en anglais mais ne pas savoir faire de phrase).
Voila pourquoi je n'arrive pas à afficher une image : yo@n97one ton code marche pas et j'ai essayé de nombreux codes tout fais sur des forums, sans succès...
En effet, j’ai écrit le code sans le tester, en plus de ce que tu as relevé, il manque un SDL_RenderPresent(renderer) après le SDL_RenderCopy.
> Deplus, toutes les autres personne de la discution recommande le c++...
Le problème, c’est que le C et le C++ sont deux langages différents. Utiliser iostream veut juste dire que tu compiles en C++, mais hormis ça, tous les codes que tu as posté sont du C. Si tu ne connais pas le C++ mais le C, fais du C (ou apprend le C++). Sinon as-tu essayé de suivre un tutoriel sur la SDL ?
J'ai essayé de nombreux tuto SDL (notamment sur yt) mais c'est de l'anglais alors je ne comprenais la moitié des choses et j'ai depuis peut compris qu'il vaut mieux comprendre de la merde pour s'attaquer à mieux plutôt que rien comprendre et recopier bêtement...
Ps : Aucune vidéo ne m'as permis d'afficher une image correctment...
Pour finir en beauté, même avec SDL_RenderPresent(renderer), sa crash et sa ne marche pas :
Il dit que ça c'est arrêté avec le code -1...
Comme je le dis tout le temps (je pense que c'est mon slogan) :
C'est incroyable, tous les problèmes que j'ai sont insolvables...
Donc ça veut dire qu’une initialisation ou un chargement a échoué. As-tu regardé stderr pour connaître le message d’erreur ? Le fichier img.jpg est bien placé au bon endroit ?
> J'ai essayé de nombreux tuto SDL (notamment sur yt) mais c'est de l'anglais alors je ne comprenais la moitié des choses et j'ai depuis peut compris qu'il vaut mieux comprendre de la merde pour s'attaquer à mieux plutôt que rien comprendre et recopier bêtement...
Regarde sur Zeste de Savoir ou encore sur Developpez. Sais-tu au moins à quoi sert le renderer et les textures, et ce que font les fonctions du code ? Si non, il faudrait d’abord comprendre ça et faire les choses dans l’ordre.
PS : insolvable ne veut pas du tout dire ce que tu penses.
Mon site web de jeux SDL2 entre autres : https://www.ant01.fr