Bonjour bienvenu dans cette vidéo d'introduction
de la minilibX alors vous débuté la programmation
et faire tout de suite des jolis dessins dans
des fenêtres c'est pas forcément la chose
la plus facile et la plus aisé avec les bases
de C que vous avez actuellement.
Donc nous vous fournissons une librairie
faite maison qui s'appelle la minilibX et
qui va vous permettre de commencer rapidement
à faire des jolis dessins dans des fenêtres
cette petite vidéo va vous expliquer les
rudiments, les tous premiers pas qu'il
vous faut connaitre pour pouvoir faire vos
projets graphique, notamment le FdF qui
sera surement le premier projet que vous
allez rencontrer. Alors pour cela nous allons
tout simplement prendre notre terminal
et commencer à regarder un petit peu ce que
nous avons à disposition. Alors nous avons donc
à disposition bah tout d'abord les man de
la minilibX, si je fais man mlx vous allez voir
que vous avez un premier man qui est un
man introductif de la minilibX et qui va vous
permettre de faire une accroche, de commencer
vos premiers projet en C et vos premiers projets
graphiques. Alors la minilibX va décrire un petit
peu le contexte, qu'est ce qu'elle fait, elle va
vous parler de son mode de fonctionnement
à la fois dans l'univers linux, bsd, avec
l'environnement graphique Xwindow mais
aussi et c'est le cas de la minilibX que vous avez
d'installé sur les dump mac elle va vous
expliquer de quelle façon globalement elle
fonctionne sur macOS. Vous avez un include
mlx.h qui va vous permettre d'accéder aux
différentes fonctions de l'API de la minilibX
La première fonction qui était tout au début
de ce man s'appelle mlx_init vous l'avez ici
au début et cette fonction là va permettre
d'établir la connexion entre votre programme
et le serveur graphique l'idée principale va
être la suivante, vous allez au travers de
cette connexion finalement envoyer des
ordres pour dessiner des choses, pour
ouvrir une fenêtre, pour faire des dessins
à l'intérieur de cette fenêtre et vous allez
récupérer des informations qui vont être
ce qu'on appellera des évènements qui seront
décris expliqué dans une seconde vidéo.
On va commencer par la première étape
ouvrir une première fenêtre à l'écran
et puis ensuite créer un dessin, dessiner
quelque chose à l'intérieur.
Alors pour cela nous allons faire un premier
projet, on va faire un main.c
Alors dans ce main.c on a vu qu'on a
besoin d'inclure mlx.h et ensuite on va
faire un main, on ne s'occupe pas de argv, argc
pour le moment et on a vu qu'il nous fallait
appeler mlx_init() au début. Alors si vous
avez remarqué, je reprends le man de mlx
mlx_init renvoie un void* globalement
mlx_init va vous renvoyer un pointeur
et ce pointeur va servir d'identifiant
pour la connexion avec le serveur graphique
c'est une valeur dont vous n'avez globalement
rien à faire mais qui vous sera redemandé
pour tout les autres appels aux autres
fonctions de la minilibX ça leurs permettra aux
autres fonctions de réutiliser la même connexion
vers le serveur. Donc on va sauvegarder le
fameux void* qui est récupéré.
On va l'appeler mlx
et on va donc faire mlx=mlx_init() donc
ça va nous permettre de créer la connexion
mais notre programme il va s'arrêter là
directement on va rapidement passer à
l'étape suivante tout de même.
Alors si vous avez regardé un petit peu
déjà le man de mlx jusqu'au bout, vous
avez en bas, un descriptif des principales
fonctions qui sont disponible dans la
librairie notamment mlx_new_window
qui va vous permettre de créer une
nouvelle fenêtre et mlx_pixel_put qui
va permettre d'allumer un pixel de la
couleur que vous voulez à l'intérieur de
cette fenêtre. Vous les retrouvez bien
évidement dans les autres man qui sont
disponible notamment le fameux man
de mlx_new_window
Le man de mlx_new_window va nous indiquer
les différents paramètres qu'il faut transmettre
à cette fonction pour pouvoir créer une fenêtre
le premier paramètre s'appelle mlx_ptr
il est là, c'est tout simplement le void*
qu'on a récupéré de mlx_init, la taille
X et Y, sizeX, sizeY, les dimensions de la
fenêtre et une chaine de caractères qui
va être le titre de la fenêtre, on reprend notre emacs
mlx_new_window on a vu que le premier
paramètre c'était ce que nous avait renvoyé
mlx_init on va créer une fenêtre qui va faire
par exemple 400 pixels sur 400 pixels et
on va l'appeler mlx_42 ça va être le titre
de notre fenêtre. Alors vous pouvez voir que
globalement là encore je récupère ce que me
renvoit mlx_new_window un void* qui va être
de la même façon un identifiant de la fenêtre
la minilibX vous permet d'ouvrir simultanément
plusieurs fenêtres et pour savoir dans quelle
fenêtre vous voulez agir ou dans quelle fenêtre
vous voulez récupérer ce qu'on verra plus tard
c'est à dire les évènements clavier et souris
qui vont pouvoir arriver, il faudra préciser
l'identifiant de la fenêtre pour savoir sur
quelle fenêtre vous travaillez. Alors très
basiquement là voilà on a créé la connexion
au serveur, on a ouvert une fenêtre, si on
veut pouvoir déjà voir un petit peu ce que
ça donne, on va compiler le tout.
Au cas où vous l'auriez pas remarqué le man
de la minilibX vous indique également comment
compiler: linking minilibX soit en environnement
X-Window avec les librairies qui sont nécessaire
pour ça, soit en environnement macOS avec
les framework qui sont nécessaire pour ça
Donc là vous voyez que en étant en environnemnt
macOS on va utilise -mlx -Framework OpenGL
et AppKit. Compilons donc notre mail.c en lui
transmettant mon lmlx la minilibX
le framework OpenGL
et le framework AppKit et donc là nous à créé
notre binaire mlx que je vais m'apprêter à
lancer et qui rend la main tout de suite
parce qu'une fois qu'on a créé la fenêtre
le programme s'arrête tout simplement.
Alors vous allez me dire "oué alors si on
veut voir la fenêtre, qu'est ce qu'on fait"
On va pour ça, avoir plusieurs solutions
la plus simple serait d'utiliser la fonction
système sleep() ici, qui fait un délai qui
vous ferait attendre je sais pas 5 sec, 10 sec
pour voir la fenêtre apparaitre.
C'est pas une solution qui est viable tout
simplement parce que la fenêtre ne va pas
apparaitre au moment ou vous appelez
mlx_new_window elle va apparaitre une fois
que l'ensemble du système graphique de macOS
va prendre la main et pour faire cela il faut
que appeliez la fonction mlx_loop qui elle
prend comme paramètre l'identifiant de
la connexion.
mlx_loop va servir pour gérer les évènements
ce sera l'objet de la vidéo suivante et elle
va servir surtout pour donner la main à
l'ensemble du système graphique mac
j'ai créé la fenêtre, et maintenant je rends
la main à mlx_loop, je rends la main au
système graphique mac qui lui va se charger
d'afficher la fenêtre, il va pas le faire de
façon instantané, il va le faire de façon
asynchrone et pour qu'il puisse le faire
on a besoin de rentrer dans cette phase là.
Donc cette fois si je compile à nouveau
et que je lance, j'ai maintenant la fenêtre
qui s'affiche, elle est là. mlx_loop est
comme son nom l'indique, une boucle
une loop, elle rend pas la main tout simplement
donc si vous voulez sortir du programme
il faudra que vous le prévoyiez d'une façon
ou d'une autre, par exemple lorsque vous
aurez appuyé sur une touche ce sera une
façon d'appeler la fonction exit qui arrêtera
votre programme mais mlx_loop elle ne va
jamais vous rendre la main
Alors on va rapidement regardé maintenant
de quelle façon on va pouvoir effectuer
différents dessins. Je vais utiliser pour
l'instant la façon simple, de vous présenter
mlx_pixel_put qui permet d'afficher un pixel
à l'intérieur d'une fenêtre, les paramètres
de mlx_pixel_put on va les retrouver dans
le man en cas de doute; man mlx, mlx_pixel_put
voilà il y a une man dédié à mlx_pixel_put
c'est pas le cas de toutes les fonctions mais
vous trouverez les fonctions similaires
dans le même man.
mlx_pixel_put qui prend l'identifiant de la
connexion, l'identifiant de la fenêtre
les coordonnées du pixel et la couleur
la couleur qui est exprimée sur un int
Alors on est sur fenêtre qui fait 400*400
on va mettre un pixel en 200*200 et la couleur
est codée en RGB sur l'int
Alors les deux premiers zéros qui correspondent
à l'octet de poids fort
sont pour la transparence qui n'est dans le
cas du pixel_put pas géré par la minilibX
nous avons le rouge qui est codé sur le
premier FF, le vert qui est ici sur le deuxième
et le bleu sur le troisième on va donc avoir
ici un pixel de couleur blanche
on recompile
alors, vous le voyez peut-être
ou vous ne le voyez peut-être pas nous
avons bien un pixel blanc ici au milieu
de la fenêtre qui s'est affiché
si on veut faire d'avantage de pixel on
peut toujours s'amuser un petit peu
prenons
deux variables supplémentaires
faisons une petite boucle
faisons une deuxième boucle
recompilons le tout
et manque de bol
ça fait pas ce qu'il faut, c'est un grand classique
nous avons donc x et y
qui vont remplacer le 200*200
parce qu'afficher je ne sais combien de fois
le même pixel au même endroit ça n'aura
pas l'effet voulu, et nous avons cette fois ci
notre carré entre 50 et 150 sur x et sur y
donc ça vous donne ainsi un exemple
d'utilisation de mlx_pixel_put ça vous
donne un exemple de création de fenêtre
alors gardez en tête la chose suivante
les pixels ne sont pas dessinés à l'intérieur
de la fenêtre au moment où vous appelez
mlx_pixel_put c'est vraiment au moment où
mlx_loop est appelé que l'affichage sera
vraiment fait dans votre fenêtre, mlx_loop
je vous en ai déjà fait part un petit peu
va également s'occuper de la gestion des
évènements et c'est quelque chose que nous
allons voir dans la deuxième vidéo consacrée
à la minilibX, à tout de suite.