Initialiser la SDL dans une fonction

L'auteur de ce sujet a trouvé une solution à son problème.
Auteur du sujet

Bonjour,

n'ayant pas l'habitude des langages si bas niveau j'ai un problème au niveau de la transmission des pointeurs. Je comprend parfaitement le principe d'adresse et de valeur mais quand j'essaye de l'appliquer pour par exemple initialiser la sdl dans une fonction ça ne fonctionne pas.

j'ai une fonction :

1
int init( SDL_Window* window, SDL_Surface* screenSurface ); 

Après avoir initialiser mes deux pointers à NULL dans mon main j'appelle la fonction de cette manière :

1
if( init( window, screenSurface ) < 0 ) return 0;

Puis dans ma fonction après plusieurs test je crée ma fenêtre :

1
window = SDL_CreateWindow( "SDL Window", 0, 0, 640, 480, SDL_WINDOW_SHOWN ); 

et

1
screenSurface = SDL_GetWindowSurface( window ) 

Je test bien sur si window est pas égale à NULL si la fonction SDL_Init() me retourne pas une erreur mais malgrès tout ça a la compilation je n'ai aucune erreur mais une fois le programme lancer je n'ai aucune fenêtre, juste les bordure mais la fenêtre est vide (je vois à travers).

Avec vous une idée ? Je suis un peu perdu.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
int main( int argc, char* argv[] )
{

  SDL_Window* window = NULL;
  SDL_Surface* screenSurface = NULL;

  if( init(window, screenSurface) < 0 )return 0;

  SDL_UpdateWindowSurface( window );
  
  SDL_Delay( 2000 );

  return 0;

}

Édité par #VK

Salut,

Je n'ai pas regardé ton problème vraiment en détail, mais à première vue, il vient du fait que tu affiches ta fenêtre à la position (0, 0). Utilises la variable SDL_WINDOWPOS_CENTERED pour l'afficher au centre de ta fenêtre.

De plus, il y a d'autres problèmes dans ton code :

  • Tu n'initialises pas la SDL, à moins que tu ne le fasses dans ta fonction init.
  • Tu modifies ton pointeur dans la fonction init, il faut donc utiliser un pointeur de pointeur.

Donc voici un code que je pense bon. Les autres jugeront :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <SDL2/SDL.h>
#include <stdio.h>


int init( SDL_Window** window, SDL_Surface** screenSurface )
{
   if(0 != SDL_Init(SDL_INIT_VIDEO))
   {
      fprintf(stderr, "Erreur d'initialisation de la SDL : %s\n", SDL_GetError());
      return -1;
   }
   *window = SDL_CreateWindow("Test", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
                              500, 500, SDL_WINDOW_SHOWN);
   if(NULL == *window)
   {
      fprintf(stderr, "Erreur de creation de la fenetre : %s\n", SDL_GetError());
      return -1;
   }
   *screenSurface = SDL_GetWindowSurface(*window);
   return 0; 
}


int main(int argc, char* argv[])
{
   SDL_Window *window = NULL;
   SDL_Surface* screenSurface = NULL;

   init(&window, &screenSurface);

   SDL_Delay(500);

   return 0;
}

EDIT : @ Dominus Carnufex : si son problème c'est qu'il n'y a rien d'affiché, alors j'ai tout compris de travers. :-°

Édité par Karnaj

Je fais un carnage si ce car nage car je nage, moi, Karnaj ! - Tutoriels LaTeX - Contribuez à un tutoriel Ruby

+0 -0
Auteur du sujet

Salut,

alors je n'ai pas poster mon code en entier car je voulais pas simplement qu'on me corrige mais surtout comprendre d'ou venait l'erreur.

En regardant ton code la seul différence est dans la fonction init, tu utilises deux fois l'astérisque alors que moi une seul (dans la fonction main je fais bien un SDL_Init().

Du coup je comprend pas l'utilité d'un double pointer.

Auteur du sujet

Alors je vous ai fait un petit screen car c'est compliqué à expliquer. Imgur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <stdio.h>
#include <SDL2/SDL.h>

int init(SDL_Window* window, SDL_Surface* screenSurface);

void close();

int main( int argc, char* argv[] )
{

  SDL_Window* window = NULL;
  SDL_Surface* screenSurface = NULL;

  if( init(window, screenSurface) < 0 )return 0;

  SDL_UpdateWindowSurface( window );
  
  SDL_Delay( 2000 );

  return 0;

}

int init(SDL_Window* window, SDL_Surface* screenSurface)
{
  
  int success = 0;

  if( SDL_Init( SDL_INIT_VIDEO ) < 0 )
  {
      printf( "SDL could not initialize! SDL Error: %s\n", SDL_GetError() );
      success = -1;
  }
  else
  {
      window = SDL_CreateWindow( "Event driven programming", 0, 0, 640, 480, SDL_WINDOW_SHOWN );
      if( window == NULL )
      {
          printf( "Window could not be created! SDL Error; %s\n", SDL_GetError() );
          success = -1;
      }
      else
      {
          screenSurface = SDL_GetWindowSurface( window );
      }
  }

  return success;

}

Cette réponse a aidé l'auteur du sujet

Je répète ce que j'ai dit, tu ne dessines rien dans ta fenêtre. Tu crées une fenêtre avec SDL_CreateWindow, tu récupères la surface associée avec SDL_GetWindowSurface, puis tu ne fais rien, et enfin, tu affiches ta surface avec SDL_UpdateWindowSurface. Tu essayes d'afficher du rien, forcément, ça ne donne aucun résultat intéressant !

Edit : il faudrait rajouter une étape du genre de

1
2
    image = SDL_LoadBMP("image.bmp"); // loads image
    SDL_BlitSurface(image, NULL, screen, NULL); // blit it to the screen

pour que quelque chose s'affiche.

Édité par Dominus Carnufex

#JeSuisGrimur #OnVautMieuxQueÇa

+1 -0
Auteur du sujet

Alors en fait maintenant j'ai un tout petit soucis:

1
Erreur de segmentation (core dumped)

Juste en rajoutant ceci :

1
SDL_FillRect( screenSurface, NULL, SDL_MapRGB( screenSurface->format, 0xFF, 0xFF, 0xFF ) ); 

avant le update

Édité par #VK

Ah, finalement en relisant la documentation de la SDL rapidement, oui le double pointeur me semble obligatoire. C'est la valeur du pointeur et non ce sur quoi il pointe qui est modifié. Je pense que c'est ce qui pose problème avec SDL_FillRect. . J'imagine que si tu regardes avec le debugger, screenSurface vaut toujours NULL.

Par contre, pourquoi tu n'utilises pas une texture plutôt ?

Je fais un carnage si ce car nage car je nage, moi, Karnaj ! - Tutoriels LaTeX - Contribuez à un tutoriel Ruby

+0 -0
Auteur du sujet

Alors je suis en train d'apprendre à utiliser la SDL donc j'y vais étape par étape. Et le tutoriel que je regarde le mec fait ses déclarations de variables en global et vu que je trouve ça dégeu j'ai voulu faire la même fonction init mais en plus propre.

Erreur de segmentation correspond a quoi ? C'est pas un dépassement de mémoire ou un truc comme ça ?

EDIT: Au fait avec les ** ça fonctionne correctement et sans erreurs.

Édité par #VK

L'erreur de segmentation, c'est que tu as essayé d'accéder à une zone mémoire qui ne t'étais pas allouée (avec NULL, ça fait mal).

Je te conseille de quitter le tutoriel que tu suis. Le gars, il utilise la SDL2 avec des fonctions de la SDL1. Le mieux est d'utiliser plusieurs ressources (par exemple, tu as une série d'articles sur Developpez) et la documentation.

Je fais un carnage si ce car nage car je nage, moi, Karnaj ! - Tutoriels LaTeX - Contribuez à un tutoriel Ruby

+0 -0

Je ne l'ai jamais lu celui là, alors je ne pourrais pas te donner de bons conseils à son propos. Peut-être qu'il est bon, mais je pense quand même qu'apprendre à utiliser les surfaces alors que la SDL2 introduit les textures, c'est pas la meilleure chose à faire. Et c'est du C++ alors que tu utilises le C. Autant suivre un tutoriel dans le bon langage (si quelqu'un pouvait en faire un ici ce serait bien).

Je fais un carnage si ce car nage car je nage, moi, Karnaj ! - Tutoriels LaTeX - Contribuez à un tutoriel Ruby

+0 -0
Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte