Home   Archives    Hardware   Programmation   Challenges   Forum   Le Mag    Faq   La Communauté   L'Equipe
 
L'équipe progG de Ti-Fr

Voici les nicks de vos serviteurs ;-)

chickensaver_john
Kevin Kofler
Thibaut
janjan2
TiMad
Iceman89
fréka
Zewoo
Squale92
Verstand
ZdRUbAl
UtOpIaH

et nEUrOne ...

Une idée ?
Une idée pour améliorez cette partie? ou tout simplement vous souhaitez participer à l'élaborations des tutos.
Mailez-nous ici

Les raccourcis
 

Chapitre XXI


    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.

Retour au menu général

Chapitre XXII


 


Copyright © Ti-Fr v2.0 1999-2002