Jay Link A propos de l'Auteur: Jay Link a la vingtaine et vit à Springfield, dans l'Illinois. En plus de Linux, la randonnée de montagne et l'Aile Delta ont leur place parmi ses centres d'intérêts. Il administre le BBS Interlink (un fournisseur d'accès Internet non lucratif malgré lui) pendant le peu de temps libre qui lui reste et effectue divers emplois étranges pour payer le loyer. Ecrire à l'Auteur

Graphismes faciles : SVGAlib pour les débutants

Vous cherchez une bibliothèque graphique simple pour votre système Linux ? Dans ce cas, ne cherchez plus. SVGAlib offre une solution simple pour créer des applications graphiques et éliminer le galimatias du système X-Window. Si vous avez la moindre notion de programmation en C, vous pouvez utiliser SVGAlib.

SVGAlib est une bibliothèque graphique bas niveau pour Linux. Elle complète le langage C qui ne supporte pas le mode graphique.

Mais il existe de nombreux programmes graphiques écrits en C !

Oui, mais il font tous l'usage de bibliothèques externes. Le C seul peut seulement afficher du texte. Tout cela car les fonctions graphiques sont dépendantes du système et non portables. Des routines graphiques codées pour un système d'exploitation ne fonctionneront pas sur un autre sans être complètement réécrites. Par exemple, le code graphique écrit à l'origine pour DOS ou Windows est inutile sous Linux.

Pour réaliser des graphismes en C sous Linux, il est nécesaire d'utiliser un ensemble additionnel de fonctions natives à Linux. SVGAlib est une des possibilités.

Le système X Window (XFree86) est en fait un serveur. Ce serveur doit être lancé avant chaque application qui l'utilise. De plus, le serveur X est une application nécessitant de la puissance (il faut lire : il se goinfre de ressources systèmes) et il pourra vous empêcher d'utiliser vos terminaux virtuels (Alt 1-6).

SVGAlib, au contraire, ne nécessite rien de tel. Vous ne "lançez" pas SVGAlib comme X Window. SVGAlib est simplement une bibliothèque compilée qui peut être appelée par les programmes C, comme toutes les bibliothèques des répertoires /lib et /usr/lib. Si SVGAlib est correctement installée, l'utilisateur moyen ne devrait même pas être conscient de son existence. Enfin SVGAlib ne touche pas à vos terminaux virtuels, vous laissant libre de lancer plusieurs applications comme vous en avez l'habitude. Vous pouvez avoir un terminal texte et un écran graphique sur un autre.

Limitations

Il y a beaucoup plus d'applications disponibles pour X Window qu'il n'y en a pour SVGAlib, car X Window est multi plateforme (il fonctionne sur de nombreux Unix). Seul Linux utilise SVGAlib. Il se peut également que des applications SVGAlib mal écrites puissent bloquer votre console et forcer un redémarrage. Enfin vous ne devrez pas basculer trop rapidement entre deux consoles utilisant SVGAlib, ou vous risquerez de corrompre l'écran (ce qui conduira également au reboot).

Pourtant, il est faux de considérer SVGAlib comme un risque pour la sécurité. Les applications SVGAlib doivent être setuid root, mais ce privilège est abandonné immédiatement après le chargement. Il n'y a pas lieu de s'inquiéter.

En résumé, malgré les problèmes mentionnés ci-dessus, la simplicité d'usage de SVGAlib et sa rapidité la rendent attractive dans de nombreuses situations, en particulier si vous voulez juste faire des affichages simples.

Exemples

Pour utiliser SVGAlib, vous devez la référencer dans votre programme C Ajoutez simplement #include <vga.h> . Voici un programme SVGAlib parmi les plus simples qui puissent exister : Télécharger

#include  <stdio.h>
#include  <vga.h>

int main(void) {
   vga_init();
   vga_setmode(5);
   vga_setcolor(4);
   vga_drawpixel(10,10);

   sleep(5);
   vga_setmode(0);
   exit(0);
}

Ceci affiche un simple pixel rouge sur votre écran. Après cinq secondes, il réinitialise la console en mode texte et quitte.

Remarquez la première instruction, vga_init(). Elle abandonne les privilèges root et initialise la bibliothèque SVGAlib. La deuxième ligne, vga_setmode(5), passe l'écran en mode 5 qui correspond à 320x200x256. Ce qui veut dire que votre écran devient une grille large de 320 pixels et haute de 200, en 256 couleurs. il était également possible d'écrire vga_setmode(G320x200x256), les deux instructions sont correctes. Notre instruction suivante, vga_setcolor(4), positionne la couleur courante à rouge. Les valeurs possibles vont de 0 à 255. D'autres couleurs sont accessibles par d'autres commandes, mais nous en resterons à ces couleurs de base pour cet exemple. Finalement, nous affichons notre pixel aux coordonnées 10,10. On compte onze espaces à droite de la bordure gauche de l'écran et onze espaces vers le bas. Onze et pas dix parce que la grille des coordonnées commence à 0. Le point de coordonnées 0,0 est dans le coin supérieur gauche. vga_setmode(0) replace l'écran en mode texte. vga_setmode(0) est équivalent à vga_setmode(0). Il est toujours utile de placer cette commande à la fin de vos programmes. Dans le cas contraire, vous rendrez la vie difficile à vos utilisateurs.

Pour compiler ce code, utilisez le compilateur gcc habituel. Vous devrez également lier votre exécutable avec SVGAlib avec l'option -lvga. Enfin, je suggère d'ajouter -O3, le degré d'optimisation le plus efficace. Voici alors notre commande :

gcc -O3 -o sample sample.c -lvga

Maintenant, pour le rendre utilisable par des utilisateurs non-roots, tapez :

chmod u+s

Pour exécuter, tapez simplement :

sample     <ou le nom que vous avez choisi>

Toutes les fonctions de SVGAlib sont documentées dans la page de manuel SVGAlib. Nous ne les passerons pas toutes en revue ici. Nous allonz plutôt réaliser un deuxième programme d'exemple en utilisant en jeu de fonctions SVGAlib plus rapides : vgagl.

Tapez "man vgagl", et vous verrez que vgagl est "une bibliothèque graphique rapide basée sur SVGAlib accédant aux blocs de mémoire vidéo". Plus clairement, elle offre des fonctions graphiques avancées, par exemple des fonctions de tracé de formes géométriques.

Ci-dessous suit un programme qui utilise vgagl. Il affiche un écran bleu en dégradés, semblable à celui que présentent de nombreux programmes d'installation. Il commence par un bleu clair en haut de l'écran qu'il fonçe progressivement au fur et à mesure qu'il descend. Une première différence avec le premier programme : L'affichage s'effectue sur un "écran virtuel" invisible. quand toutes les lignes ont été tracées, l'image finale est copiée d'un seul coup vers l'écran "physique". Celà élimine les papillottements et donne un look bien plus professionnel à votre application. J'aime voir l'écran virtuel comme une coulisse où les décors sont montés entre deux scènes du spectacle.

Pour compiler, je conseille de taper :

gcc -O3 -o gradient gradient.c -lvgagl -lvga

Remarquez que -lvgagl vient avant -lvga. Il est nécessaire de faire référence à vgagl en premier lorsque vous utilisez cette bibliothèque. Avez vous pensé à faire le chmod u+s ?

Voici le code: Télécharger

#include <stdio.h>  
#include <stdlib.h>
#include <vga.h>
#include <vgagl.h>

GraphicsContext *physicalscreen;
GraphicsContext *virtualscreen;

int main(void) {
   int i,  j,  b,  y,  c;

   vga_init();
   vga_setmode(5);
   gl_setcontextvga(5);
   gl_setcontextvgavirtual(5);
   physicalscreen = gl_allocatecontext();
   gl_getcontext(physicalscreen);
   virtualscreen = gl_allocatecontext();
   gl_getcontext(virtualscreen);

   y = 0;
   c = 0;
   gl_setpalettecolor(c, 0, 0, 0);
   c++;
   for (i = 0; i < 64; i++) {
      b = 63 - i;
      gl_setpalettecolor(c, 0, 0, b);
      for (j = 0; j < 3; j++) {
         gl_hline(0, y, 319, c);
         y++;
      }
      c++;
   }
   gl_copyscreen(physicalscreen);

   getchar();
   gl_clearscreen(0);
   vga_setmode(0);
   exit(0);
}
	  

Remarquez que nous devons maintenant inclure vgagl.h.

Le code commence par l'initialisation du contexte graphique :

GraphicsContext *physicalscreen
GraphicsContext *virtualscreen

Ensuite nous déclarons nos variables et appelons vga_setmode() pour configurer le mode graphique. Nous utiliserons 5 (G320x200x256) comme précédemment.

Nous avons besoin d'initialiser l'écran "physique", visible, tout comme l'écran "virtuel", invisible. Nous sauvegardons les contextes obtenus dans des variables :

gl_setcontextvga(5)
gl_setcontextvgavirtual(5)
physicalscreen = gl_allocatecontext()
gl_getcontext(physicalscreen)
virtualscreen = gl_allocatecontext()
gl_getcontext(virtualscreen)

Nous annonçons maintenant que nous allons travailler sur l'écran virtuel : gl_setcontext(virtualscreen).

gl_setpalettecolor() nous offre 64 intensités de bleu. Nous allons tracer 3 lignes par teinte, soit au total 192 lignes. Les huit lignes restantes seront déjà noires et l'on ne remarquera rien.

Une fois le tracé accompli, nous copions le contenu de l'écran virtuel (notre écran courant) vers l'écran physique avec gl_copyscreen(physicalscreen).

Cette fois, nous allons laisser l'utilisateur décider combien de temps l'image restera visible. getchar() attend une entrée au clavier. Après avoir reçu la notification de la frappe d'une touche (n'importe laquelle, ça n'a pas d'importance), nous effaçons l'écran avec gl_clearscreen(0) et utilisons vga_setmode(0) pour retourner en mode texte.

La liste complète des fonctions de SVGAlib peut être consultée tapant "man svgalib" et "man vgagl". Puis chaque fonction a sa propre page de manuel. Après avoir lu cette introduction, vous devriez être capable d'utiliser de nouvelles commandes dans vos propres programmes avec une relative facilité. Vous pouvez également apprendre grâce aux programmes de démonstrations fournis avec SVGAlib.

Si vous pensez que votre distribution est incomplète, vous pouvez trouver la dernière version de SVGAlib sur sunsite.unc.edu dans le répertoire /pub/Linux/libs/graphics ou bien sur tsx-11.mit.edu dans /pub/linux/sources/libs. A la date de rédaction, la version courante était la 1.3.0.

Enfin, la distribution Slackware, malgré sa qualité, a tendance à installer SVGAlib dans de mauvais répertoires. Obtenir et installer une nouvelle distribution de SVGAlib sur Sunsite ou MIT résoudra le problème.

Texte original soumis en anglais, traduction française par Cyril M. Hansen.