Triceraprog

VG5000µ, SetPoint en BASIC, manipulation de gros pixels (2017-03-22)
Dans l'épisode précédent, j'avais décrit l'arrangement en mémoire vidéo des caractères semi-graphiques et un moyen d'accéder directement en mémoire à celui qui nous intéresse.

Le but est toujours de pouvoir allumer un élément constitutif d'un caractère semi-graphique, que je nomme « gros pixel ». Et l'article précédent s'arrêtait au moment où je pouvais récupérer, via une paire d'appels à commande PEEK, les deux valeurs décrivant le caractère affiché à l'écran.

Premier test, après avoir effacé l'écran avec INIT, j'affiche les deux valeurs correspondantes à la colonne 1, ligne 0.

Les deux valeurs obtenues et visibles sur la capture d'écran sont 79 et 0. Pour comprendre ce qu'ils signifient, je reprends ici un morceau de l'article sur l'arrangement de la mémoire vidéo qui décrit la structure de ces deux valeurs.

On y lit que la première valeur a cette structure :

Bit 7 6 / 5 / 4 / 3 / 2 / 1 / 0

Contenu N (0)/E (1) numéro du caractère

Et que la seconde a celle-ci :

Bit 7 6 5 4 3 2 / 1 / 0

Contenu TX (0) Inverse vidéo Largeur x2 Hauteur x2 Clignotement Couleur

Contenu GR (1) Couleur ... ... de ... ... fond Clignotement Couleur

Compter jusqu'à deux

Pour comprendre ce que ces tableaux signifient, il faut savoir et comprendre que les valeurs que j'ai obtenues et affichées le sont en base 10, c'est-à-dire sous la forme sous laquelle nous comptons usuellement dans la vie de tous les jours. En base 10, il y a 10 chiffres, et 0 à 9, et les nombres sont composés de ces chiffres. 79 est composé du chiffre 7 en position des dizaines et 9 en position des unités.

C'est d'ailleurs au programme du primaire à l'école, où l'on apprends que 79, c'est 7 dizaines et 9 unités. Autrement dit, 7 × 10 + 9. De même, 0 est composé de 0 unité.

Ces 10 chiffres sont arbitraires. On aurait pu, et d'autres civilisations l'ont fait, avoir un système de comptage avec 20 chiffres. Pourquoi pas. En programmation, il est usuel de compter en base 10, bien entendu, mais aussi en base 8, donc en ne prenant que les chiffres de 0 à 7, en base 16, où nous avons besoins de chiffres supplémentaires au-delà du 9 (qui sont notés A, B, C, D, E et F) et... en base 2, où seuls les chiffres 0 et 1 sont utilisés.

Le pourquoi de ces bases sort du cadre de cet article. J'y reviendrai probablement une autre fois. Je ne vais pas non plus expliquer ici les conversions d'écritures entre ces bases.

Ces chiffres, 0 et 1 dont on va se servir se nomment chiffres binaires, en anglais Binary Digits, raccourcis en bit. C'est ce bit qui est mentionné dans les tableaux ci-dessus.

Les valeurs que nous avons obtenues sont, de part l'organisation de l'ordinateur, des valeurs entre 0 et 255, et il se trouve que ces valeurs peuvent toutes s'écrire avec 8 chiffres binaires. Cette organisation en groupe de 8 bits s'appelle en octet.

On reprend son souffle

Cela fait beaucoup de vocabulaire d'un coup. Alors reprenons. Les valeurs que nous avons obtenues avec PEEK :
- Sont toujours comprises entre 0 et 255,
- Peuvent s'écrire en base 2 avec 8 bits (chiffres binaires) maximum,
- Ces groupements de 8 bits, s'appellent des octets.
À quoi ressemblent ces deux valeurs écrites en base 2 ? Les voici :
- 79 (en base 10), s'écrit 01001111 (en base 2)
- 0 (en base 10), s'écrit 00000000 (en base 2)
Tout comme en base 10, le 0 en tête du 01001111 est optionnel, mais je les garde ici pour bien faire la différence entre les deux notations, et pour montrer que ces deux valeurs écrites en binaires s'associent parfaitement aux cases des tableaux ci-dessus.

Dernier petit détail, dans les tableaux, le rang du chiffre binaire commence par le rang 0, à droite, puis va jusqu`au rang 7, à gauche. Cela donne bien 8 chiffres/colonnes.

Décodage, enfin

On a maintenant tous les éléments pour comprendre les deux valeurs récupérées au début de cet article. Le premier octet, de valeur 79, écrit en base 2 et remis en place dans le tableau de décodage, donne ceci :

Bit 7 6 / 5 / 4 / 3 / 2 / 1 / 0

Contenu 0 1001111

Le second octet, de valeur 0, mis en base 2 et placé dans le tableau de décodage donne ceci :

Bit 7 6 5 4 3 2 / 1 / 0

Contenu 0 0 0 0 0 000

Ce qui se lit :
- Première valeur : il s'agit d'un caractère non étendu (bit 7 vaut 0) dont le numéro est 79
- Seconde valeur : il s'agit d'un caractère textuel, de hauteur et largeur normale, sans clignotement, et de couleur 0 (noir)
Un rapide coup d’œil sur la table de caractère nous renseigne que le caractère normal (non étendu) de rang 79 est le caractère O. Nous avons bien lu le O de Ok! en haut de l'écran.

Et maintenant, l'encodage

La commande pour modifier la valeur d'un emplacement mémoire, c'est-à-dire l'inverse de PEEK, est POKE. Cette commande prend un numéro d'emplacement mémoire et une valeur pour se charger de mettre cette valeur à cet emplacement mémoire.

Exemple rapide en faisant POKE &"4000"+2,80 pour voir que le O de Ok! se transforme en P.

Ce que je voudrais maintenant, c'est utiliser des caractères semi-graphiques pour tracer une ligne horizontale au milieu de l'écran. En reprenant la méthode décrite dans l'article sur la constitution des caractères semi-graphiques, je calcule que les deux pixels du milieu allumés donnent le caractère numéro 76, ce que je peux vérifier sur le tableau des caractères semi-graphiques.

D'après le calcul pour trouver l'emplacement mémoire du milieu de l'écran, ligne 12, colonne 0, j'obtiens 960, que je devrai ajouter à l'adresse de début de la mémoire vidéo &"4000".

Dans les 20 paires de valeurs à partir de cet emplacement, je dois placer le caractère semi-graphique numéro 76 (1001100 en binaire sur 7 bits) non étendu, sans clignotement, avec comme couleur de fond la couleur 6 (110 en binaire sur 3 bits) et la couleur d'encre 0 (000 en binaire sur 3 bits), qui sont les couleurs par défaut à l'allumage du VG5000µ (INIT 6).

Cela donne dans les tableaux d'encodage (qui sont toujours les mêmes) :

Bit 7 6 / 5 / 4 / 3 / 2 / 1 / 0

Contenu 0 1001100

Bit 7 6 / 5 / 4 3 2 / 1 / 0

Contenu 1 110 0 000

Soit, une fois convertis en base 10, les valeurs 76 et 224.

Et enfin, le programme
```
10 INIT 6           : REM On efface l'écran
20 P=&"4000"+960    : REM La variable P est positionnée en début de ligne 12
30 FOR X=1 TO 40    : REM On effectue 40 fois les instructions suivantes
40 POKE P,76        : REM La première valeur est 76
50 POKE P+1,224     : REM La valeur suivante est 224
60 P=P+2            : REM La variable P est avancée de 2, afin de traiter la paire suivante
70 NEXT X           : REM Fin des instructions à répéter 40 fois
```
Voici une belle ligne horizontale à base d'un caractère semi graphique choisi et positionné grâce à une série de calculs. Il n'y a plus long avant de pouvoir choisir directement quel point de l'écran afficher !
VG5000µ, SetPoint en BASIC, changements de repères (2017-03-15)
Après avoir fait un mini tour des commandes graphiques, puis étudié la structure des caractères semi-graphiques du VG5000µ, il est temps d'implémenter la possibilité d'allumer un point particulier de l'écran.

Comme je vais utiliser les caractères semi-graphiques, ce « point » sera sur la grille de résolution de 80 par 75. En effet, il y a 40 caractères par ligne qui ont chacun une largeur de deux éléments, et 25 caractères par colonne qui ont chacun trois éléments en hauteur.

L'idée pour allumer ou éteindre un point est donc d'abord de trouver quelle position de caractère semi-graphique est influencée, puis de modifier le caractère à cette position. Pour modifier le caractère, il faudra lire celui déjà présent, calculer le nouveau, puis écrire le nouveau.

Transformation de coordonnées

Pour visualiser la transformation de coordonnées, voici un tableau.
```
|-------------|-------------|-------------|-------------|-------------|
| (0,0) (1,0) | (1,0) (2,0) | (3,0) (4,0) | (5,0) (6,0) | ......
| (0,1) (1,1) | (1,1) (2,1) | (3,1) (4,1) | (5,1) (6,1) | ..... etc.
| (0,2) (1,2) | (1,2) (2,2) | (3,2) (4,2) | (5,2) (6,2) | ....
|    [0,0]    |    [1,0]    |    [2,0]    |    [3,0]    | ....
|-------------|-------------|-------------|-------------|------
| (0,3) (1,3) | (1,3) (2,3) | (3,3) (4,3) | (5,3) (6,3) |
| (0,4) (1,4) | (1,4) (2,4) | (3,4) (4,4) | (5,4) (6,4) |
| (0,5) (1,5) | (1,5) (2,5) | (3,5) (4,5) | (5,5) (6,5) |
|    [0,1]    |    [1,1]    |    [2,1]    |    [3,1]    |
|-------------|-------------|-------------|-------------|---
| (0,6) (1,6) | (1,6) (2,6) | (3,6) (4,6) | (5,6) (6,6) |
| (0,7) (1,7) | (1,7) (2,7) | (3,7) (4,7) | (5,7) (6,7) |
| (0,8) (1,8) | (1,8) (2,8) | (3,8) (4,8) | (5,8) (6,8) |
|    [0,2]    |    [1,2]    |    [2,2]    |    [3,2]    |
|-------------|-------------|-------------|-------------|-
|   .     .   |   .     .   |   .     .   |   .     .   | 
|   .     .   |   .     .   |   .     .   |   .     
|   .     .   |   .     .   |   .     .
```
Entre parenthèse, j'ai placé tous les couples de coordonnées qui nous intéressent. Entre crochet, j'ai placé les coordonnées du caractère correspondant.

Pour passer du premier système de coordonnées à l'autre, nous utilisons un outil mathématique très simple : la division. Prenez une coordonnée « gros pixel », divisez par 2 sa coordonnées X, divisez par 3 sa coordonnée Y (en arrondissant à l'entier inférieur), et vous obtenez les coordonnées du caractère semi-graphique à modifier.

Par exemple : (2, 7) devient (2÷2, 7÷3) ce qui fait (0, 2). Sept divisé par trois de manière entière faisant 2.

À présent que l'on sait trouver les coordonnées du caractère semi-graphique, il nous faut trouver lequel des six éléments est à modifier. Et pour cela, nous utilisons encore la division entière, mais cette fois en prenant son reste.

En continuant sur le même exemple : (2, 7) devient (reste de 2÷2, reste de 7÷3), ce qui fait (0, 1). C'est-à-dire l'élément de la colonne de gauche (0), sur la ligne du centre (1).

Pour transformer l’élément semi-graphique aux coordonnées (2, 7), il faudra donc allumer l'élément semi graphique de la colonne de gauche, ligne du centre, du caractère positionné aux coordonnées (0, 2).

Ce que nous venons de faire est un changement de repère.

Voici le même tableau avec l'élément exemple mis en évidence :
```
|-------------|-------------|-------------|-------------|-------------|
| (0,0) (1,0) | (1,0) (2,0) | (3,0) (4,0) | (5,0) (6,0) | ......
| (0,1) (1,1) | (1,1) (2,1) | (3,1) (4,1) | (5,1) (6,1) | ..... etc.
| (0,2) (1,2) | (1,2) (2,2) | (3,2) (4,2) | (5,2) (6,2) | ....
|    [0,0]    |    [1,0]    |    [2,0]    |    [3,0]    | ....
|-------------|-------------|-------------|-------------|------
| (0,3) (1,3) | (1,3) (2,3) | (3,3) (4,3) | (5,3) (6,3) |
| (0,4) (1,4) | (1,4) (2,4) | (3,4) (4,4) | (5,4) (6,4) |
| (0,5) (1,5) | (1,5) (2,5) | (3,5) (4,5) | (5,5) (6,5) |
|    [0,1]    |    [1,1]    |    [2,1]    |    [3,1]    |
|=============|-------------|-------------|-------------|---
I             I (1,6) (2,6) | (3,6) (4,6) | (5,6) (6,6) |
I       (1,7) I (1,7) (2,7) | (3,7) (4,7) | (5,7) (6,7) |
I             I (1,8) (2,8) | (3,8) (4,8) | (5,8) (6,8) |
I    [0,2]    I    [1,2]    |    [2,2]    |    [3,2]    |
|=============|-------------|-------------|-------------|-
|   .     .   |   .     .   |   .     .   |   .     .   | 
|   .     .   |   .     .   |   .     .   |   .     
|   .     .   |   .     .   |   .     .
```
Transformation du caractère

À présent que l'on connaît les coordonnées du caractère à modifier, il faut trouver un moyen de savoir quelle est sa valeur actuelle. Et là-dessus, le BASIC du VG5000µ ne nous aide pas. Il y bien une commande d'affichage à l'écran, PRINT, mais pas de commande spécifique pour connaître le caractère actuellement affiché à l'écran pour une position donnée.

Heureusement, cet article décrit l'arrangement en mémoire des informations d'affichage telles que gérées par le BASIC. Il est donc possible, moyennant un autre changement de coordonnées et de l'instruction PEEK du BASIC, d'obtenir cette information.

L'instruction PEEK prend en paramètre une adresse mémoire et renvoie son contenu sous la forme d'un octet, c'est-à-dire, d'un entier allant de 0 à 255. C'est une instruction, avec son pendant POKE qui permet de modifier le contenu d'une adresse mémoire, qui permet au BASIC d'interagir avec la machine au delà des instructions toutes faites. Nous y reviendrons dans d'autres articles.

En lisant l'article sur l'arrangement mémoire des informations écran, il est facile de convertir les coordonnées d'un caractère à l'écran en adresse mémoire. Chaque ligne prend 80 octets, il faut donc multiplier le numéro de la ligne par 80. Et chaque caractère prend deux octets sur une ligne, il faut donc multiplier le numéro de la colonne par 2.

Dans notre exemple, (0, 2) donne (0×2)+(2×80) = 160. L'emplacement est donc le 160ième depuis le début de la mémoire vidéo. Plus exactement 160ième et 161ième puisque chaque caractère prend deux octets. Encore un changement de repère.

Il reste donc à décoder cette information, la modifier et la replacer en mémoire. Ceci sera pour la prochaine fois.

Bit	7	6 / 5 / 4 / 3 / 2 / 1 / 0
Contenu	0	1001111

Bit	7	6	5	4	3	2 / 1 / 0
Contenu	0	0	0	0	0	000

Bit	7	6 / 5 / 4 / 3 / 2 / 1 / 0
Contenu	0	1001100

Bit	7	6 / 5 / 4	3	2 / 1 / 0
Contenu	1	110	0	000

VG5000µ, Arrangement de la mémoire vidéo (2017-03-08)

Cet article est la version française de cet autre que j'ai écrit suite à une demande d'aide dans le forum System.cfg forum. Je me suis dit que c'était le moment de mettre à plat mes notes, même si du coup cela cassait un peu la progression des articles en français sur l'affichage.

Cela donne un article un peu plus austère que d'habitude, et un peu plus dense.

Pour commencer, le processeur vidéo du VG5000µ est un EF9345. On peut y accéder de deux façons, soit en discutant directement, soit à travers la RAM lorsqu'on utilise le BASIC embarqué dans la machine. La manière directe est plus puissante, la seconde est plus simple.

Le signal de début d'affichage (Blank Start) du processeur vidéo est connecté à la broche d'interruption du Z80. Cela provoque une interruption IRQ qui, dans le mode dans lequel le BASIC initialise le Z80, fait un appel à l'adresse 0x0038 en tant qu'interruption.

La routine IRQ utilises des drapeaux (flags) pour décider si le contenu de la RAM doit être envoyé au EF9345. Pour cela, le moniteur regarde les valeurs en 0x47FA (compteur décrémenté jusqu'à 0), 0x47FB (force un rafraîchissement si différent de 0) et 0x47FC (valeur de référence pour le compteur en 0x47FA). En BASIC, cela correspond à la commande DISPLAY.

Si le rafraîchissement est enclenché, la mémoire vidéo est décodée et transférée au EF9345. Pour avoir une idée de comment est effectué cette opération, sur une version 1.1 du BASIC, cela commence à l'adresse 0x0056, puis un peu plus loin en 0x00bc et se termine en 0x018b. Le registre ix est toujours à la valeur 0x47fa lorsque le BASIC est en route. Il se sert de ce registre d'index pour repérer les variables d'affichage (ne touchez pas à ix si vous laissez le système BASIC gérer la vidéo, ou alors en masquant les interruptions).

La mémoire vidéo est de la mémoire RAM standard. Elle n'est pas branchée d'une manière spécifique et si vous voulez contrôler l'affichage vous même, vous pouvez utiliser n'importe quel endroit disponible et le format qui vous chante. L'arrangement utilisé par le BASIC en ROM, lui, commence en 0x4000. L'arrangement ligne/colonne est comme suit :

Offset (decimal)	Colonne 0	Colonne 1	Colonne 2	...	Colonne 38	Colonne 39
Ligne 0	+0/+1	+2/+3	+4/+5	...	+76/+77	+78/+79
Ligne 1	+80/+81	+82/+83	+84/+85	...	+156/+157	+158/+159
Ligne 2	+160/+161	+162/+163	+164/+165	...	+236/+237	+238/+239
...
Ligne 24	+1840/+1841	+1842/+1843	+1844/+1845	...	+1916/+1917	+1918/+1919
Ligne 25	+1920/+1921	+1922/+1923	+1924/+1925	...	+1996/+1997	+1998/+1999

Chaque unité affichable est codée sur une paire d'octets. Le premier octet contient principalement le numéro du caractère. Le second octet contient principalement ses attributs. La page de caractères est sélectionnée avec 1 bit dans chaque octet.

Le premier octet de la paire se présente comme suit :

Bit	7	6 / 5 / 4 / 3 / 2 / 1 / 0
Contenu	N (0)/E (1)	numéro du caractère

Le second octet de la paire se présente comme suit :

Bit	7	6	5	4	3	2 / 1 / 0
Contenu	TX (0)	Inverse vidéo	Largeur x2	Hauteur x2	Clignotement	Couleur
Contenu	GR (1)	Couleur ...	... de ...	... fond	Clignotement	Couleur

Grâce à N/E (Normal/Étendu) et TX/GR, la page de caractères est choisie. Cela correspond aux diverses sélection de caractères en BASIC. TX/Normal est TX, TX/Étendu est ET, GR/Normal est GR, GR/Étendu est EG. Le mode étendu permet de redéfinir les caractères. Le texte normal est ASCII, et le graphique normal contient les caractères semi-graphiques.

Comme vous pouvez le voir, il n'y a pas de moyen pour spécifier une couleur de fond en mode texte. La couleur de fond utilisée est la couleur de fond fixée par le dernier caractère graphique précédent sur la même ligne. C'est pour cela que lorsqu'on utilise la commande INIT du BASIC pour effacer l'écran, la colonne 0 est remplie avec un caractère graphique invisible ayant pour couleur de fond la couleur spécifiée. Et c'est aussi pour ça que le BASIC n'utilise pas la première colonne.

Un dernier mot: le EF9345 est beaucoup plus puissant que ce qui est induit par son utilisation par le VG5000µ. Vous pouvez trouver sur Internet des ressources pour l'utiliser en 80 colonnes, ou bien avec plus de 7 couleurs. Cela nécessite plus de travail car il faut alors communiquer directement avec le EF9345 à travers les ports I/O 0x8F et 0xCF du Z80.

Human Resource Machine, le jeu assembleur (2017-03-04)
Human Resource Machine est un jeu de Tomorrow Corporation de type résolution de défi. Ces défis se présentent tous sous la même formes : une série de chiffres et/ou lettres à transformer en une autre série de chiffres et/ou lettres, en fonction de directives.

Et pour cela, le joueur a à sa disposition une série de commandes. Au début, très peu, leur nombre s'étoffe au fur et à mesure des 42 niveaux de la ligne principale. Ces commandes sont exécutées par l'avatar du joueur, qui va courir d'un bout à l'autre d'une pièce pour prendre des données, les transformer, les ajoutes, les comparer, les stocker...

C'est ici que cela m'intéresse dans le cadre de Triceraprog. Le personnage que contrôle le joueur simule le fonctionnement d'un ordinateur (en parti). Le joueur au fur et à mesure de la résolution des puzzle apprend « tout simplement » un langage d'assemblage.

Un langage d'assemblage, ou langage assembleur, est un langage très proche des opérations effectuées par un processeur d'ordinateur. Résoudre des problèmes avec ce seul langage est assez fastidieux et c'est sur ce ressort que joue Human Resource Machine.

Le joueur a la possibilité de copier/coller les programmes du jeu, et ce qui est intéressant est que ce qui est sauvé dans le presse-papier ressemble à un vrai langage d'assemblage pour une machine inventée pour l'occasion. Voici un exemple de résolution d'un des premiers niveaux du jeu, copié dans un éditeur de texte :
```
-- HUMAN RESOURCE MACHINE PROGRAM --

a:
    INBOX   
    COPYTO   0
b:
c:
    INBOX   
    JUMPZ    e
    SUB      0
    JUMPN    d
    JUMP     c
d:
    ADD      0
    COPYTO   0
    JUMP     b
e:
    COPYFROM 0
    OUTBOX  
    JUMP     a
```
En termes plus clairs (attention soyez attentif !) :
1. le programme indique qu'il faut prendre une donnée dans celle qui se présentent en entrée (INBOX)
2. la copier dans une case mémoire nommée 0 (COPYTO 0)
3. puis prendre une autre donnée
4. aller à la ligne indiquer e: si cette donnée est égale à zéro (JUMPZ).
5. Dans le cas contraire, retrancher le contenu de la case 0 à la donnée courante (SUB 0)
6. Si le résultat est négatif, allez en d:
7. Sinon revenir en c:
8. Dans le cas où le résultat était négatif et que l'on est maintenant en d:, cela signifie que la nouvelle donnée était plus petite que celle dans la case 0.
9. La nouvelle donnée est rétablie (ADD 0... on ajoute ce qu'on avait retranché) et est mise dans la case 0.
10. On revient en b: pour lire une nouvelle donnée
11. Dans le cas où la donnée était égale à 0, on arrive en e:
12. La donnée présente dans la case 0 est copiée dans la sortie (COPYFROM 0 puis OUTBOX)
13. On reprend tout le depuis le début.
Plus clair ? Mouais... Et en français ? Voici : en entrée se trouvent des suites de nombres qui sont séparées par des 0 (zéro). Pour chaque série, le plus petit des nombres est recopié en sortie. Ce qui est exactement l'énoncé du défi.

Apprentissage ?

Je ne suis pas entièrement persuadé que le jeu soit didactique au point d'enseigner la programmation en assembleur. Cependant, il présente une manière de décrire des problèmes et fait ressentir ce qu'est la programmation de ce type.

Pour un programmeur déjà habitué à l'exercice, le jeu n'est pas très long. Je l'ai terminé en moins de 3 heures, à l'exception du dernier des puzzles optionnels, qui aurait été vraiment long à mettre au point, je n'en avais pas vraiment envie.

Je me demande cependant, pour quelqu'un qui n'est pas programmeur, si le jeu est intéressant et à quel point il est complexe.

Au final, un jeu sympathique avec une petite histoire amusante en fil rouge. Si vous voulez jouer à programmer en assembleur, ce jeu est fait pour vous.
Tramage basse définition pour le VG5000µ (2017-03-02)

La dernière fois, j'avais présenté le début d'une idée pour accéder à des pixels « basse définition » sur le VG5000µ en se servant de caractères semi-graphiques.

Avant de continuer sur l'idée, je me demandais ce que donnerais, sans trop de traitement, une image de synthèse en niveau de gris avec une telle technique.

Afin de transformer cette image en niveaux de gris vers du noir et blanc, je fais appel à une technique appelée « Dithering » ou « tramage » en français. Il s'agit de transformer le niveau de lumière en série de points plus ou moins dense.

Plus la résolution est dense, plus le résultat est bon. Forcément, en basse résolution semi-graphique, il ne faut pas s'attendre à des merveilles.

Voici donc deux couples d'images. En premier le rendu en niveau de gris d'une image de synthèse assez simple. Puis un rendu avec du tramage. Il existe de nombreuses techniques de tramages, et j'en utilise une parmi d'autre, pour me donner une idée grossière de ce que cela peut donner. Il ne s'agit pas là de rendu faits sur un VG5000µ, cela sera l'objectif suivant.

Un second but sera de faire sortir au VG5000µ une image en plus haute résolution. Mais pour cela, il faudra aller au-delà des caractères semi-graphiques.

Cela pourrait donner quelque chose comme ça.