Assembleur : reconstruction - modes graphiques

Des modes graphiques

Pour faire une sorte de séance de révision, nous allons retravailler les graphiques du chapitre 5. Reprenons tout le déroulement du programme :

1. Saut au début, optionnel
2. P'tit message pour ne pas perdre la main
3. Demande d'informations sur le VESA BIOS EXTENSION
4. Traitement de ces informations
5. Choix du mode graphique
6. Passage dans le mode choisi
7. Affichage de points
8. Affichage de droites
9. Affichage d'un alphabet

Saut au début, optionnel

call initialise_segments

On s'en souvient, on est en binaire pur pour être chargé depuis un chargeur d'amorçage, on a gardé la directive org d'une inutilité certaine ici. On fait un saut pour inclure les fonctions d'affichage de texte au début. C'est un choix, absolument pas justifiable par autre chose que "c'est comme ça". On appelle une fonction "initialise_segments" qui ne sera jamais appelée qu'une fois. On pourrait la mettre en macro, mais nous verrons les macros plus tard. C'est donc encore en fonction.

mov ax, cs
mov ds, ax
mov es, ax
mov ax, 0x8000
cli
mov ss, ax
mov sp, 0xF000
sti
ret


P'tit message pour ne pas perdre la main

mov si, hello; met l'adresse de la chaîne à afficher dans le registre SI
call affiche_chaine


Bon, le message sera affiché, mais tel quel, on a d'excellentes chances de ne pas le voir, parce qu'on va afficher plus d'un écran par la suite. Il faut modifier le code qui viendra après pour le voir.

Demande d'informations sur le VESA BIOS EXTENSION

mov ax, 0x4F00 ; demande infos sur le pilote VESA VBE
mov di, VESASignature
int 10h
cmp ax, 0x4F ; Si AL <> 0x4F, on n'a pas de VESA, donc fin. Si AH <> O, erreur, donc fin.
jne fin


VESASignature est défini dans la partie "données" :

Ces informations, je ne les sors pas de mon chapeau, évidemment. Elle proviennent d'ici : VESA BIOS Extension (VBE) Core Functions Standard Version 2.0, tout ça parce que dans ma machine virtuelle, c'est VBE 2.0 qui est implanté.

Traitement de ces informations

Le traitement des informations VESA consiste principalement en deux choses : gérer les cas d'erreur et pousser plus avant les investigations. Pour les erreurs, on restera très simple puisqu'on sort au moindre problème. Pour le reste, voyons cela.

Première chose, afficher le nom du constructeur :

cmp ax, 0x4F ; Si AL <> 0x4F, on n'a pas de VESA, donc fin. Si AH <> O, erreur, donc fin.
jne fin
mov si, OEMStringPtr ; pointeur vers le nom de l'OEM stocké offset:segment
lodsw; on charge l'adresse d'offset dans ax
mov bx, ax ; BX contient l'adresse d'offset
lodsw ; on charge l'adresse de segment dans ax
mov si, bx ; SI pointe sur le nom de l'OEM
push ds ; on sauvegarde DS


mov ds, ax ; ds contient l'adresse de segment du nom de l'OEM
call affiche_chaine


pop ds ; on restaure DS
mov cx, 18


mov si, retour_chariot
call affiche_chaine
loop lignes_vides


Notez qu'on ajoute 18 lignes de retours chariot. C'est bête, c'est méchant et ça ne sert qu'à décaler l'affichage pour en avoir plus à visualiser sur l'écran suivant. Cette horreur devrait partir prochainement.

Nous allons ensuite lire les informations de chaque mode supporté par notre interruption 0x10. Ca nous permettra de choisir un bon mode vidéo.

mov si, VideoModePtr ; pointeur vers la liste des modes supportés
lodsw ; on charge l'adresse d'offset dans ax
mov cx, ax ; cx contient l'adresse d'offset
lodsw ; on charge l'adresse de segment dans ax
mov si, cx ; si pointe sur le premier mode supporté
mov dx, ax ; dx contient l'adresse de segment


push ds


mov ds, dx ; ds contient l'adresse de segment de la liste des modes
lodsw ;charge dans ax le mode


pop ds
cmp ax, 0xFFFF ; Fin de la liste
je arret_modes
mov cx, ax
mov ax, 0x4F01 ; demande infos sur le mode VESA
mov di, ModeAttributes
int 0x10


VideoModePtr est défini dans le bloc de données :

Le test d'erreurs :

cmp ax, 0x4F ; Si AL <> 0x4F, la fonction n'est pas supportée, on se contentera du VGA. Si AH <> O, erreur, pareil.
jne lit_mode_suivant
test word [ModeAttributes], 0xF
jz lit_mode_suivant


On affiche les informations pertinentes du mode courant :

mov di, hello ; on écrit dans hello
mov ax, cx
push cx


mov ch, 3
mov bl, 16
call nombre_vers_chaine
mov al, ':'
stosb
mov ch, 4
mov bl, 10
mov ax, [XResolution]
call nombre_vers_chaine
mov ax, ('*' << 8) + ' '
stosw
mov al, ' '
stosb
mov ax, [YResolution]
call nombre_vers_chaine
mov ax, ' '
stosb
mov ch, 2
mov al, [BitsPerPixel]
call nombre_vers_chaine
mov al, ' '
stosb
mov ax, ';' ; on met 2 caractères d'un coup après la chaîne : un '\n' et le zéro terminal.
stosw ; les caractères sont dépilés, c'est à dire qu'il faut placer le premier dans la zone basse


pop cx


push si ;sauve si sur la pile
mov si, hello
call affiche_chaine


pop si ; on récupère si


Les esprits chagrins remarqueront que j'écris sur l'emplacement hello. Alors, il est fait pour cela, et j'en suis parfaitement conscient. Vu le peu que j'écris, j'ai largement la place dans cet espace pour mettre ce qui m'intéresse.

On va déborder un peu sur le paragraphe suivant : on va chercher quelle est la meilleure résolution à utiliser. On va la définir comme étant celle maximisant largeurEnPixels * hauteurEnPixels * TailleDeCodageDesCouleurs. Ca se fait dans la même boucle, c'est pour cela qu'on en parle maintenant.

push dx


mov ax, [XResolution]
shr ax, 5
push ax


mov ax, [YResolution]
shr ax, 3
push ax


mov al, [BitsPerPixel]
xor ah, ah
shr ax, 3


pop bx
mul bx


pop bx
mul bx


pop dx
cmp ax, [maxResol]
jb lit_mode_suivant
mov [maxResol], ax
mov [mode_souhaite], cx
jmp lit_mode_suivant


Choix du mode graphique

mov cx, [mode_souhaite] ; On s'enquiert du mode souhaité
mov ax, 0x4F01 ; demande infos sur le mode VESA
mov di, ModeAttributes
int 0x10
mov di, hello ; on écrit dans hello
mov ax, cx
push cx


mov ch, 3
mov bl, 16
call nombre_vers_chaine
mov al, ':'
stosb
mov ch, 4
mov bl, 10
mov ax, [XResolution]
call nombre_vers_chaine
mov ax, ('*' << 8) + ' '
stosw
mov al, ' '
stosb
mov ax, [YResolution]
call nombre_vers_chaine
mov ax, ' '
stosb
mov ch, 2
mov al, [BitsPerPixel]
call nombre_vers_chaine
mov ax, 13 ; on met 2 caractères d'un coup après la chaîne : un '\n' et le zéro terminal.
stosw ; les caractères sont dépilés, c'est à dire qu'il faut placer le premier dans la zone basse


pop cx
mov si, hello
call affiche_chaine

mov al, [BitsPerPixel]
shr al, 3
mov byte [octetsParPixel], al
mov ax, [WinASegment]
or ax, ax ; on teste l'adresse du segment de la fenêtre. Si elle est nulle, on passe en mode 0x13
jnz adresse_OK


mov word [mode_souhaite], 0x0013 ; infos du mode 0x13, le mode VGA
mov word [WinASegment], 0xA000
mov word [YResolution], 200
mov word [XResolution], 320
mov byte [octetsParPixel], 1


mov di, hello ; met l'adresse de la chaîne à lire dans le registre SI
call lit_chaine ; On attend l'utilisateur pour nettoyer l'écran


Passage dans le mode choisi

mov ax, 0x4F02
mov bx, [mode_souhaite]
int 0x10 ; Changement de mode vidéo
call nettoyage_ecran


Nettoyage de l'écran

Derrière ce terme ménager se cache juste le remplissage de l'intégralité de l'écran avec une couleur de fond. Comme d'habitude, l'idée n'est pas l'optimisation, le code super rapide comme l'ont tous les logiciels spécialisés. L'idée est d'avoir d'abord un code fonctionnel, créé au plus évident. L'algorithme que je vous propose ne prend en compte aucun prérequis autre qu'un mode VESA disposant d'une fenêtre A en mode écriture. Enfin, il me semble.

On écrit dans la mémoire vidéo par bloc de 64 ko. L'idée est donc de remplir tous ces blocs par la couleur de fond.

nettoyage_ecran:


push di
push es
push ax
push bx
push cx
push dx
mov es, [WinASegment]; On lit l'adresse de départ de la mémoire vidéo

mov cx, [YResolution]
mov ax, [XResolution]
mul cx ; Nombre de points total
mov ax, dx
mov cl, [octetsParPixel]
mul cl
mov cx, ax
xor dx, dx
xor bh, bh
xor bl, bl


boucle_fenetres:


push cx


mov ax, 0x4F05
int 0x10 ; Changement de fenêtre
mov cx, [WinSize]
shl cx, 9 ;Passage de ko en mots.
xor di, di


.point:


push cx
push bx


mov cl, [octetsParPixel]
xor ch, ch
mov bx, couleur_defaut


.couleur:


inc bx
mov al, byte [bx]
stosb
loop .couleur


pop bx
pop cx
loop .point
inc dx


pop cx
loop boucle_fenetres


.depile:


xor dx, dx
mov [bloc_courant], dl
mov ax, 0x4F05
int 0x10 ; Changement de fenêtre
pop dx
pop cx
pop bx
pop ax
pop es
pop di
ret


;Fin nettoyage_ecran


Affichage de points

Avec cette fonction, vous pouvez dorénavant dessiner ce que vous voulez où vous le voulez, en, normalement, n'importe quel mode VESA ! L'idée de base reste de mettre, octet par octet, la couleur spécifiée à l'adresse couleurPoint dans la mémoire vidéo, et de donner le bon numéro de plage. Ce bon numéro de plage est toujours basé sur la sainte formule : ordonnée * octetsParLigne + abcsisse. Je suppose que le débordement de la multiplication me donne le numéro convoité.

Affichage de droites

On avait déjà parlé de l'algorithme de Bresenham, le revoici à l'identique. Il a été mis à jour pour refléter l'inversion des paramètres de affiche_point. On met sur la pile X1, puis Y1, puis X2 et enfin Y2.

Affichage d'un alphabet

Voici la grande nouveauté de ce chapitre : un alphabet ! En mode graphique, oui madame, dessiné par mes soins, à la va-comme-j'te-pousse. Je l'ai fait parce qu'il me semble que bientôt, nous n'en aurons plus. Et puis, ça permettra d'afficher facilement des 'é', 'ç' et autres 'à'. Dès que j'aurai mis ces caractères, bien sûr. La fonction est très simple : on lui donne le numéro du caractère, avec A = 1, dans cx. ax contient l'ordonnée du coin supérieur gauche du caractère et bx son abscisse.