Étape 5: La Build : faire une fenêtre
La base code vous aurez besoin de compiler et d’exécuter est comme ci-dessous. Maintenant, il peut être beaucoup plus courte, mais je tiens à introduire quelques concepts importants dans cette étape et compléter cette instructable dans un laps de temps.
Nous allons regarder de plus près lors de l’initialisation
SDL_Init initialise la sdl pour le mode pour lequel vous souhaitez utiliser. Plus précisément, il y a 8 modes dans SDL incluent Audio, CD-ROM, fichier e/s, manipulation du Joystick, Threading, gestion d’événements, minuteries, vidéo (celui que nous utilisons). Seulement le SDL_INIT_VIDEOest maintenant notre besoin dès maintenant.
Les trois lignes de code il suffit de créer une fenêtre pour nous d’utiliser. l’écran est une variable de type
SDL_Window *; d’écran
Cette variable, nous stockons la valeur de retour de SDL_CreateWindow() qui renvoie une fenêtre si réussie ou une valeur NULL si infructueuse.
en SDL_CreateWindow(),
1) le titre de la fenêtre, le détail le premier argument
2) le deuxième et le troisième argument donner l’emplacement par défaut de la fenêtre sur l’écran au démarrage
3) le quatrième et cinquième argument spécifie la taille de l’écran, j’ai créé deux variables windowHeight = 1020 ; et largeur de la fenêtre = 610 ; pour stocker ces informations.
4) sixième argument est pour un indicateur, ce qui peut indiquer des choses comme si la fenêtre peut être redimensionnée ou si elle doit être minimisée au démarrage etc. vous trouverez plus de drapeaux dans les liens au bas de cette étape.
La fonction suivante SDL_CreateContext() est unique pour chaque fenêtre. SDL2 introduit un nouveau système par lequel vous pouvez créer plusieurs fenêtres. mais pour chaque fenêtre, vous devez créer un contexte qui fondamentalement stocke l’ensemble de l’état associé à cette instance d’OpenGL.
Comme je le disais avant, OpenGL est une machine d’État. Notre application peut avoir plusieurs fenêtres, donc openGL doit savoir quelle fenêtre pour restituer les graphiques, nous utilisons
SDL_GL_MakeCurrent (, )
de dire à quelle fenêtre pour restituer à openGL. OpenGL continuera à rendre d’une fenêtre donnée set jusqu'à ce que vous réutilisez actuel SDL_GL_Make pour spécifier une autre fenêtre.
Ensuite, nous allons jeter un oeil à la boucle while()
J’ai créé une variable done = 0; qui vérifie à chaque itération de la boucle. Si done = 1, le programme a démontré à condition de sortie et la boucle seront terminera, et le programme se ferme.
SDL_Event event crée sorte d’une pile de différents événements triés par la priorité d’occurrence. À chaque nouvelle itération, l’état de l’application sera actualisé, et dans chaque itération de la boucle, l’utilisateur peut appuyer sur les touches, cliquez sur les boutons ou déplacez la souris etc..
SDL_PollEvent (& event) ; remplira l' événement avec les divers événements qui se produisent à chaque itération.
autrement dit, à chaque itération du while boucle, la variable d’événement NomDocument est générée avec les données d’événement maintes et maintes fois.
SDL_PollEvent (& event); en plaçant un certain temps boucle
tandis que (SDL_PollEvent (& event))
{
}
Nous pouvons évaluer les événements de la pile de l’événement dans la variable d’événement jusqu'à ce qu’il n’y a pas plus d’évenements dans la variable d’événement.
dans l’imbriqués tout en boucle, nous vérifions pour événements SDL_QUIT qui fondamentalement nous indique le bouton croix rouge sur le dessus de l’application a été enfoncée et l’utilisateur est maintenant quitter l’application.
La toute dernière fonction est SDL_GL_SwapWindow(screen).
Maintenant, tout a rendu à l’écran en OpenGL est stocké dans une zone de mémoire appelée le frame buffer. lors de l’actualisation de l’écran avec une nouvelle image à chaque image, le contenu de tampons de trame est effacé et rempli avec les nouveaux graphismes. pratiquement, ce processus prend du temps et si nous courons notre application cette façon nous verrions beaucoup de scintillement comme la nouvelle image de dessin prend du temps dans le frame buffer.
Mais avec le concept d’échange de mémoire, nous pouvons empêcher cet effet. Nous définissons deux zones de mémoire, le tampon d’affichage et de la mémoire tampon d’arrière-plan, l’écran pointe vers le tampon d’affichage et l’image dans le tampon d’affichage s’affiche. L’image suivante à tirer est chargé dans la mémoire tampon d’arrière-plan tandis que l’écran affiche le contenu du tampon, donc au lieu de copier le contenu du dossier de la mémoire tampon pour le tampon d’affichage, l’écran pointe vers la mémoire tampon d’arrière-plan au lieu de cela l’image suivante est appelée instantanément et puis le tampon est rempli avec l’image suivante et l’écran est modifiée à nouveau et ainsi de suite. En substance, nous définissons aux emplacements de mémoire et charger les données dans leur en tandem, c'est-à-dire l’image à afficher et l’image suivante pour afficher et garder swapping le pointeur écran entre les deux.
Heureusement en OpenGL, nous n’avons pas à aller dans cette grande complexité et il suffit d’appeler une fonction pour obtenir un affichage agréable et éviter le scintillement :
SDL_GL_SwapWindow ();
La dernière chose à faire est fermer l’application et disposer de toutes les ressources que nous avons utilisé.
Externe des liens et des références pour la recherche :
SDL_Init()- https://www.libsdl.org/release/SDL-1.2.15/docs/htm...
SDL_CreateWindow()- https://wiki.libsdl.org/SDL_CreateWindow
SDL_GL_MakeCurrent()- https://wiki.libsdl.org/SDL_GL_MakeCurrent
SDL_PollEvent()- https://wiki.libsdl.org/SDL_PollEvent
