Dans ce Chapitre, nous verrons comment faire pour utiliser
des écrans virtuels, en particulier pour obtenir des animations fluides,
dépourvues de clignotements désagréables dans l'affichage.
En effet, certaines fonctions, par exemple DrawStrXY,
sont lentes, et il peut être désagréable de voir un texte s'afficher
lentement, ligne par ligne ! Ici, nous verrons comment écrire ce texte sur un
écran invisible (Qualifié du terme d'écran virtuel, puisqu'il ne sera pas
pris en compte pour l'affichage), puis comment afficher cet écran, d'un seul
coup.
I:\ Théorie concernant l'utilisation d'écrans virtuels :
Tout au cours de ce Chapitre, nous utiliserons des écrans
virtuels alloués dynamiquement (Voir Chapitre
précédent). Cela nous permettra de ne pas avoir à prêter attention à la
quantité de mémoire utilisée sur la Stack. En effet, que ce soit sur TI-89 ou
TI-92plus, les écrans virtuels doivent faire 3840 octets. Vous comprendrez
aisément que, si vous en utilisez plusieurs (ne serait-ce que deux), en
association avec d'autres variables de taille importante, les 16ko du Stack
risquent d'être vite submergés !
De la même façon, si vous souhaitez utiliser des écrans
virtuels déclarés de façon globale pour tout le programme, chaque écran
virtuel déclaré fera prendre environ 4ko de plus à votre programme si vous ne
les allouez pas dynamiquement...
Voici comment nous ferons pour allouer un écran virtuel
en RAM :
void
*Vscreen1 = malloc(3840);
Ceci nous permet de créer un écran virtuel nommé
Vscreen1.
A présent, voyons il nous faut, pour pouvoir
l'utiliser, rediriger les fonctions graphiques vers celui-ci. Pour cela, il
convient d'utiliser la syntaxe suivante :
PortSet(Vscreen1, 239, 127);
Ainsi, l'écran virtuel en cours d'utilisation est à
présent Vscreen1.
Le premier argument que prend cette fonction est le nom de
l'écran. Le second correspond à la largeur de celui-ci, et le dernier à sa
hauteur. En général, il vous faudra utiliser un écran virtuel correspondant
à la taille de l'écran normal de la TI (C'est ce que nous avons fait ici.).
Mais cette fonction permet d'utiliser des écrans virtuels dont la taille n'est
pas forcément de 3840 pixels.
Maintenant, les fonctions graphiques du TIOS
écriront non plus à l'écran, mais sur cet écran virtuel.
Pour copier ce que contient cet écran virtuel vers l'écran
d'affichage, il vous faudra utiliser cette fonction :
memcpy(LCD_MEM, Vscreen1, 3840);
Il est aussi possible d'utiliser ceci, qui revient
exactement au même, sauf qu'il s'agit d'une fonction moins générale :
LCD_restore(Vscreen1);
Enfin, avant de quitter le programme, il faut
absolument penser à annuler les écrans virtuels, afin que le contrôleur
d'écran du TIOS recommence à fonctionner de manière correcte. pour cela, il
faut utiliser l'instruction suivante :
PortRestore();
Attention : l'oubli de cette fonction aura pour
conséquence des problèmes d'affichage après avoir quitté le programme !
Attention : Si, comme nous l'avons fait ici, vous avez alloué votre, ou vos, écran(s) dynamiquement, n'oubliez pas non plus d'utiliser la fonction free pour libérer les espaces mémoire utilisés...
II:\ Exemple d'utilisation d'un écran virtuel :
Nous allons ici partir d'un petit programme, qui affichera plusieurs fois à l'écran une simple chaîne de caractères. Nous l'étudierons en premier lieu comme nous l'avons fait jusqu'à présent, c'est-à-dire sans utiliser d'écran virtuel.
Voila le code source de la version n'utilisant pas
d'écran virtuel :
#define
OPTIMIZE_ROM_CALLS
#define SAVE_SCREEN
#include <tigcclib.h>
short _ti92plus,
_ti89;
void _main(void)
{
short i=0;
FontSetSys(F_6x8);
ClrScr();
for(i=0;
i<LCD_HEIGHT-8
; i++)
{
DrawStrXY(10,
i, "TCI : Salut
!!!", A_NORMAL);
}
ngetchx();
}
Comme vous pouvez le voir si vous exécutez le
programme, le résultat n'est pas beau à voir (mais le but ici n'est
heureusement pas d'obtenir de joli graphismes !!!). De plus, vous pouvez voir la
lenteur à laquelle se fait l'affichage...
A présent, regardons le même programme, mais utilisant
cette fois un écran virtuel :
#define
OPTIMIZE_ROM_CALLS
#define SAVE_SCREEN
#include <tigcclib.h>
short _ti92plus,
_ti89;
void _main(void)
{
void *Vscreen1
= malloc(3840);
// Déclaration dynamique
d'un écran virtuel.
short i=0;
FontSetSys(F_6x8);
PortSet(Vscreen1,
239, 127);
// On redirige les fonctions graphiques vers cet
écran virtuel.
ClrScr();
for(i=0;
i<LCD_HEIGHT-8
; i++)
{
DrawStrXY(10,
i, "TCI : Salut
!!!", A_NORMAL);
}
memcpy(LCD_MEM,
Vscreen1, 3840);
// On copie le contenu de
l'écran virtuel vers l'écran réel.
PortRestore();
// On annule l'utilisation
d'écran virtuel.
free(Vscreen1);
// On libère l'espace
mémoire qui avait été alloué pour l'écran virtuel.
ngetchx();
}
Comme vous pouvez à présent le voir, tout l'écran
est affiché d'un seul coup : on ne voit plus un affichage en lignes par lignes.
Par contre, il ne se passe rien sur l'écran réel pendant quelques temps : le
temps d'écrire sur l'écran virtuel !
En fait, l'idéal serait de créer une image sur un écran
virtuel, et, en même temps, afficher l'image précédente sur l'écran réel !
On aura ainsi des images qui s'enchaîneraient rapidement les unes aux autres !
III:\ Autres manipulations concernant les écrans virtuels :
Naturellement, il est possible d'utiliser plusieurs
écrans virtuels en même temps, ainsi que de les copier les uns vers les
autres.
Pour cela, il vous suffit d'en déclarer plusieurs, par
exemple de la façon suivante :
void
*Vscreen1 = malloc(3840);
void
*Vscreen2 = malloc(3840);
// Vous pouvez utiliser ces deux écrans virtuels...
// Si vous voulez copier le contenu de l'écran virtuel Vscreen1 vers Vscreen2,
il suffira d'utiliser ceci :
memcpy(Vscree2, Vscreen1,
3840);
// Vous pouvez ensuite continuer d'utiliser ces deux
écrans virtuels, comme vous le feriez en d'autres circonstances...
// Enfin, n'oubliez pas d'appeler PortRestore, et de libérer les espaces
mémoires occupés !
Pour créer un écran virtuel alloué dynamiquement, et
déclaré de façon globale (il sera donc utilisable dans tout le programme), il
convient de faire ceci :
void *Vscreen = NULL.
Cette ligne permet de déclarer l'écran virtuel. Elle
doit être placé avant la fonction _main, hors de toute fonction.
Ensuite, il faut allouer l'espace mémoire qui correspondra
à l'écran. Pour cela, il convient de placer la ligne suivante avant d'utiliser
l'écran virtuel, par exemple au début de la fonction _main :
Vscreen = malloc(3840);
Maintenant, vous pouvez utiliser votre écran virtuel
dans toutes les fonctions du programme, et la taille de celui n'est pas
augmentée de façon démesurée...
Voilà, j'espère que, maintenant, vous avez compris comment faire pour utiliser des écrans virtuels. C'est une opération assez simple, mais qui nécessite un peu d'entraînement, afin d'acquérir de précieuses habitudes dans ce domaine.
Copyright Squale92 & Verstand. Logo et sigle TCI® réservés. Développé pour MS Internet Explorer 5.0 en 1024x768 pixels. Page modifiée le