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 XIV


   Ce chapitre va nous permettre d'apprendre comment faire des dessins en niveaux de gris. (En 4 niveaux de gris, pour être plus précis, car TIGCC ne permet pas d'accéder aux 7 niveaux de gris, qui ne sont pas stables sur HW2...).
    Pour cela, nous étudierons tout d'abord les fonctions qui sont à la base de l'utilisation des niveaux de gris, puis nous verrons quelques exemples, qui reprendront, pour certains, les fonctions que nous avons appris au Chapitre VI (Version TI-92plus - Version TI-89).

    Si vous souhaitez avoir plus d'informations sur la façon dont les 4 niveaux de gris fonctionnent, je vous encourage à visiter cette page.

    Les fonctions traitant des niveaux de gris, qui sont décrites dans la première partie de ce chapitre, sont localisées dans la librairie de TIGCC nommée <gray.h>.

 

I:\ Utilisation des niveaux de gris :

    Pour pouvoir utiliser les 4 niveaux de gris (appelés "grayscales" en anglais) sous TIGCC, il faut tout d'abord les activer. Pour cela, il faut utiliser l'instruction suivante :
        GrayOn();
    Cette instruction permettra d'utiliser les niveaux de gris dans la suite du programme. Elle renvoie un short, qui a pour valeur TRUE si les 4 niveaux de gris ont bien été activés, et FALSE s'ils ne l'ont pas été.

    Après avoir utilisé les niveaux de gris dans un programme, il ne faut pas oublier de les désactiver avant de quitter ce programme. En effet, comme vous avez sans doute pu le remarquer, le TIOS n'utilise jamais de niveaux de gris. Ainsi, oublier de les désactiver à la fin d'un programme a de grandes chances de planter la TI...
    Pour les désactiver, il faut utiliser l'instruction suivante :
        GrayOff();
    Étant donné que cette fonction est équivalente à la précédente, elle renverra exactement la même chose...

    Il existe une fonction qui permet de savoir si les niveaux de gris sont activés ou non. Sa syntaxe est la suivante :
        IsGrayMode();
    Cette fonction renvoie une valeur de type short, qui est égale à TRUE si les niveaux de gris sont actifs, et à FALSE dans le cas contraire.

    Nous avons dit dans la page qui explique comment fonctionnent les niveaux de gris qu'il fallait utiliser deux plans : LIGHT_PLANE pour le gris clair, et DARK_PLANE pour le gris foncé. Pour sélectionner le plan actif, il convient d'utiliser la fonction suivante :
        SetPlane(nom_du_plan);
    nom_du_plan peut, comme vous vous en doutez, prendre pour valeur LIGHT_PLANE et DARK_PLANE.

    La fonction suivante permet de déterminer quel est l'adresse du plan actif :
        void *GetPlane(nom_du_plan);
    Cette fonction prend en argument le nom_du_plan, qui peut avoir les mêmes valeurs que pour la fonction SetPlane, et renvoie un pointeur de type void vers le plan actif. (Cette fonction sera très utilisée plus tard, dans la manipulation des sprites en niveaux de gris).

    Si vous avez une HW2, vous avez sans aucun doute remarqué que, parfois, les graphismes en niveaux de gris avaient tendance à clignoter énormément... TIGCC permet de limiter un peu ce clignotement. pour cela, il faut utiliser la méthode développée par JM dans le programme Adjust (livré avec les anciennes version d'UniversalOS), qui consiste à modifier la fréquence de rafraîchissement de l'écran. Pour cela, il faut utiliser la fonction suivante :
        GrayAdjust(valeur_ajustée);
    Cette fonction prend en argument un short, dont la valeur va de -28 à 127 sur TI-89, et de 0 à 127 sur TI-92plus. Attention, les valeurs inférieures à 0 ne sont pas supportées sur TI-92plus, et pourraient poser des problèmes. (C'est là que certaines des pseudo-constantes définies au Chapitre XIII peuvent s'avérer utiles, pour détecter de quelle calculatrice il s'agit !)
    La valeur par défaut pour valeur_ajustée est de 0, ce qui correspond aux réglages d'usine. Les valeurs inférieures à 0 permettent d'augmenter la fréquence de rafraîchissement, tandis que celles positives permettent de la diminuer.
    Il vous faut savoir que la fréquence de rafraîchissement de l'écran restera celle que vous fixerez par cette fonction jusqu'à ce que la TI soit éteinte : le fait de l'allumer a pour conséquence une réinitialisation de cette valeur aux paramètres d'usine.
    Attention : depuis la version 0.9 (ou 0.91, je ne sais pas exactement) de TIGCC, les graphismes en niveaux de gris devraient poser beaucoup moins de clignotements que précédemment, en particulier sur HW2.

 

 

II:\ Graphismes en niveaux de gris :

    Pour afficher des graphismes en niveaux de gris, il vous suffit d'afficher ceux-ci sur le ou les plan(s) correspondant à la couleur qu'ils doivent avoir.

 

        A: Premier exemple :

    Le plus simple pour expliquer le fonctionnement des 4 niveaux de gris est de prendre un premier exemple. Le programme que nous allons étudier pour cela dessine 3 (ou 4, selon le point de vue) rectangles (blanc, gris clair, gris foncé, noir) à l'écran, et écrit à coté comment ils ont été formés...
    Voici le source de ce programme :

#define SAVE_SCREEN
#include <tigcclib.h>

short _ti92plus, _ti89;

void _main(void)
{
  short i=0;
 
if(!GrayOn()) return;
// Déclare la variable i, qui servira pour les boucles à compteur, puis active les niveaux de gris, et quitte en cas d'erreur lors de leur activation...

  FontSetSys(F_4x6);

  SetPlane(LIGHT_PLANE);
  ClrScr();
  DrawStrXY(20, 3,
"Pas de Plan actif", A_NORMAL);
// Permet d'effacer le plan correspondant au gris clair, et d'y écrire la chaîne de caractères "Pas de plan actif".

  SetPlane(DARK_PLANE);
  ClrScr();
  DrawStrXY(20, 3, "Pas de Plan actif", A_NORMAL);
// Permet d'effacer le plan correspondant au gris foncé, et d'y écrire la chaîne de caractères "Pas de plan actif".

  ngetchx(); // Permet d'observer le résultat. "Pas de plan actif" étant inscrit sur les deux plans, il apparaîtra à l'écran en noir.

  SetPlane(LIGHT_PLANE);
 
for(i=11 ; i<=20 ; i++)
  {
   
DrawLine(0, i, 18, i, A_NORMAL);
  }
 
DrawStrXY(20, 14, "LIGHT_PLANE actif", A_NORMAL);
  ngetchx();
// Permet de dessiner un rectangle sur le plan des gris clairs, ainsi qu'une chaîne de caractères. Puis, observation du résultat...

  SetPlane(DARK_PLANE);
 
for(i=22 ; i<=31 ; i++)
  {
   
DrawLine(0, i, 18, i, A_NORMAL);
  }
 
DrawStrXY(20, 25, "DARK_PLANE actif", A_NORMAL);
  ngetchx();
// Permet de dessiner un rectangle sur le plan des gris foncés, ainsi qu'une chaîne de caractères. Puis, observation du résultat...

  SetPlane(LIGHT_PLANE);
 
for(i=33 ; i<=42 ; i++)
  {
   
DrawLine(0, i, 18, i, A_NORMAL);
  }
 
DrawStrXY(20, 36, "LIGHT_PLANE et DARK_PLANE actifs", A_NORMAL);
  SetPlane(DARK_PLANE);
 
for (i=33 ; i<=42 ; i++)
  {
   
DrawLine(0, i, 18, i, A_NORMAL);
  }
 
DrawStrXY(20, 36, "LIGHT_PLANE et DARK_PLANE actifs", A_NORMAL);
  ngetchx();
// Permet de dessiner un rectangle ainsi qu'une chaîne de caractères sur le plan correspondant au gris clair, puis sur celui correspondant au gris foncé. Ainsi, le résultat apparaîtra en noir, car il sera affiché en permanence à l'écran.

 
GrayOff();
// Permet de désactiver les niveaux de gris, chose qu'il est impératif de faire avant de quitter le programme.
}

    Et voici le résultat : 
Sur TI-92plus (HW1) :

Niveaux de gris sur TI-92plus (HW1)

Et sur TI-89 (HW2) :

Niveaux de gris sur TI-89 (HW2)

    Si vous souhaitez voir comment il est possible d'optimiser légèrement un programme utilisant des niveaux de gris afin qu'il prenne un peu moins de place en mémoire, je vous conseiller de visiter cette page...

 

        B: Second exemple :

    Le programme qui va nous servir de second exemple pour ce chapitre constitue une "reprise" d'une partie de l'exemple utilisé au Chapitre VI (Version TI-92+ // Version TI-89). Celui-ci dessinait plusieurs écrans en noir et blancs... et maintenant, la version qui nous est proposée ici dessine le premier de ceux-ci, en niveaux de gris...
    Au Chapitre VI, nous avions été forcé de faire une version pour chaque calculatrice, à cause des tailles différentes d'écran... Cette fois, nous avons utilisé ce que nous avons appris au Chapitre XIII concernant les pseudo-constantes, afin de ne faire qu'une seule version, qui fonctionne sur les deux calculatrices...

#define OPTIMIZE_ROM_CALLS
#define SAVE_SCREEN
#include <tigcclib.h>

short _ti92plus, _ti89;

void _main(void)
{
  short i=0;
  GrayOn();

  SetPlane(LIGHT_PLANE);
  ClrScr();
  SetPlane(DARK_PLANE);
  ClrScr();
 
for(i=0 ; i<=LCD_HEIGHT ; i++)
  {
    SetPlane(LIGHT_PLANE);
    DrawLine(0, 0, LCD_WIDTH,LCD_HEIGHT-i, A_XOR);
    DrawLine(LCD_WIDTH, 0, 0, LCD_HEIGHT-i, A_XOR);
    SetPlane(DARK_PLANE);
    DrawLine(0, LCD_HEIGHT, LCD_WIDTH, i, A_XOR);
    DrawLine(LCD_WIDTH, LCD_HEIGHT, 0, i, A_XOR); 
  }
 
ngetchx();
  GrayOff();
}

Et voici le résultat :

Niveaux de gris sur TI-89 (HW2) : Second exemple.

(Je n'ai placé ici qu'un screenshot de TI-89, mais le résultat serait semblable sur TI-92plus, en plus grand :-) ).

 

    Je ne vais pas allonger ce chapitre plus que nécessaire : je pense que vous avez maintenant compris comment utiliser les 4 niveaux de gris sous TIGCC... La seule chose que je puisse à présent rajouter et que vous pouvez utiliser toutes les fonction définies dans la librairies <graph.h> avec les niveaux de gris : il suffit de les afficher sur le bon plan... 

Retour au menu général

Chapitre XV


 


Copyright © Ti-Fr v2.0 1999-2002