|
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
|
| |
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) :

Et 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 :

(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
|
|