https:/.../low_d_Documentation_-_Minilibx_-_introduction.mp4

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.